@ebowwa/claude-code-config-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,1744 @@
+#!/usr/bin/env bun
+// ============================================================================
+// Claude Code Config MCP Server
+// ============================================================================
+// Manage Claude Code configuration files with atomic writes, validation,
+// and comprehensive error handling.
+// ============================================================================
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { join, resolve } from 'node:path';
+import * as path from './utils/path.js';
+import { getMCPConfigPaths } from './utils/path.js';
+import * as file from './utils/file.js';
+import * as errors from './utils/errors.js';
+// ============================================================================
+// MCP Server Setup
+// ============================================================================
+const server = new Server({
+    name: '@mcp/claude-code-config',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+/**
+ * List all available tools
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        // CLAUDE.md tools
+        {
+            name: 'read_global_claude_md',
+            description: 'Read the global CLAUDE.md file (~/.claude/CLAUDE.md)',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'write_global_claude_md',
+            description: 'Write to the global CLAUDE.md file (~/.claude/CLAUDE.md). Creates backup before writing.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    content: {
+                        type: 'string',
+                        description: 'Content to write to CLAUDE.md',
+                    },
+                    createBackup: {
+                        type: 'boolean',
+                        description: 'Create backup before writing (default: true)',
+                        default: true,
+                    },
+                },
+                required: ['content'],
+            },
+        },
+        {
+            name: 'read_project_claude_md',
+            description: 'Read the project-local CLAUDE.md file (.claude/CLAUDE.md)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    projectPath: {
+                        type: 'string',
+                        description: 'Project directory path (default: current working directory)',
+                    },
+                },
+            },
+        },
+        {
+            name: 'write_project_claude_md',
+            description: 'Write to the project-local CLAUDE.md file (.claude/CLAUDE.md). Creates backup before writing.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    content: {
+                        type: 'string',
+                        description: 'Content to write to CLAUDE.md',
+                    },
+                    projectPath: {
+                        type: 'string',
+                        description: 'Project directory path (default: current working directory)',
+                    },
+                    createBackup: {
+                        type: 'boolean',
+                        description: 'Create backup before writing (default: true)',
+                        default: true,
+                    },
+                },
+                required: ['content'],
+            },
+        },
+        // Keybindings tools
+        {
+            name: 'read_keybindings',
+            description: 'Read the keybindings.json file',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'write_keybindings',
+            description: 'Write to keybindings.json. Validates the structure before writing.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    keybindings: {
+                        type: 'object',
+                        description: 'Keybindings configuration object',
+                    },
+                    createBackup: {
+                        type: 'boolean',
+                        description: 'Create backup before writing (default: true)',
+                        default: true,
+                    },
+                },
+                required: ['keybindings'],
+            },
+        },
+        {
+            name: 'add_keybinding',
+            description: 'Add or update a single keybinding',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    key: {
+                        type: 'string',
+                        description: 'Key combination (e.g., "ctrl+s", "cmd+k")',
+                    },
+                    command: {
+                        type: 'string',
+                        description: 'Command to execute',
+                    },
+                    when: {
+                        type: 'string',
+                        description: 'Optional context condition',
+                    },
+                },
+                required: ['key', 'command'],
+            },
+        },
+        {
+            name: 'remove_keybinding',
+            description: 'Remove a keybinding by key combination',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    key: {
+                        type: 'string',
+                        description: 'Key combination to remove',
+                    },
+                },
+                required: ['key'],
+            },
+        },
+        // Settings tools
+        {
+            name: 'read_settings',
+            description: 'Read the settings.json file',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'write_settings',
+            description: 'Write to settings.json',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    settings: {
+                        type: 'object',
+                        description: 'Settings object',
+                    },
+                    createBackup: {
+                        type: 'boolean',
+                        description: 'Create backup before writing (default: true)',
+                        default: true,
+                    },
+                },
+                required: ['settings'],
+            },
+        },
+        // Hooks tools
+        {
+            name: 'list_hooks',
+            description: 'List all configured hooks',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+        },
+        {
+            name: 'read_hook',
+            description: 'Read a specific hook file',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Hook file name (without extension)',
+                    },
+                },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'write_hook',
+            description: 'Write or update a hook file',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Hook file name',
+                    },
+                    event: {
+                        type: 'string',
+                        description: 'Hook event (SessionStart, SessionEnd, PreToolUse, PostToolUse, etc.)',
+                    },
+                    content: {
+                        type: 'string',
+                        description: 'Hook script content',
+                    },
+                    enabled: {
+                        type: 'boolean',
+                        description: 'Whether the hook is enabled',
+                        default: true,
+                    },
+                },
+                required: ['name', 'event', 'content'],
+            },
+        },
+        // Utility tools
+        {
+            name: 'list_config_files',
+            description: 'List all Claude Code config files with metadata',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    includeProject: {
+                        type: 'boolean',
+                        description: 'Include project-local config files',
+                        default: true,
+                    },
+                },
+            },
+        },
+        {
+            name: 'get_config_path',
+            description: 'Get the path to a specific config file',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    fileType: {
+                        type: 'string',
+                        enum: [
+                            'CLAUDE_MD_GLOBAL',
+                            'CLAUDE_MD_PROJECT',
+                            'KEYBINDINGS',
+                            'SETTINGS',
+                            'HOOKS_DIR',
+                        ],
+                        description: 'Type of config file',
+                    },
+                },
+                required: ['fileType'],
+            },
+        },
+        {
+            name: 'backup_config',
+            description: 'Create a backup of a config file',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    fileType: {
+                        type: 'string',
+                        enum: ['CLAUDE_MD', 'KEYBINDINGS', 'SETTINGS'],
+                        description: 'Type of config file to backup',
+                    },
+                },
+                required: ['fileType'],
+            },
+        },
+        // MCP Server management tools
+        {
+            name: 'mcp_list',
+            description: 'List all configured MCP servers from config files. Supports CLI (~/.claude.json) and app (~/.config/claude-code/config.json) configs.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    target: {
+                        type: 'string',
+                        enum: ['cli', 'app', 'both'],
+                        description: 'Which config to read (default: both)',
+                        default: 'both',
+                    },
+                    includeHealth: {
+                        type: 'boolean',
+                        description: 'Check server health status by running claude mcp list',
+                        default: false,
+                    },
+                },
+            },
+        },
+        {
+            name: 'mcp_get',
+            description: 'Get details about a specific MCP server from config files',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'MCP server name',
+                    },
+                    target: {
+                        type: 'string',
+                        enum: ['cli', 'app', 'both'],
+                        description: 'Which config to read (default: both)',
+                        default: 'both',
+                    },
+                },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'mcp_add',
+            description: 'Add a new MCP server configuration. Supports stdio, HTTP, SSE, and WebSocket transports. Can add to CLI config, app config, or both.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Unique name for the MCP server',
+                    },
+                    command: {
+                        type: 'string',
+                        description: 'Command to run (for stdio transport, e.g., "node", "bun", "npx")',
+                    },
+                    args: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Arguments for the command (e.g., ["/path/to/server.js"])',
+                    },
+                    url: {
+                        type: 'string',
+                        description: 'URL for HTTP/SSE/WebSocket transport',
+                    },
+                    transport: {
+                        type: 'string',
+                        enum: ['stdio', 'sse', 'http', 'ws', 'websocket'],
+                        description: 'Transport type (default: stdio)',
+                    },
+                    env: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                        description: 'Environment variables for the server',
+                    },
+                    headers: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                        description: 'HTTP headers for HTTP/SSE/WebSocket transport',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Human-readable description of the server',
+                    },
+                    alwaysAllow: {
+                        type: 'boolean',
+                        description: 'Always allow this server (bypass project-scoped approval)',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Timeout in milliseconds',
+                    },
+                    target: {
+                        type: 'string',
+                        enum: ['cli', 'app', 'both'],
+                        description: 'Which config(s) to add to (default: both - adds to both CLI and app configs)',
+                        default: 'both',
+                    },
+                },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'mcp_install',
+            description: 'Download and configure an MCP server from npm, GitHub, or a local path. Automatically detects configuration from package.json. Can add to CLI config, app config, or both.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source: {
+                        type: 'string',
+                        enum: ['npm', 'github', 'local', 'url'],
+                        description: 'Source type (auto-detected if not specified)',
+                    },
+                    package: {
+                        type: 'string',
+                        description: 'Package name (npm), repo URL (github), local path, or direct URL',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Name for the MCP server (defaults to package name)',
+                    },
+                    version: {
+                        type: 'string',
+                        description: 'Version to install (for npm packages, e.g., "latest", "1.2.3")',
+                    },
+                    env: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                        description: 'Environment variables for the server',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Description for the server',
+                    },
+                    args: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Additional arguments to pass to the server',
+                    },
+                    installDir: {
+                        type: 'string',
+                        description: 'Global MCP packages directory (defaults to ~/.claude/mcp-servers)',
+                    },
+                    force: {
+                        type: 'boolean',
+                        description: 'Force reinstallation even if already installed',
+                    },
+                    target: {
+                        type: 'string',
+                        enum: ['cli', 'app', 'both'],
+                        description: 'Which config(s) to add to (default: both - adds to both CLI and app configs)',
+                        default: 'both',
+                    },
+                },
+                required: ['package'],
+            },
+        },
+        {
+            name: 'mcp_remove',
+            description: 'Remove an MCP server configuration from config file(s)',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'MCP server name to remove',
+                    },
+                    target: {
+                        type: 'string',
+                        enum: ['cli', 'app', 'both'],
+                        description: 'Which config(s) to remove from (default: both)',
+                        default: 'both',
+                    },
+                },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'mcp_update',
+            description: 'Update an existing MCP server configuration',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'MCP server name to update',
+                    },
+                    command: {
+                        type: 'string',
+                        description: 'New command to run',
+                    },
+                    args: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'New arguments for the command',
+                    },
+                    url: {
+                        type: 'string',
+                        description: 'New URL for HTTP/SSE/WebSocket transport',
+                    },
+                    env: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                        description: 'New environment variables',
+                    },
+                    headers: {
+                        type: 'object',
+                        additionalProperties: { type: 'string' },
+                        description: 'New HTTP headers',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'New description',
+                    },
+                    alwaysAllow: {
+                        type: 'boolean',
+                        description: 'Update always allow flag',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'New timeout in milliseconds',
+                    },
+                    target: {
+                        type: 'string',
+                        enum: ['cli', 'app', 'both'],
+                        description: 'Which config(s) to update (default: both)',
+                        default: 'both',
+                    },
+                },
+                required: ['name'],
+            },
+        },
+        {
+            name: 'mcp_sync',
+            description: 'Synchronize MCP servers between CLI and app configs. Ensures both configs have the same servers.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source: {
+                        type: 'string',
+                        enum: ['cli', 'app'],
+                        description: 'Source config to sync from (default: app - syncs from app to CLI)',
+                        default: 'app',
+                    },
+                    dryRun: {
+                        type: 'boolean',
+                        description: 'Show what would be synced without making changes',
+                        default: false,
+                    },
+                },
+            },
+        },
+    ],
+}));
+// ============================================================================
+// Tool Handlers
+// ============================================================================
+/**
+ * Handle tool execution
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            // CLAUDE.md tools
+            case 'read_global_claude_md':
+                return await handleReadGlobalClaudeMd();
+            case 'write_global_claude_md':
+                return await handleWriteGlobalClaudeMd(args);
+            case 'read_project_claude_md':
+                return await handleReadProjectClaudeMd(args);
+            case 'write_project_claude_md':
+                return await handleWriteProjectClaudeMd(args);
+            // Keybindings tools
+            case 'read_keybindings':
+                return await handleReadKeybindings();
+            case 'write_keybindings':
+                return await handleWriteKeybindings(args);
+            case 'add_keybinding':
+                return await handleAddKeybinding(args);
+            case 'remove_keybinding':
+                return await handleRemoveKeybinding(args);
+            // Settings tools
+            case 'read_settings':
+                return await handleReadSettings();
+            case 'write_settings':
+                return await handleWriteSettings(args);
+            // Hooks tools
+            case 'list_hooks':
+                return await handleListHooks();
+            case 'read_hook':
+                return await handleReadHook(args);
+            case 'write_hook':
+                return await handleWriteHook(args);
+            // Utility tools
+            case 'list_config_files':
+                return await handleListConfigFiles(args);
+            case 'get_config_path':
+                return await handleGetConfigPath(args);
+            case 'backup_config':
+                return await handleBackupConfig(args);
+            // MCP management tools
+            case 'mcp_list':
+                return await handleMCPList(args);
+            case 'mcp_get':
+                return await handleMCPGet(args);
+            case 'mcp_add':
+                return await handleMCPAdd(args);
+            case 'mcp_install':
+                return await handleMCPInstall(args);
+            case 'mcp_remove':
+                return await handleMCPRemove(args);
+            case 'mcp_update':
+                return await handleMCPUpdate(args);
+            case 'mcp_sync':
+                return await handleMCPSync(args);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        const mcpError = errors.createMCPError(error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(mcpError, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ============================================================================
+// CLAUDE.md Handlers
+// ============================================================================
+async function handleReadGlobalClaudeMd() {
+    const filePath = path.getConfigPaths().globalClaudeMd;
+    const validatedPath = path.validatePath(filePath);
+    const content = await file.safeReadFile(validatedPath);
+    const stats = await getFileInfo(validatedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: content,
+            },
+        ],
+    };
+}
+async function handleWriteGlobalClaudeMd(args) {
+    const schema = z.object({
+        content: z.string(),
+        createBackup: z.boolean().optional(),
+    });
+    const { content, createBackup = true } = schema.parse(args);
+    const filePath = path.getConfigPaths().globalClaudeMd;
+    const validatedPath = path.validatePath(filePath);
+    // Normalize content
+    const normalized = file.normalizeLineEndings(content);
+    const stripped = file.stripBOM(normalized);
+    await file.atomicWrite(validatedPath, stripped, { createBackup });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully wrote global CLAUDE.md to ${path.getDisplayPath(validatedPath)}`,
+            },
+        ],
+    };
+}
+async function handleReadProjectClaudeMd(args) {
+    const schema = z.object({
+        projectPath: z.string().optional(),
+    });
+    const { projectPath } = schema.parse(args);
+    const cwd = projectPath || process.cwd();
+    const filePath = path.getConfigPaths(cwd).projectClaudeMd;
+    const validatedPath = path.validatePath(filePath, cwd);
+    const content = await file.safeReadFile(validatedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: content,
+            },
+        ],
+    };
+}
+async function handleWriteProjectClaudeMd(args) {
+    const schema = z.object({
+        content: z.string(),
+        projectPath: z.string().optional(),
+        createBackup: z.boolean().optional(),
+    });
+    const { content, projectPath, createBackup = true } = schema.parse(args);
+    const cwd = projectPath || process.cwd();
+    const filePath = path.getConfigPaths(cwd).projectClaudeMd;
+    const validatedPath = path.validatePath(filePath, cwd);
+    // Normalize content
+    const normalized = file.normalizeLineEndings(content);
+    const stripped = file.stripBOM(normalized);
+    await file.atomicWrite(validatedPath, stripped, { createBackup });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully wrote project CLAUDE.md to ${path.getDisplayPath(validatedPath)}`,
+            },
+        ],
+    };
+}
+// ============================================================================
+// Keybindings Handlers
+// ============================================================================
+async function handleReadKeybindings() {
+    const filePath = path.getConfigPaths().keybindings;
+    const validatedPath = path.validatePath(filePath);
+    const content = await file.safeReadFile(validatedPath);
+    const config = file.safeJSONParse(content, validatedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(config, null, 2),
+            },
+        ],
+    };
+}
+async function handleWriteKeybindings(args) {
+    const schema = z.object({
+        keybindings: z.object({
+            $schema: z.string().optional(),
+            keybindings: z.record(z.string(), z.object({
+                key: z.string(),
+                command: z.string(),
+                when: z.string().optional(),
+            })),
+        }),
+        createBackup: z.boolean().optional(),
+    });
+    const { keybindings, createBackup = true } = schema.parse(args);
+    const filePath = path.getConfigPaths().keybindings;
+    const validatedPath = path.validatePath(filePath);
+    const content = file.formatJSON(keybindings);
+    await file.atomicWrite(validatedPath, content, { createBackup });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully wrote keybindings to ${path.getDisplayPath(validatedPath)}`,
+            },
+        ],
+    };
+}
+async function handleAddKeybinding(args) {
+    const schema = z.object({
+        key: z.string(),
+        command: z.string(),
+        when: z.string().optional(),
+    });
+    const { key, command, when } = schema.parse(args);
+    const filePath = path.getConfigPaths().keybindings;
+    const validatedPath = path.validatePath(filePath);
+    // Read existing config
+    let config;
+    try {
+        const content = await file.safeReadFile(validatedPath);
+        config = file.safeJSONParse(content, validatedPath);
+    }
+    catch {
+        // Create new config if file doesn't exist
+        config = { keybindings: {} };
+    }
+    // Add/update keybinding
+    config.keybindings[key] = { key, command, ...(when && { when }) };
+    const content = file.formatJSON(config);
+    await file.atomicWrite(validatedPath, content, { createBackup: true });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully added keybinding: ${key} -> ${command}`,
+            },
+        ],
+    };
+}
+async function handleRemoveKeybinding(args) {
+    const schema = z.object({
+        key: z.string(),
+    });
+    const { key } = schema.parse(args);
+    const filePath = path.getConfigPaths().keybindings;
+    const validatedPath = path.validatePath(filePath);
+    // Read existing config
+    const content = await file.safeReadFile(validatedPath);
+    const config = file.safeJSONParse(content, validatedPath);
+    // Remove keybinding
+    delete config.keybindings[key];
+    const newContent = file.formatJSON(config);
+    await file.atomicWrite(validatedPath, newContent, { createBackup: true });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully removed keybinding: ${key}`,
+            },
+        ],
+    };
+}
+// ============================================================================
+// Settings Handlers
+// ============================================================================
+async function handleReadSettings() {
+    const filePath = path.getConfigPaths().settings;
+    const validatedPath = path.validatePath(filePath);
+    const content = await file.safeReadFile(validatedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: content,
+            },
+        ],
+    };
+}
+async function handleWriteSettings(args) {
+    const schema = z.object({
+        settings: z.object({
+            $schema: z.string().optional(),
+        }).passthrough(),
+        createBackup: z.boolean().optional(),
+    });
+    const { settings, createBackup = true } = schema.parse(args);
+    const filePath = path.getConfigPaths().settings;
+    const validatedPath = path.validatePath(filePath);
+    const content = file.formatJSON(settings);
+    await file.atomicWrite(validatedPath, content, { createBackup });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully wrote settings to ${path.getDisplayPath(validatedPath)}`,
+            },
+        ],
+    };
+}
+// ============================================================================
+// Hooks Handlers
+// ============================================================================
+async function handleListHooks() {
+    const hooksDir = path.getConfigPaths().hooksDir;
+    const validatedPath = path.validatePath(hooksDir);
+    const hooks = await listHookFiles(validatedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(hooks, null, 2),
+            },
+        ],
+    };
+}
+async function handleReadHook(args) {
+    const schema = z.object({
+        name: z.string(),
+    });
+    const { name } = schema.parse(args);
+    const hooksDir = path.getConfigPaths().hooksDir;
+    const validatedPath = path.validatePath(hooksDir);
+    const hookPath = `${validatedPath}/${name}`;
+    const validatedHookPath = path.validatePath(hookPath);
+    const content = await file.safeReadFile(validatedHookPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: content,
+            },
+        ],
+    };
+}
+async function handleWriteHook(args) {
+    const schema = z.object({
+        name: z.string(),
+        event: z.string(),
+        content: z.string(),
+        enabled: z.boolean().optional(),
+    });
+    const { name, event, content, enabled = true } = schema.parse(args);
+    const hooksDir = path.getConfigPaths().hooksDir;
+    const validatedPath = path.validatePath(hooksDir);
+    const hookPath = `${validatedPath}/${name}`;
+    const validatedHookPath = path.validatePath(hookPath);
+    await file.atomicWrite(validatedHookPath, content, { createBackup: true });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully wrote hook: ${name}`,
+            },
+        ],
+    };
+}
+// ============================================================================
+// Utility Handlers
+// ============================================================================
+async function handleListConfigFiles(args) {
+    const schema = z.object({
+        includeProject: z.boolean().optional(),
+    });
+    const { includeProject = true } = schema.parse(args);
+    const paths = path.getConfigPaths();
+    const cwd = process.cwd();
+    const files = [
+        {
+            type: 'CLAUDE_MD_GLOBAL',
+            path: path.getDisplayPath(paths.globalClaudeMd),
+            exists: path.pathExists(paths.globalClaudeMd),
+        },
+        {
+            type: 'KEYBINDINGS',
+            path: path.getDisplayPath(paths.keybindings),
+            exists: path.pathExists(paths.keybindings),
+        },
+        {
+            type: 'SETTINGS',
+            path: path.getDisplayPath(paths.settings),
+            exists: path.pathExists(paths.settings),
+        },
+        {
+            type: 'HOOKS_DIR',
+            path: path.getDisplayPath(paths.hooksDir),
+            exists: path.pathExists(paths.hooksDir),
+        },
+    ];
+    if (includeProject) {
+        files.push({
+            type: 'CLAUDE_MD_PROJECT',
+            path: path.getDisplayPath(paths.projectClaudeMd),
+            exists: path.pathExists(paths.projectClaudeMd),
+        });
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(files, null, 2),
+            },
+        ],
+    };
+}
+async function handleGetConfigPath(args) {
+    const schema = z.object({
+        fileType: z.enum([
+            'CLAUDE_MD_GLOBAL',
+            'CLAUDE_MD_PROJECT',
+            'KEYBINDINGS',
+            'SETTINGS',
+            'HOOKS_DIR',
+        ]),
+    });
+    const { fileType } = schema.parse(args);
+    const paths = path.getConfigPaths();
+    const filePathMap = {
+        CLAUDE_MD_GLOBAL: paths.globalClaudeMd,
+        CLAUDE_MD_PROJECT: paths.projectClaudeMd,
+        KEYBINDINGS: paths.keybindings,
+        SETTINGS: paths.settings,
+        HOOKS_DIR: paths.hooksDir,
+    };
+    const resolvedPath = filePathMap[fileType];
+    const displayPath = path.getDisplayPath(resolvedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    type: fileType,
+                    path: displayPath,
+                    absolutePath: resolvedPath,
+                    exists: path.pathExists(resolvedPath),
+                }, null, 2),
+            },
+        ],
+    };
+}
+async function handleBackupConfig(args) {
+    const schema = z.object({
+        fileType: z.enum(['CLAUDE_MD', 'KEYBINDINGS', 'SETTINGS']),
+    });
+    const { fileType } = schema.parse(args);
+    const paths = path.getConfigPaths();
+    const filePathMap = {
+        CLAUDE_MD: paths.globalClaudeMd,
+        KEYBINDINGS: paths.keybindings,
+        SETTINGS: paths.settings,
+    };
+    const filePath = filePathMap[fileType];
+    const validatedPath = path.validatePath(filePath);
+    if (!path.pathExists(validatedPath)) {
+        throw new Error(`File does not exist: ${fileType}`);
+    }
+    const backupPath = await createBackup(validatedPath);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Backup created: ${path.getDisplayPath(backupPath)}`,
+            },
+        ],
+    };
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+async function getFileInfo(filePath) {
+    const { stat } = await import('node:fs/promises');
+    const stats = await stat(filePath);
+    return {
+        size: stats.size,
+        modified: stats.mtime,
+    };
+}
+async function listHookFiles(hooksDir) {
+    const { readdir } = await import('node:fs/promises');
+    const { existsSync } = await import('node:fs');
+    if (!existsSync(hooksDir)) {
+        return [];
+    }
+    const files = await readdir(hooksDir, { withFileTypes: true });
+    const hooks = [];
+    for (const file of files) {
+        if (file.isFile()) {
+            // Parse event from filename (e.g., "PreToolUse.ts" -> "PreToolUse")
+            const name = file.name;
+            const event = name.replace(/\.(ts|js|sh)$/, '');
+            hooks.push({ name, event, enabled: true });
+        }
+    }
+    return hooks;
+}
+async function createBackup(filePath) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = `${filePath}.backup.${timestamp}`;
+    const { readFile, writeFile } = await import('node:fs/promises');
+    const content = await readFile(filePath);
+    await writeFile(backupPath, content);
+    return backupPath;
+}
+// ============================================================================
+// MCP Management Handlers
+// ============================================================================
+async function handleMCPList(args) {
+    const schema = z.object({
+        target: z.enum(['cli', 'app', 'both']).optional(),
+        includeHealth: z.boolean().optional(),
+    });
+    const { target = 'both', includeHealth = false } = schema.parse(args);
+    const configPaths = getMCPConfigPaths(target);
+    // Read configs from requested targets
+    const results = {};
+    if (configPaths.cli) {
+        try {
+            const validatedPath = path.validatePath(configPaths.cli);
+            const content = await file.safeReadFile(validatedPath);
+            results.cli = {
+                config: file.safeJSONParse(content, validatedPath),
+                source: 'cli',
+            };
+        }
+        catch {
+            results.cli = { config: { mcpServers: {} }, source: 'cli' };
+        }
+    }
+    if (configPaths.app) {
+        try {
+            const validatedPath = path.validatePath(configPaths.app);
+            const content = await file.safeReadFile(validatedPath);
+            results.app = {
+                config: file.safeJSONParse(content, validatedPath),
+                source: 'app',
+            };
+        }
+        catch {
+            results.app = { config: { mcpServers: {} }, source: 'app' };
+        }
+    }
+    // If health check is requested, run claude mcp list
+    let healthInfo = {};
+    if (includeHealth) {
+        try {
+            const { exec } = await import('node:child_process');
+            const result = await new Promise((resolve, reject) => {
+                exec('claude mcp list 2>&1', (error, stdout, stderr) => {
+                    if (error) {
+                        resolve(stderr || stdout);
+                    }
+                    else {
+                        resolve(stdout);
+                    }
+                });
+            });
+            // Parse the output to extract health info
+            const lines = result.split('\n');
+            for (const line of lines) {
+                const match = line.match(/^([^:]+):\s+.*?-\s+([✓✗])/);
+                if (match) {
+                    const name = match[1].trim();
+                    const status = match[2] === '✓' ? 'connected' : 'error';
+                    healthInfo[name] = status;
+                }
+            }
+        }
+        catch {
+            // Health check failed, continue without it
+        }
+    }
+    // Build result with servers from each config
+    const output = {};
+    if (results.cli) {
+        const cliServers = Object.entries(results.cli.config.mcpServers || {}).map(([name, serverConfig]) => ({
+            ...serverConfig,
+            name,
+            source: 'cli',
+            health: healthInfo[name],
+        }));
+        output.cli = { mcpServers: cliServers };
+    }
+    if (results.app) {
+        const appServers = Object.entries(results.app.config.mcpServers || {}).map(([name, serverConfig]) => ({
+            ...serverConfig,
+            name,
+            source: 'app',
+            health: healthInfo[name],
+        }));
+        output.app = { mcpServers: appServers };
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(output, null, 2),
+            },
+        ],
+    };
+}
+async function handleMCPGet(args) {
+    const schema = z.object({
+        name: z.string(),
+        target: z.enum(['cli', 'app', 'both']).optional(),
+    });
+    const { name, target = 'both' } = schema.parse(args);
+    const configPaths = getMCPConfigPaths(target);
+    const results = {};
+    let found = false;
+    if (configPaths.cli) {
+        try {
+            const validatedPath = path.validatePath(configPaths.cli);
+            const content = await file.safeReadFile(validatedPath);
+            const config = file.safeJSONParse(content, validatedPath);
+            const serverConfig = config.mcpServers?.[name];
+            if (serverConfig) {
+                results.cli = { name, ...serverConfig, source: 'cli' };
+                found = true;
+            }
+        }
+        catch {
+            // Continue to app config
+        }
+    }
+    if (configPaths.app) {
+        try {
+            const validatedPath = path.validatePath(configPaths.app);
+            const content = await file.safeReadFile(validatedPath);
+            const config = file.safeJSONParse(content, validatedPath);
+            const serverConfig = config.mcpServers?.[name];
+            if (serverConfig) {
+                results.app = { name, ...serverConfig, source: 'app' };
+                found = true;
+            }
+        }
+        catch {
+            // Server not found in app config
+        }
+    }
+    if (!found) {
+        throw new Error(`MCP server not found: ${name}`);
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(results, null, 2),
+            },
+        ],
+    };
+}
+async function handleMCPAdd(args) {
+    const schema = z.object({
+        name: z.string().min(1),
+        command: z.string().optional(),
+        args: z.array(z.string()).optional(),
+        url: z.string().optional(),
+        transport: z.enum(['stdio', 'sse', 'http', 'ws', 'websocket']).optional(),
+        env: z.record(z.string(), z.string()).optional(),
+        headers: z.record(z.string(), z.string()).optional(),
+        description: z.string().optional(),
+        alwaysAllow: z.boolean().optional(),
+        timeout: z.number().optional(),
+        target: z.enum(['cli', 'app', 'both']).optional(),
+    });
+    const options = schema.parse(args);
+    const configPaths = getMCPConfigPaths(options.target || 'both');
+    const results = [];
+    // Build server config
+    const serverConfig = {};
+    if (options.command)
+        serverConfig.command = options.command;
+    if (options.args)
+        serverConfig.args = options.args;
+    if (options.url)
+        serverConfig.url = options.url;
+    if (options.transport)
+        serverConfig.transport = options.transport;
+    if (options.env)
+        serverConfig.env = options.env;
+    if (options.headers)
+        serverConfig.headers = options.headers;
+    if (options.description)
+        serverConfig.description = options.description;
+    if (options.alwaysAllow !== undefined)
+        serverConfig.alwaysAllow = options.alwaysAllow;
+    if (options.timeout)
+        serverConfig.timeout = options.timeout;
+    // Add to CLI config
+    if (configPaths.cli) {
+        const validatedPath = path.validatePath(configPaths.cli);
+        let config;
+        try {
+            const content = await file.safeReadFile(validatedPath);
+            config = file.safeJSONParse(content, validatedPath);
+        }
+        catch {
+            config = { mcpServers: {} };
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        if (config.mcpServers[options.name]) {
+            throw new Error(`MCP server already exists in CLI config: ${options.name}`);
+        }
+        config.mcpServers[options.name] = serverConfig;
+        const content = file.formatJSON(config);
+        await file.atomicWrite(validatedPath, content, { createBackup: true });
+        results.push(`CLI config (${path.getDisplayPath(configPaths.cli)})`);
+    }
+    // Add to app config
+    if (configPaths.app) {
+        const validatedPath = path.validatePath(configPaths.app);
+        let config;
+        try {
+            const content = await file.safeReadFile(validatedPath);
+            config = file.safeJSONParse(content, validatedPath);
+        }
+        catch {
+            config = { mcpServers: {} };
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        if (config.mcpServers[options.name]) {
+            throw new Error(`MCP server already exists in app config: ${options.name}`);
+        }
+        config.mcpServers[options.name] = serverConfig;
+        const content = file.formatJSON(config);
+        await file.atomicWrite(validatedPath, content, { createBackup: true });
+        results.push(`App config (${path.getDisplayPath(configPaths.app)})`);
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully added MCP server: ${options.name}\nAdded to: ${results.join(', ')}`,
+            },
+        ],
+    };
+}
+async function handleMCPRemove(args) {
+    const schema = z.object({
+        name: z.string(),
+        target: z.enum(['cli', 'app', 'both']).optional(),
+    });
+    const { name, target = 'both' } = schema.parse(args);
+    const configPaths = getMCPConfigPaths(target);
+    const results = [];
+    let found = false;
+    // Remove from CLI config
+    if (configPaths.cli) {
+        try {
+            const validatedPath = path.validatePath(configPaths.cli);
+            const content = await file.safeReadFile(validatedPath);
+            const config = file.safeJSONParse(content, validatedPath);
+            if (config.mcpServers && config.mcpServers[name]) {
+                delete config.mcpServers[name];
+                const newContent = file.formatJSON(config);
+                await file.atomicWrite(validatedPath, newContent, { createBackup: true });
+                results.push(`CLI config (${path.getDisplayPath(configPaths.cli)})`);
+                found = true;
+            }
+        }
+        catch {
+            // Continue to app config
+        }
+    }
+    // Remove from app config
+    if (configPaths.app) {
+        try {
+            const validatedPath = path.validatePath(configPaths.app);
+            const content = await file.safeReadFile(validatedPath);
+            const config = file.safeJSONParse(content, validatedPath);
+            if (config.mcpServers && config.mcpServers[name]) {
+                delete config.mcpServers[name];
+                const newContent = file.formatJSON(config);
+                await file.atomicWrite(validatedPath, newContent, { createBackup: true });
+                results.push(`App config (${path.getDisplayPath(configPaths.app)})`);
+                found = true;
+            }
+        }
+        catch {
+            // Server not found
+        }
+    }
+    if (!found) {
+        throw new Error(`MCP server not found: ${name}`);
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully removed MCP server: ${name}\nRemoved from: ${results.join(', ')}`,
+            },
+        ],
+    };
+}
+async function handleMCPUpdate(args) {
+    const schema = z.object({
+        name: z.string(),
+        command: z.string().optional(),
+        args: z.array(z.string()).optional(),
+        url: z.string().optional(),
+        env: z.record(z.string(), z.string()).optional(),
+        headers: z.record(z.string(), z.string()).optional(),
+        description: z.string().optional(),
+        alwaysAllow: z.boolean().optional(),
+        timeout: z.number().optional(),
+        target: z.enum(['cli', 'app', 'both']).optional(),
+    });
+    const options = schema.parse(args);
+    const configPaths = getMCPConfigPaths(options.target || 'both');
+    const results = [];
+    let found = false;
+    // Update CLI config
+    if (configPaths.cli) {
+        try {
+            const validatedPath = path.validatePath(configPaths.cli);
+            const content = await file.safeReadFile(validatedPath);
+            const config = file.safeJSONParse(content, validatedPath);
+            if (config.mcpServers && config.mcpServers[options.name]) {
+                const serverConfig = config.mcpServers[options.name];
+                if (options.command !== undefined)
+                    serverConfig.command = options.command;
+                if (options.args !== undefined)
+                    serverConfig.args = options.args;
+                if (options.url !== undefined)
+                    serverConfig.url = options.url;
+                if (options.env !== undefined)
+                    serverConfig.env = options.env;
+                if (options.headers !== undefined)
+                    serverConfig.headers = options.headers;
+                if (options.description !== undefined)
+                    serverConfig.description = options.description;
+                if (options.alwaysAllow !== undefined)
+                    serverConfig.alwaysAllow = options.alwaysAllow;
+                if (options.timeout !== undefined)
+                    serverConfig.timeout = options.timeout;
+                const newContent = file.formatJSON(config);
+                await file.atomicWrite(validatedPath, newContent, { createBackup: true });
+                results.push(`CLI config (${path.getDisplayPath(configPaths.cli)})`);
+                found = true;
+            }
+        }
+        catch {
+            // Continue to app config
+        }
+    }
+    // Update app config
+    if (configPaths.app) {
+        try {
+            const validatedPath = path.validatePath(configPaths.app);
+            const content = await file.safeReadFile(validatedPath);
+            const config = file.safeJSONParse(content, validatedPath);
+            if (config.mcpServers && config.mcpServers[options.name]) {
+                const serverConfig = config.mcpServers[options.name];
+                if (options.command !== undefined)
+                    serverConfig.command = options.command;
+                if (options.args !== undefined)
+                    serverConfig.args = options.args;
+                if (options.url !== undefined)
+                    serverConfig.url = options.url;
+                if (options.env !== undefined)
+                    serverConfig.env = options.env;
+                if (options.headers !== undefined)
+                    serverConfig.headers = options.headers;
+                if (options.description !== undefined)
+                    serverConfig.description = options.description;
+                if (options.alwaysAllow !== undefined)
+                    serverConfig.alwaysAllow = options.alwaysAllow;
+                if (options.timeout !== undefined)
+                    serverConfig.timeout = options.timeout;
+                const newContent = file.formatJSON(config);
+                await file.atomicWrite(validatedPath, newContent, { createBackup: true });
+                results.push(`App config (${path.getDisplayPath(configPaths.app)})`);
+                found = true;
+            }
+        }
+        catch {
+            // Server not found
+        }
+    }
+    if (!found) {
+        throw new Error(`MCP server not found: ${options.name}`);
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Successfully updated MCP server: ${options.name}\nUpdated in: ${results.join(', ')}`,
+            },
+        ],
+    };
+}
+async function handleMCPInstall(args) {
+    const schema = z.object({
+        source: z.enum(['npm', 'github', 'local', 'url']).optional(),
+        package: z.string(),
+        name: z.string().optional(),
+        version: z.string().optional(),
+        env: z.record(z.string(), z.string()).optional(),
+        description: z.string().optional(),
+        args: z.array(z.string()).optional(),
+        installDir: z.string().optional(),
+        force: z.boolean().optional(),
+        target: z.enum(['cli', 'app', 'both']).optional(),
+    });
+    const options = schema.parse(args);
+    const target = options.target || 'both';
+    // Auto-detect source if not specified
+    let source = options.source;
+    if (!source) {
+        if (options.package.startsWith('http') || options.package.startsWith('git+')) {
+            source = 'github';
+        }
+        else if (options.package.startsWith('/') || options.package.startsWith('./') || options.package.startsWith('../')) {
+            source = 'local';
+        }
+        else if (options.package.includes('/')) {
+            // Could be npm scoped package or GitHub - default to npm for @scope/name pattern
+            source = options.package.startsWith('@') ? 'npm' : 'github';
+        }
+        else {
+            source = 'npm';
+        }
+    }
+    // Determine install directory
+    const installDir = options.installDir || join(path.getHomeDir(), '.claude', 'mcp-servers');
+    // Ensure install directory exists
+    const { mkdir } = await import('node:fs/promises');
+    await mkdir(installDir, { recursive: true });
+    let serverName = options.name;
+    let serverConfig = {};
+    let installPath;
+    switch (source) {
+        case 'npm': {
+            // Install from npm
+            const packageName = options.package;
+            const version = options.version || 'latest';
+            serverName = serverName || packageName.replace(/^@[^/]+\//, '').replace(/^mcp-server-/, '').replace(/^server-/, '');
+            installPath = join(installDir, 'node_modules', packageName);
+            // Check if already installed
+            if (!options.force && path.pathExists(join(installPath, 'package.json'))) {
+                // Already installed, just configure it
+            }
+            else {
+                // Install using bun
+                const { execSync } = await import('node:child_process');
+                execSync(`bun install ${packageName}@${version}`, {
+                    cwd: installDir,
+                    stdio: 'inherit',
+                });
+            }
+            // Read package.json to find entry point
+            const packageJsonPath = join(installPath, 'package.json');
+            const packageJsonContent = await file.safeReadFile(packageJsonPath);
+            const packageJson = JSON.parse(packageJsonContent);
+            // Determine command and args
+            const entryPoint = packageJson.bin || packageJson.main || 'index.js';
+            if (typeof entryPoint === 'string') {
+                serverConfig.command = 'node';
+                serverConfig.args = [join(installPath, entryPoint), ...(options.args || [])];
+            }
+            else if (typeof entryPoint === 'object') {
+                const binName = Object.keys(entryPoint)[0];
+                serverConfig.command = 'node';
+                serverConfig.args = [join(installPath, entryPoint[binName]), ...(options.args || [])];
+            }
+            serverConfig.description = options.description || packageJson.description;
+            break;
+        }
+        case 'github': {
+            // Clone from GitHub
+            const repo = options.package.replace(/\.git$/, '');
+            const repoName = repo.split('/').pop() || 'mcp-server';
+            serverName = serverName || repoName.replace(/^mcp-/, '').replace(/^server-/, '');
+            installPath = join(installDir, repoName);
+            if (options.force || !path.pathExists(join(installPath, '.git'))) {
+                const { execSync } = await import('node:child_process');
+                execSync(`git clone ${options.package} "${installPath}"`, {
+                    stdio: 'inherit',
+                });
+            }
+            // Read package.json to find entry point
+            const packageJsonPath = join(installPath, 'package.json');
+            const packageJsonContent = await file.safeReadFile(packageJsonPath);
+            const packageJson = JSON.parse(packageJsonContent);
+            // Determine command and args
+            const entryPoint = packageJson.main || 'dist/index.js';
+            const distPath = join(installPath, entryPoint);
+            serverConfig.command = 'node';
+            serverConfig.args = [distPath, ...(options.args || [])];
+            serverConfig.description = options.description || packageJson.description;
+            break;
+        }
+        case 'local': {
+            // Link local package
+            installPath = resolve(options.package);
+            if (!path.pathExists(installPath)) {
+                throw new Error(`Local path does not exist: ${installPath}`);
+            }
+            const packageJsonPath = join(installPath, 'package.json');
+            const packageJsonContent = await file.safeReadFile(packageJsonPath);
+            const packageJson = JSON.parse(packageJsonContent);
+            serverName = serverName || packageJson.name?.replace(/^@[^/]+\//, '').replace(/^mcp-server-/, '').replace(/^server-/, '') || 'local-mcp';
+            const entryPoint = packageJson.bin || packageJson.main || 'dist/index.js';
+            const entryPath = typeof entryPoint === 'string' ? join(installPath, entryPoint) : installPath;
+            serverConfig.command = 'node';
+            serverConfig.args = [entryPath, ...(options.args || [])];
+            serverConfig.description = options.description || packageJson.description;
+            break;
+        }
+        case 'url': {
+            // Download from URL and install
+            throw new Error('URL source not yet implemented');
+        }
+        default: {
+            throw new Error(`Unknown source type: ${source}`);
+        }
+    }
+    // Add environment variables
+    if (options.env) {
+        serverConfig.env = options.env;
+    }
+    // Add to config files based on target
+    const configPaths = getMCPConfigPaths(target);
+    const results = [];
+    // Add to CLI config
+    if (configPaths.cli) {
+        const validatedConfigPath = path.validatePath(configPaths.cli);
+        let config;
+        try {
+            const content = await file.safeReadFile(validatedConfigPath);
+            config = file.safeJSONParse(content, validatedConfigPath);
+        }
+        catch {
+            config = { mcpServers: {} };
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        config.mcpServers[serverName] = serverConfig;
+        const content = file.formatJSON(config);
+        await file.atomicWrite(validatedConfigPath, content, { createBackup: true });
+        results.push(`CLI config (${path.getDisplayPath(configPaths.cli)})`);
+    }
+    // Add to app config
+    if (configPaths.app) {
+        const validatedConfigPath = path.validatePath(configPaths.app);
+        let config;
+        try {
+            const content = await file.safeReadFile(validatedConfigPath);
+            config = file.safeJSONParse(content, validatedConfigPath);
+        }
+        catch {
+            config = { mcpServers: {} };
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        config.mcpServers[serverName] = serverConfig;
+        const content = file.formatJSON(config);
+        await file.atomicWrite(validatedConfigPath, content, { createBackup: true });
+        results.push(`App config (${path.getDisplayPath(configPaths.app)})`);
+    }
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    success: true,
+                    message: `Successfully installed MCP server: ${serverName}`,
+                    addedTo: results,
+                    server: {
+                        name: serverName,
+                        source,
+                        package: options.package,
+                        installPath,
+                        config: serverConfig,
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}
+async function handleMCPSync(args) {
+    const schema = z.object({
+        source: z.enum(['cli', 'app']).optional(),
+        dryRun: z.boolean().optional(),
+    });
+    const { source = 'app', dryRun = false } = schema.parse(args);
+    const sourcePath = source === 'cli' ? path.getClaudeCliConfigPath() : path.getConfigPaths().appConfig;
+    const targetPath = source === 'cli' ? path.getConfigPaths().appConfig : path.getClaudeCliConfigPath();
+    const sourceLabel = source === 'cli' ? 'CLI' : 'App';
+    const targetLabel = source === 'cli' ? 'App' : 'CLI';
+    // Read source config
+    let sourceConfig;
+    try {
+        const validatedSourcePath = path.validatePath(sourcePath);
+        const content = await file.safeReadFile(validatedSourcePath);
+        sourceConfig = file.safeJSONParse(content, validatedSourcePath);
+    }
+    catch {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Source ${sourceLabel} config not found or empty`,
+                },
+            ],
+        };
+    }
+    const sourceServers = sourceConfig.mcpServers || {};
+    // Read target config
+    let targetConfig;
+    try {
+        const validatedTargetPath = path.validatePath(targetPath);
+        const content = await file.safeReadFile(validatedTargetPath);
+        targetConfig = file.safeJSONParse(content, validatedTargetPath);
+    }
+    catch {
+        targetConfig = { mcpServers: {} };
+    }
+    if (!targetConfig.mcpServers) {
+        targetConfig.mcpServers = {};
+    }
+    // Calculate what needs to be synced
+    const sourceServerNames = new Set(Object.keys(sourceServers));
+    const targetServerNames = new Set(Object.keys(targetConfig.mcpServers));
+    const toAdd = [...sourceServerNames].filter(name => !targetServerNames.has(name));
+    const toUpdate = [...sourceServerNames].filter(name => targetServerNames.has(name) &&
+        JSON.stringify(sourceServers[name]) !== JSON.stringify(targetConfig.mcpServers[name]));
+    const toRemove = [...targetServerNames].filter(name => !sourceServerNames.has(name));
+    const summary = {
+        source: sourceLabel,
+        target: targetLabel,
+        toAdd,
+        toUpdate,
+        toRemove,
+        totalChanges: toAdd.length + toUpdate.length + toRemove.length,
+    };
+    if (dryRun) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        mode: 'dry-run',
+                        ...summary,
+                        message: `Would sync ${summary.totalChanges} changes from ${sourceLabel} to ${targetLabel}`,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    // Apply changes
+    const results = [];
+    // Add new servers
+    for (const name of toAdd) {
+        targetConfig.mcpServers[name] = sourceServers[name];
+        results.push(`Added: ${name}`);
+    }
+    // Update existing servers
+    for (const name of toUpdate) {
+        targetConfig.mcpServers[name] = sourceServers[name];
+        results.push(`Updated: ${name}`);
+    }
+    // Remove servers not in source
+    for (const name of toRemove) {
+        delete targetConfig.mcpServers[name];
+        results.push(`Removed: ${name}`);
+    }
+    // Write to target config
+    const validatedTargetPath = path.validatePath(targetPath);
+    const content = file.formatJSON(targetConfig);
+    await file.atomicWrite(validatedTargetPath, content, { createBackup: true });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    mode: 'sync',
+                    ...summary,
+                    changes: results,
+                    message: `Synced ${summary.totalChanges} changes from ${sourceLabel} to ${targetLabel}`,
+                }, null, 2),
+            },
+        ],
+    };
+}
+// ============================================================================
+// Server Startup
+// ============================================================================
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Claude Code Config MCP Server running');
+    console.error('Version: 1.0.0');
+    console.error('Runtime: Bun');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map