claude-code.ts

import {
  CodifyCliSender,
  CreatePlan,
  DestroyPlan,
  ExampleConfig,
  ModifyPlan,
  ParameterChange,
  Resource,
  ResourceSettings,
  getPty,
  z,
} from '@codifycli/plugin-core';
import { OS } from '@codifycli/schemas';
import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';

import { McpServersParameter } from './mcp-servers-parameter.js';
import { SettingsParameter } from './settings-parameter.js';

const CLAUDE_DIR = path.join(os.homedir(), '.claude');
const CLAUDE_MD_PATH = path.join(CLAUDE_DIR, 'CLAUDE.md');

const mcpStdioServerSchema = z.object({
  name: z.string().describe('Unique name for this MCP server'),
  type: z.literal('stdio'),
  command: z.string().describe('Executable or command to launch the server process'),
  args: z.array(z.string()).optional().describe('Arguments to pass to the command'),
  env: z.record(z.string(), z.string()).optional().describe('Environment variables for the server process'),
});

const mcpHttpServerSchema = z.object({
  name: z.string().describe('Unique name for this MCP server'),
  type: z.literal('http'),
  url: z.string().describe('URL of the HTTP (streamable-http) MCP server'),
  headers: z.record(z.string(), z.string()).optional().describe('HTTP headers sent with every request'),
});

const mcpSseServerSchema = z.object({
  name: z.string().describe('Unique name for this MCP server'),
  type: z.literal('sse'),
  url: z.string().describe('URL of the SSE MCP server (deprecated transport; prefer http)'),
  headers: z.record(z.string(), z.string()).optional().describe('HTTP headers sent with every request'),
});

export const mcpServerSchema = z.discriminatedUnion('type', [
  mcpStdioServerSchema,
  mcpHttpServerSchema,
  mcpSseServerSchema,
]);

export type McpServer = z.infer<typeof mcpServerSchema>;

const schema = z
  .object({
    globalClaudeMd: z
      .string()
      .optional()
      .describe(
        'Content for ~/.claude/CLAUDE.md. Accepts inline text, an https:// URL, or a ' +
        'codify:// cloud URL (e.g. codify://documentId:fileId). Claude Code reads this at ' +
        'the start of every session.',
      ),
    settings: z
      .record(z.string(), z.unknown())
      .optional()
      .describe(
        'Settings to merge into ~/.claude/settings.json. Supports model, effortLevel, ' +
        'editorMode, permissions, env, hooks, and all other Claude Code settings.',
      ),
    mcpServers: z
      .array(mcpServerSchema)
      .optional()
      .describe('MCP servers to register globally in ~/.claude.json.'),
  })
  .meta({ $comment: 'https://codifycli.com/docs/resources/claude-code/claude-code' })
  .describe('Claude Code installation and configuration management');

export type ClaudeCodeConfig = z.infer<typeof schema>;

const defaultConfig: Partial<ClaudeCodeConfig> = {
  mcpServers: [],
};

const exampleSettings: ExampleConfig = {
  title: 'Claude Code with custom settings',
  description: 'Install Claude Code and configure model selection, editor mode, and shell permissions.',
  configs: [
    {
      type: 'claude-code',
      settings: {
        model: 'claude-opus-4-7',
        effortLevel: 'high',
        editorMode: 'vim',
        permissions: {
          allow: ['Bash(npm run *)', 'Bash(git *)'],
          deny: ['Bash(rm -rf *)'],
        },
      },
    },
  ],
};

const exampleWithMcp: ExampleConfig = {
  title: 'Claude Code with global instructions and MCP',
  description: 'Install Claude Code, set global instructions via CLAUDE.md, and wire up an MCP server.',
  configs: [
    {
      type: 'claude-code',
      globalClaudeMd:
        '# Global Instructions\n\nAlways follow security best practices.\nPrefer TypeScript over JavaScript.',
      mcpServers: [
        {
          name: 'filesystem',
          type: 'stdio',
          command: 'npx',
          args: ['-y', '@modelcontextprotocol/server-filesystem', '/tmp'],
        },
      ],
    },
  ],
};

export class ClaudeCodeResource extends Resource<ClaudeCodeConfig> {
  getSettings(): ResourceSettings<ClaudeCodeConfig> {
    return {
      id: 'claude-code',
      defaultConfig,
      exampleConfigs: {
        example1: exampleSettings,
        example2: exampleWithMcp,
      },
      operatingSystems: [OS.Darwin, OS.Linux],
      schema,
      parameterSettings: {
        globalClaudeMd: { canModify: true },
        settings: { type: 'stateful', definition: new SettingsParameter(), order: 1 },
        mcpServers: { type: 'stateful', definition: new McpServersParameter(), order: 2 },
      },
    };
  }

  async refresh(parameters: Partial<ClaudeCodeConfig>): Promise<Partial<ClaudeCodeConfig> | null> {
    const claudeBin = path.join(os.homedir(), '.local', 'bin', 'claude');
    try {
      await fs.access(claudeBin);
    } catch {
      return null;
    }

    const result: Partial<ClaudeCodeConfig> = {};

    if (parameters.globalClaudeMd != null) {
      if (isRemoteUrl(parameters.globalClaudeMd)) {
        result.globalClaudeMd = parameters.globalClaudeMd;
      } else {
        try {
          result.globalClaudeMd = await fs.readFile(CLAUDE_MD_PATH, 'utf8');
        } catch {
          result.globalClaudeMd = undefined;
        }
      }
    }

    return result;
  }

  async create(plan: CreatePlan<ClaudeCodeConfig>): Promise<void> {
    const $ = getPty();

    await $.spawn(
      'bash -c "curl -fsSL https://claude.ai/install.sh | bash"',
      { interactive: true },
    );

    // Ensure PATH is updated so subsequent lifecycle methods can call `claude`
    const localBin = path.join(os.homedir(), '.local', 'bin');
    process.env['PATH'] = `${localBin}:${process.env['PATH'] ?? ''}`;

    if (plan.desiredConfig.globalClaudeMd) {
      await this.writeClaudeMd(plan.desiredConfig.globalClaudeMd);
    }
  }

  async modify(
    pc: ParameterChange<ClaudeCodeConfig>,
    plan: ModifyPlan<ClaudeCodeConfig>,
  ): Promise<void> {
    if (pc.name === 'globalClaudeMd') {
      const newValue = plan.desiredConfig.globalClaudeMd;
      if (newValue) {
        await this.writeClaudeMd(newValue);
      } else {
        await fs.rm(CLAUDE_MD_PATH, { force: true });
      }
    }
  }

  async destroy(plan: DestroyPlan<ClaudeCodeConfig>): Promise<void> {
    if (plan.currentConfig.globalClaudeMd) {
      await fs.rm(CLAUDE_MD_PATH, { force: true });
    }

    // Native uninstall: remove the binary and version files
    await fs.rm(path.join(os.homedir(), '.local', 'bin', 'claude'), { force: true });
    await fs.rm(path.join(os.homedir(), '.local', 'share', 'claude'), { recursive: true, force: true });
  }

  private async writeClaudeMd(content: string): Promise<void> {
    await fs.mkdir(CLAUDE_DIR, { recursive: true });
    const resolved = await resolveClaudeMdContent(content);
    await fs.writeFile(CLAUDE_MD_PATH, resolved, 'utf8');
  }
}

function isRemoteUrl(value: string): boolean {
  return value.startsWith('https://') || value.startsWith('http://') || value.startsWith('codify://');
}

async function resolveClaudeMdContent(content: string): Promise<string> {
  if (content.startsWith('codify://')) {
    const regex = /codify:\/\/(.*):(.*)/;
    const [, documentId, fileId] = regex.exec(content) ?? [];
    if (!documentId || !fileId) {
      throw new Error(`Invalid codify URL for claudeMd: ${content}`);
    }
    const credentials = await CodifyCliSender.getCodifyCliCredentials();
    const response = await fetch(`https://api.codifycli.com/v1/documents/${documentId}/file/${fileId}`, {
      headers: { Authorization: `Bearer ${credentials}` },
    });
    if (!response.ok) {
      throw new Error(`Failed to fetch claudeMd from ${content}: ${response.statusText}`);
    }
    return response.text();
  }

  if (content.startsWith('https://') || content.startsWith('http://')) {
    const response = await fetch(content);
    if (!response.ok) {
      throw new Error(`Failed to fetch claudeMd from ${content}: ${response.statusText}`);
    }
    return response.text();
  }

  return content;
}