@ebowwa/claude-code-config-mcp 1.0.0

package/src/index.js

@@ -0,0 +1,2171 @@
+#!/usr/bin/env bun
+"use strict";
+// ============================================================================
+// Claude Code Config MCP Server
+// ============================================================================
+// Manage Claude Code configuration files with atomic writes, validation,
+// and comprehensive error handling.
+// ============================================================================
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+var stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+var types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+var zod_1 = require("zod");
+var node_path_1 = require("node:path");
+var path = require("./utils/path.js");
+var path_js_1 = require("./utils/path.js");
+var file = require("./utils/file.js");
+var errors = require("./utils/errors.js");
+// ============================================================================
+// MCP Server Setup
+// ============================================================================
+var server = new index_js_1.Server({
+    name: '@mcp/claude-code-config',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+/**
+ * List all available tools
+ */
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, ({
+                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(types_js_1.CallToolRequestSchema, function (request) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, name, args, _b, error_1, mcpError;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _a = request.params, name = _a.name, args = _a.arguments;
+                _c.label = 1;
+            case 1:
+                _c.trys.push([1, 50, , 51]);
+                _b = name;
+                switch (_b) {
+                    case 'read_global_claude_md': return [3 /*break*/, 2];
+                    case 'write_global_claude_md': return [3 /*break*/, 4];
+                    case 'read_project_claude_md': return [3 /*break*/, 6];
+                    case 'write_project_claude_md': return [3 /*break*/, 8];
+                    case 'read_keybindings': return [3 /*break*/, 10];
+                    case 'write_keybindings': return [3 /*break*/, 12];
+                    case 'add_keybinding': return [3 /*break*/, 14];
+                    case 'remove_keybinding': return [3 /*break*/, 16];
+                    case 'read_settings': return [3 /*break*/, 18];
+                    case 'write_settings': return [3 /*break*/, 20];
+                    case 'list_hooks': return [3 /*break*/, 22];
+                    case 'read_hook': return [3 /*break*/, 24];
+                    case 'write_hook': return [3 /*break*/, 26];
+                    case 'list_config_files': return [3 /*break*/, 28];
+                    case 'get_config_path': return [3 /*break*/, 30];
+                    case 'backup_config': return [3 /*break*/, 32];
+                    case 'mcp_list': return [3 /*break*/, 34];
+                    case 'mcp_get': return [3 /*break*/, 36];
+                    case 'mcp_add': return [3 /*break*/, 38];
+                    case 'mcp_install': return [3 /*break*/, 40];
+                    case 'mcp_remove': return [3 /*break*/, 42];
+                    case 'mcp_update': return [3 /*break*/, 44];
+                    case 'mcp_sync': return [3 /*break*/, 46];
+                }
+                return [3 /*break*/, 48];
+            case 2: return [4 /*yield*/, handleReadGlobalClaudeMd()];
+            case 3: return [2 /*return*/, _c.sent()];
+            case 4: return [4 /*yield*/, handleWriteGlobalClaudeMd(args)];
+            case 5: return [2 /*return*/, _c.sent()];
+            case 6: return [4 /*yield*/, handleReadProjectClaudeMd(args)];
+            case 7: return [2 /*return*/, _c.sent()];
+            case 8: return [4 /*yield*/, handleWriteProjectClaudeMd(args)];
+            case 9: return [2 /*return*/, _c.sent()];
+            case 10: return [4 /*yield*/, handleReadKeybindings()];
+            case 11: return [2 /*return*/, _c.sent()];
+            case 12: return [4 /*yield*/, handleWriteKeybindings(args)];
+            case 13: return [2 /*return*/, _c.sent()];
+            case 14: return [4 /*yield*/, handleAddKeybinding(args)];
+            case 15: return [2 /*return*/, _c.sent()];
+            case 16: return [4 /*yield*/, handleRemoveKeybinding(args)];
+            case 17: return [2 /*return*/, _c.sent()];
+            case 18: return [4 /*yield*/, handleReadSettings()];
+            case 19: return [2 /*return*/, _c.sent()];
+            case 20: return [4 /*yield*/, handleWriteSettings(args)];
+            case 21: return [2 /*return*/, _c.sent()];
+            case 22: return [4 /*yield*/, handleListHooks()];
+            case 23: return [2 /*return*/, _c.sent()];
+            case 24: return [4 /*yield*/, handleReadHook(args)];
+            case 25: return [2 /*return*/, _c.sent()];
+            case 26: return [4 /*yield*/, handleWriteHook(args)];
+            case 27: return [2 /*return*/, _c.sent()];
+            case 28: return [4 /*yield*/, handleListConfigFiles(args)];
+            case 29: return [2 /*return*/, _c.sent()];
+            case 30: return [4 /*yield*/, handleGetConfigPath(args)];
+            case 31: return [2 /*return*/, _c.sent()];
+            case 32: return [4 /*yield*/, handleBackupConfig(args)];
+            case 33: return [2 /*return*/, _c.sent()];
+            case 34: return [4 /*yield*/, handleMCPList(args)];
+            case 35: return [2 /*return*/, _c.sent()];
+            case 36: return [4 /*yield*/, handleMCPGet(args)];
+            case 37: return [2 /*return*/, _c.sent()];
+            case 38: return [4 /*yield*/, handleMCPAdd(args)];
+            case 39: return [2 /*return*/, _c.sent()];
+            case 40: return [4 /*yield*/, handleMCPInstall(args)];
+            case 41: return [2 /*return*/, _c.sent()];
+            case 42: return [4 /*yield*/, handleMCPRemove(args)];
+            case 43: return [2 /*return*/, _c.sent()];
+            case 44: return [4 /*yield*/, handleMCPUpdate(args)];
+            case 45: return [2 /*return*/, _c.sent()];
+            case 46: return [4 /*yield*/, handleMCPSync(args)];
+            case 47: return [2 /*return*/, _c.sent()];
+            case 48: throw new Error("Unknown tool: ".concat(name));
+            case 49: return [3 /*break*/, 51];
+            case 50:
+                error_1 = _c.sent();
+                mcpError = errors.createMCPError(error_1);
+                return [2 /*return*/, {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(mcpError, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    }];
+            case 51: return [2 /*return*/];
+        }
+    });
+}); });
+// ============================================================================
+// CLAUDE.md Handlers
+// ============================================================================
+function handleReadGlobalClaudeMd() {
+    return __awaiter(this, void 0, void 0, function () {
+        var filePath, validatedPath, content, stats;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    filePath = path.getConfigPaths().globalClaudeMd;
+                    validatedPath = path.validatePath(filePath);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 1:
+                    content = _a.sent();
+                    return [4 /*yield*/, getFileInfo(validatedPath)];
+                case 2:
+                    stats = _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: content,
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleWriteGlobalClaudeMd(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, content, _b, createBackup, filePath, validatedPath, normalized, stripped;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        content: zod_1.z.string(),
+                        createBackup: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), content = _a.content, _b = _a.createBackup, createBackup = _b === void 0 ? true : _b;
+                    filePath = path.getConfigPaths().globalClaudeMd;
+                    validatedPath = path.validatePath(filePath);
+                    normalized = file.normalizeLineEndings(content);
+                    stripped = file.stripBOM(normalized);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, stripped, { createBackup: createBackup })];
+                case 1:
+                    _c.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully wrote global CLAUDE.md to ".concat(path.getDisplayPath(validatedPath)),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleReadProjectClaudeMd(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, projectPath, cwd, filePath, validatedPath, content;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        projectPath: zod_1.z.string().optional(),
+                    });
+                    projectPath = schema.parse(args).projectPath;
+                    cwd = projectPath || process.cwd();
+                    filePath = path.getConfigPaths(cwd).projectClaudeMd;
+                    validatedPath = path.validatePath(filePath, cwd);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 1:
+                    content = _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: content,
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleWriteProjectClaudeMd(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, content, projectPath, _b, createBackup, cwd, filePath, validatedPath, normalized, stripped;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        content: zod_1.z.string(),
+                        projectPath: zod_1.z.string().optional(),
+                        createBackup: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), content = _a.content, projectPath = _a.projectPath, _b = _a.createBackup, createBackup = _b === void 0 ? true : _b;
+                    cwd = projectPath || process.cwd();
+                    filePath = path.getConfigPaths(cwd).projectClaudeMd;
+                    validatedPath = path.validatePath(filePath, cwd);
+                    normalized = file.normalizeLineEndings(content);
+                    stripped = file.stripBOM(normalized);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, stripped, { createBackup: createBackup })];
+                case 1:
+                    _c.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully wrote project CLAUDE.md to ".concat(path.getDisplayPath(validatedPath)),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+// ============================================================================
+// Keybindings Handlers
+// ============================================================================
+function handleReadKeybindings() {
+    return __awaiter(this, void 0, void 0, function () {
+        var filePath, validatedPath, content, config;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    filePath = path.getConfigPaths().keybindings;
+                    validatedPath = path.validatePath(filePath);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 1:
+                    content = _a.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(config, null, 2),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleWriteKeybindings(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, keybindings, _b, createBackup, filePath, validatedPath, content;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        keybindings: zod_1.z.object({
+                            $schema: zod_1.z.string().optional(),
+                            keybindings: zod_1.z.record(zod_1.z.string(), zod_1.z.object({
+                                key: zod_1.z.string(),
+                                command: zod_1.z.string(),
+                                when: zod_1.z.string().optional(),
+                            })),
+                        }),
+                        createBackup: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), keybindings = _a.keybindings, _b = _a.createBackup, createBackup = _b === void 0 ? true : _b;
+                    filePath = path.getConfigPaths().keybindings;
+                    validatedPath = path.validatePath(filePath);
+                    content = file.formatJSON(keybindings);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, content, { createBackup: createBackup })];
+                case 1:
+                    _c.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully wrote keybindings to ".concat(path.getDisplayPath(validatedPath)),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleAddKeybinding(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, key, command, when, filePath, validatedPath, config, content_1, _b, content;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        key: zod_1.z.string(),
+                        command: zod_1.z.string(),
+                        when: zod_1.z.string().optional(),
+                    });
+                    _a = schema.parse(args), key = _a.key, command = _a.command, when = _a.when;
+                    filePath = path.getConfigPaths().keybindings;
+                    validatedPath = path.validatePath(filePath);
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 2:
+                    content_1 = _c.sent();
+                    config = file.safeJSONParse(content_1, validatedPath);
+                    return [3 /*break*/, 4];
+                case 3:
+                    _b = _c.sent();
+                    // Create new config if file doesn't exist
+                    config = { keybindings: {} };
+                    return [3 /*break*/, 4];
+                case 4:
+                    // Add/update keybinding
+                    config.keybindings[key] = __assign({ key: key, command: command }, (when && { when: when }));
+                    content = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, content, { createBackup: true })];
+                case 5:
+                    _c.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully added keybinding: ".concat(key, " -> ").concat(command),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleRemoveKeybinding(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, key, filePath, validatedPath, content, config, newContent;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        key: zod_1.z.string(),
+                    });
+                    key = schema.parse(args).key;
+                    filePath = path.getConfigPaths().keybindings;
+                    validatedPath = path.validatePath(filePath);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 1:
+                    content = _a.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    // Remove keybinding
+                    delete config.keybindings[key];
+                    newContent = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, newContent, { createBackup: true })];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully removed keybinding: ".concat(key),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+// ============================================================================
+// Settings Handlers
+// ============================================================================
+function handleReadSettings() {
+    return __awaiter(this, void 0, void 0, function () {
+        var filePath, validatedPath, content;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    filePath = path.getConfigPaths().settings;
+                    validatedPath = path.validatePath(filePath);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 1:
+                    content = _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: content,
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleWriteSettings(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, settings, _b, createBackup, filePath, validatedPath, content;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        settings: zod_1.z.object({
+                            $schema: zod_1.z.string().optional(),
+                        }).passthrough(),
+                        createBackup: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), settings = _a.settings, _b = _a.createBackup, createBackup = _b === void 0 ? true : _b;
+                    filePath = path.getConfigPaths().settings;
+                    validatedPath = path.validatePath(filePath);
+                    content = file.formatJSON(settings);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, content, { createBackup: createBackup })];
+                case 1:
+                    _c.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully wrote settings to ".concat(path.getDisplayPath(validatedPath)),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+// ============================================================================
+// Hooks Handlers
+// ============================================================================
+function handleListHooks() {
+    return __awaiter(this, void 0, void 0, function () {
+        var hooksDir, validatedPath, hooks;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    hooksDir = path.getConfigPaths().hooksDir;
+                    validatedPath = path.validatePath(hooksDir);
+                    return [4 /*yield*/, listHookFiles(validatedPath)];
+                case 1:
+                    hooks = _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(hooks, null, 2),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleReadHook(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, name, hooksDir, validatedPath, hookPath, validatedHookPath, content;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        name: zod_1.z.string(),
+                    });
+                    name = schema.parse(args).name;
+                    hooksDir = path.getConfigPaths().hooksDir;
+                    validatedPath = path.validatePath(hooksDir);
+                    hookPath = "".concat(validatedPath, "/").concat(name);
+                    validatedHookPath = path.validatePath(hookPath);
+                    return [4 /*yield*/, file.safeReadFile(validatedHookPath)];
+                case 1:
+                    content = _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: content,
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleWriteHook(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, name, event, content, _b, enabled, hooksDir, validatedPath, hookPath, validatedHookPath;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        name: zod_1.z.string(),
+                        event: zod_1.z.string(),
+                        content: zod_1.z.string(),
+                        enabled: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), name = _a.name, event = _a.event, content = _a.content, _b = _a.enabled, enabled = _b === void 0 ? true : _b;
+                    hooksDir = path.getConfigPaths().hooksDir;
+                    validatedPath = path.validatePath(hooksDir);
+                    hookPath = "".concat(validatedPath, "/").concat(name);
+                    validatedHookPath = path.validatePath(hookPath);
+                    return [4 /*yield*/, file.atomicWrite(validatedHookPath, content, { createBackup: true })];
+                case 1:
+                    _c.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully wrote hook: ".concat(name),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+// ============================================================================
+// Utility Handlers
+// ============================================================================
+function handleListConfigFiles(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, includeProject, paths, cwd, files;
+        return __generator(this, function (_b) {
+            schema = zod_1.z.object({
+                includeProject: zod_1.z.boolean().optional(),
+            });
+            _a = schema.parse(args).includeProject, includeProject = _a === void 0 ? true : _a;
+            paths = path.getConfigPaths();
+            cwd = process.cwd();
+            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 [2 /*return*/, {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(files, null, 2),
+                        },
+                    ],
+                }];
+        });
+    });
+}
+function handleGetConfigPath(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, fileType, paths, filePathMap, resolvedPath, displayPath;
+        return __generator(this, function (_a) {
+            schema = zod_1.z.object({
+                fileType: zod_1.z.enum([
+                    'CLAUDE_MD_GLOBAL',
+                    'CLAUDE_MD_PROJECT',
+                    'KEYBINDINGS',
+                    'SETTINGS',
+                    'HOOKS_DIR',
+                ]),
+            });
+            fileType = schema.parse(args).fileType;
+            paths = path.getConfigPaths();
+            filePathMap = {
+                CLAUDE_MD_GLOBAL: paths.globalClaudeMd,
+                CLAUDE_MD_PROJECT: paths.projectClaudeMd,
+                KEYBINDINGS: paths.keybindings,
+                SETTINGS: paths.settings,
+                HOOKS_DIR: paths.hooksDir,
+            };
+            resolvedPath = filePathMap[fileType];
+            displayPath = path.getDisplayPath(resolvedPath);
+            return [2 /*return*/, {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                type: fileType,
+                                path: displayPath,
+                                absolutePath: resolvedPath,
+                                exists: path.pathExists(resolvedPath),
+                            }, null, 2),
+                        },
+                    ],
+                }];
+        });
+    });
+}
+function handleBackupConfig(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, fileType, paths, filePathMap, filePath, validatedPath, backupPath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        fileType: zod_1.z.enum(['CLAUDE_MD', 'KEYBINDINGS', 'SETTINGS']),
+                    });
+                    fileType = schema.parse(args).fileType;
+                    paths = path.getConfigPaths();
+                    filePathMap = {
+                        CLAUDE_MD: paths.globalClaudeMd,
+                        KEYBINDINGS: paths.keybindings,
+                        SETTINGS: paths.settings,
+                    };
+                    filePath = filePathMap[fileType];
+                    validatedPath = path.validatePath(filePath);
+                    if (!path.pathExists(validatedPath)) {
+                        throw new Error("File does not exist: ".concat(fileType));
+                    }
+                    return [4 /*yield*/, createBackup(validatedPath)];
+                case 1:
+                    backupPath = _a.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Backup created: ".concat(path.getDisplayPath(backupPath)),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function getFileInfo(filePath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var stat, stats;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require('node:fs/promises'); })];
+                case 1:
+                    stat = (_a.sent()).stat;
+                    return [4 /*yield*/, stat(filePath)];
+                case 2:
+                    stats = _a.sent();
+                    return [2 /*return*/, {
+                            size: stats.size,
+                            modified: stats.mtime,
+                        }];
+            }
+        });
+    });
+}
+function listHookFiles(hooksDir) {
+    return __awaiter(this, void 0, void 0, function () {
+        var readdir, existsSync, files, hooks, _i, files_1, file_1, name_1, event_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return require('node:fs/promises'); })];
+                case 1:
+                    readdir = (_a.sent()).readdir;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('node:fs'); })];
+                case 2:
+                    existsSync = (_a.sent()).existsSync;
+                    if (!existsSync(hooksDir)) {
+                        return [2 /*return*/, []];
+                    }
+                    return [4 /*yield*/, readdir(hooksDir, { withFileTypes: true })];
+                case 3:
+                    files = _a.sent();
+                    hooks = [];
+                    for (_i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        file_1 = files_1[_i];
+                        if (file_1.isFile()) {
+                            name_1 = file_1.name;
+                            event_1 = name_1.replace(/\.(ts|js|sh)$/, '');
+                            hooks.push({ name: name_1, event: event_1, enabled: true });
+                        }
+                    }
+                    return [2 /*return*/, hooks];
+            }
+        });
+    });
+}
+function createBackup(filePath) {
+    return __awaiter(this, void 0, void 0, function () {
+        var timestamp, backupPath, _a, readFile, writeFile, content;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                    backupPath = "".concat(filePath, ".backup.").concat(timestamp);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('node:fs/promises'); })];
+                case 1:
+                    _a = _b.sent(), readFile = _a.readFile, writeFile = _a.writeFile;
+                    return [4 /*yield*/, readFile(filePath)];
+                case 2:
+                    content = _b.sent();
+                    return [4 /*yield*/, writeFile(backupPath, content)];
+                case 3:
+                    _b.sent();
+                    return [2 /*return*/, backupPath];
+            }
+        });
+    });
+}
+// ============================================================================
+// MCP Management Handlers
+// ============================================================================
+function handleMCPList(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, _b, target, _c, includeHealth, configPaths, results, validatedPath, content, _d, validatedPath, content, _e, healthInfo, exec_1, result, lines, _i, lines_1, line, match, name_2, status_1, _f, output, cliServers, appServers;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        target: zod_1.z.enum(['cli', 'app', 'both']).optional(),
+                        includeHealth: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), _b = _a.target, target = _b === void 0 ? 'both' : _b, _c = _a.includeHealth, includeHealth = _c === void 0 ? false : _c;
+                    configPaths = (0, path_js_1.getMCPConfigPaths)(target);
+                    results = {};
+                    if (!configPaths.cli) return [3 /*break*/, 4];
+                    _g.label = 1;
+                case 1:
+                    _g.trys.push([1, 3, , 4]);
+                    validatedPath = path.validatePath(configPaths.cli);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 2:
+                    content = _g.sent();
+                    results.cli = {
+                        config: file.safeJSONParse(content, validatedPath),
+                        source: 'cli',
+                    };
+                    return [3 /*break*/, 4];
+                case 3:
+                    _d = _g.sent();
+                    results.cli = { config: { mcpServers: {} }, source: 'cli' };
+                    return [3 /*break*/, 4];
+                case 4:
+                    if (!configPaths.app) return [3 /*break*/, 8];
+                    _g.label = 5;
+                case 5:
+                    _g.trys.push([5, 7, , 8]);
+                    validatedPath = path.validatePath(configPaths.app);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 6:
+                    content = _g.sent();
+                    results.app = {
+                        config: file.safeJSONParse(content, validatedPath),
+                        source: 'app',
+                    };
+                    return [3 /*break*/, 8];
+                case 7:
+                    _e = _g.sent();
+                    results.app = { config: { mcpServers: {} }, source: 'app' };
+                    return [3 /*break*/, 8];
+                case 8:
+                    healthInfo = {};
+                    if (!includeHealth) return [3 /*break*/, 13];
+                    _g.label = 9;
+                case 9:
+                    _g.trys.push([9, 12, , 13]);
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('node:child_process'); })];
+                case 10:
+                    exec_1 = (_g.sent()).exec;
+                    return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            exec_1('claude mcp list 2>&1', function (error, stdout, stderr) {
+                                if (error) {
+                                    resolve(stderr || stdout);
+                                }
+                                else {
+                                    resolve(stdout);
+                                }
+                            });
+                        })];
+                case 11:
+                    result = _g.sent();
+                    lines = result.split('\n');
+                    for (_i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+                        line = lines_1[_i];
+                        match = line.match(/^([^:]+):\s+.*?-\s+([✓✗])/);
+                        if (match) {
+                            name_2 = match[1].trim();
+                            status_1 = match[2] === '✓' ? 'connected' : 'error';
+                            healthInfo[name_2] = status_1;
+                        }
+                    }
+                    return [3 /*break*/, 13];
+                case 12:
+                    _f = _g.sent();
+                    return [3 /*break*/, 13];
+                case 13:
+                    output = {};
+                    if (results.cli) {
+                        cliServers = Object.entries(results.cli.config.mcpServers || {}).map(function (_a) {
+                            var name = _a[0], serverConfig = _a[1];
+                            return (__assign(__assign({}, serverConfig), { name: name, source: 'cli', health: healthInfo[name] }));
+                        });
+                        output.cli = { mcpServers: cliServers };
+                    }
+                    if (results.app) {
+                        appServers = Object.entries(results.app.config.mcpServers || {}).map(function (_a) {
+                            var name = _a[0], serverConfig = _a[1];
+                            return (__assign(__assign({}, serverConfig), { name: name, source: 'app', health: healthInfo[name] }));
+                        });
+                        output.app = { mcpServers: appServers };
+                    }
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(output, null, 2),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleMCPGet(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, name, _b, target, configPaths, results, found, validatedPath, content, config, serverConfig, _c, validatedPath, content, config, serverConfig, _d;
+        var _e, _f;
+        return __generator(this, function (_g) {
+            switch (_g.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        name: zod_1.z.string(),
+                        target: zod_1.z.enum(['cli', 'app', 'both']).optional(),
+                    });
+                    _a = schema.parse(args), name = _a.name, _b = _a.target, target = _b === void 0 ? 'both' : _b;
+                    configPaths = (0, path_js_1.getMCPConfigPaths)(target);
+                    results = {};
+                    found = false;
+                    if (!configPaths.cli) return [3 /*break*/, 4];
+                    _g.label = 1;
+                case 1:
+                    _g.trys.push([1, 3, , 4]);
+                    validatedPath = path.validatePath(configPaths.cli);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 2:
+                    content = _g.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    serverConfig = (_e = config.mcpServers) === null || _e === void 0 ? void 0 : _e[name];
+                    if (serverConfig) {
+                        results.cli = __assign(__assign({ name: name }, serverConfig), { source: 'cli' });
+                        found = true;
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    _c = _g.sent();
+                    return [3 /*break*/, 4];
+                case 4:
+                    if (!configPaths.app) return [3 /*break*/, 8];
+                    _g.label = 5;
+                case 5:
+                    _g.trys.push([5, 7, , 8]);
+                    validatedPath = path.validatePath(configPaths.app);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 6:
+                    content = _g.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    serverConfig = (_f = config.mcpServers) === null || _f === void 0 ? void 0 : _f[name];
+                    if (serverConfig) {
+                        results.app = __assign(__assign({ name: name }, serverConfig), { source: 'app' });
+                        found = true;
+                    }
+                    return [3 /*break*/, 8];
+                case 7:
+                    _d = _g.sent();
+                    return [3 /*break*/, 8];
+                case 8:
+                    if (!found) {
+                        throw new Error("MCP server not found: ".concat(name));
+                    }
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(results, null, 2),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleMCPAdd(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, options, configPaths, results, serverConfig, validatedPath, config, content_2, _a, content, validatedPath, config, content_3, _b, content;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        name: zod_1.z.string().min(1),
+                        command: zod_1.z.string().optional(),
+                        args: zod_1.z.array(zod_1.z.string()).optional(),
+                        url: zod_1.z.string().optional(),
+                        transport: zod_1.z.enum(['stdio', 'sse', 'http', 'ws', 'websocket']).optional(),
+                        env: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+                        headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+                        description: zod_1.z.string().optional(),
+                        alwaysAllow: zod_1.z.boolean().optional(),
+                        timeout: zod_1.z.number().optional(),
+                        target: zod_1.z.enum(['cli', 'app', 'both']).optional(),
+                    });
+                    options = schema.parse(args);
+                    configPaths = (0, path_js_1.getMCPConfigPaths)(options.target || 'both');
+                    results = [];
+                    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;
+                    if (!configPaths.cli) return [3 /*break*/, 6];
+                    validatedPath = path.validatePath(configPaths.cli);
+                    config = void 0;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 2:
+                    content_2 = _c.sent();
+                    config = file.safeJSONParse(content_2, validatedPath);
+                    return [3 /*break*/, 4];
+                case 3:
+                    _a = _c.sent();
+                    config = { mcpServers: {} };
+                    return [3 /*break*/, 4];
+                case 4:
+                    if (!config.mcpServers) {
+                        config.mcpServers = {};
+                    }
+                    if (config.mcpServers[options.name]) {
+                        throw new Error("MCP server already exists in CLI config: ".concat(options.name));
+                    }
+                    config.mcpServers[options.name] = serverConfig;
+                    content = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, content, { createBackup: true })];
+                case 5:
+                    _c.sent();
+                    results.push("CLI config (".concat(path.getDisplayPath(configPaths.cli), ")"));
+                    _c.label = 6;
+                case 6:
+                    if (!configPaths.app) return [3 /*break*/, 12];
+                    validatedPath = path.validatePath(configPaths.app);
+                    config = void 0;
+                    _c.label = 7;
+                case 7:
+                    _c.trys.push([7, 9, , 10]);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 8:
+                    content_3 = _c.sent();
+                    config = file.safeJSONParse(content_3, validatedPath);
+                    return [3 /*break*/, 10];
+                case 9:
+                    _b = _c.sent();
+                    config = { mcpServers: {} };
+                    return [3 /*break*/, 10];
+                case 10:
+                    if (!config.mcpServers) {
+                        config.mcpServers = {};
+                    }
+                    if (config.mcpServers[options.name]) {
+                        throw new Error("MCP server already exists in app config: ".concat(options.name));
+                    }
+                    config.mcpServers[options.name] = serverConfig;
+                    content = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, content, { createBackup: true })];
+                case 11:
+                    _c.sent();
+                    results.push("App config (".concat(path.getDisplayPath(configPaths.app), ")"));
+                    _c.label = 12;
+                case 12: return [2 /*return*/, {
+                        content: [
+                            {
+                                type: 'text',
+                                text: "Successfully added MCP server: ".concat(options.name, "\nAdded to: ").concat(results.join(', ')),
+                            },
+                        ],
+                    }];
+            }
+        });
+    });
+}
+function handleMCPRemove(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, name, _b, target, configPaths, results, found, validatedPath, content, config, newContent, _c, validatedPath, content, config, newContent, _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        name: zod_1.z.string(),
+                        target: zod_1.z.enum(['cli', 'app', 'both']).optional(),
+                    });
+                    _a = schema.parse(args), name = _a.name, _b = _a.target, target = _b === void 0 ? 'both' : _b;
+                    configPaths = (0, path_js_1.getMCPConfigPaths)(target);
+                    results = [];
+                    found = false;
+                    if (!configPaths.cli) return [3 /*break*/, 6];
+                    _e.label = 1;
+                case 1:
+                    _e.trys.push([1, 5, , 6]);
+                    validatedPath = path.validatePath(configPaths.cli);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 2:
+                    content = _e.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    if (!(config.mcpServers && config.mcpServers[name])) return [3 /*break*/, 4];
+                    delete config.mcpServers[name];
+                    newContent = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, newContent, { createBackup: true })];
+                case 3:
+                    _e.sent();
+                    results.push("CLI config (".concat(path.getDisplayPath(configPaths.cli), ")"));
+                    found = true;
+                    _e.label = 4;
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    _c = _e.sent();
+                    return [3 /*break*/, 6];
+                case 6:
+                    if (!configPaths.app) return [3 /*break*/, 12];
+                    _e.label = 7;
+                case 7:
+                    _e.trys.push([7, 11, , 12]);
+                    validatedPath = path.validatePath(configPaths.app);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 8:
+                    content = _e.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    if (!(config.mcpServers && config.mcpServers[name])) return [3 /*break*/, 10];
+                    delete config.mcpServers[name];
+                    newContent = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, newContent, { createBackup: true })];
+                case 9:
+                    _e.sent();
+                    results.push("App config (".concat(path.getDisplayPath(configPaths.app), ")"));
+                    found = true;
+                    _e.label = 10;
+                case 10: return [3 /*break*/, 12];
+                case 11:
+                    _d = _e.sent();
+                    return [3 /*break*/, 12];
+                case 12:
+                    if (!found) {
+                        throw new Error("MCP server not found: ".concat(name));
+                    }
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully removed MCP server: ".concat(name, "\nRemoved from: ").concat(results.join(', ')),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleMCPUpdate(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, options, configPaths, results, found, validatedPath, content, config, serverConfig, newContent, _a, validatedPath, content, config, serverConfig, newContent, _b;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        name: zod_1.z.string(),
+                        command: zod_1.z.string().optional(),
+                        args: zod_1.z.array(zod_1.z.string()).optional(),
+                        url: zod_1.z.string().optional(),
+                        env: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+                        headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+                        description: zod_1.z.string().optional(),
+                        alwaysAllow: zod_1.z.boolean().optional(),
+                        timeout: zod_1.z.number().optional(),
+                        target: zod_1.z.enum(['cli', 'app', 'both']).optional(),
+                    });
+                    options = schema.parse(args);
+                    configPaths = (0, path_js_1.getMCPConfigPaths)(options.target || 'both');
+                    results = [];
+                    found = false;
+                    if (!configPaths.cli) return [3 /*break*/, 6];
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 5, , 6]);
+                    validatedPath = path.validatePath(configPaths.cli);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 2:
+                    content = _c.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    if (!(config.mcpServers && config.mcpServers[options.name])) return [3 /*break*/, 4];
+                    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;
+                    newContent = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, newContent, { createBackup: true })];
+                case 3:
+                    _c.sent();
+                    results.push("CLI config (".concat(path.getDisplayPath(configPaths.cli), ")"));
+                    found = true;
+                    _c.label = 4;
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    _a = _c.sent();
+                    return [3 /*break*/, 6];
+                case 6:
+                    if (!configPaths.app) return [3 /*break*/, 12];
+                    _c.label = 7;
+                case 7:
+                    _c.trys.push([7, 11, , 12]);
+                    validatedPath = path.validatePath(configPaths.app);
+                    return [4 /*yield*/, file.safeReadFile(validatedPath)];
+                case 8:
+                    content = _c.sent();
+                    config = file.safeJSONParse(content, validatedPath);
+                    if (!(config.mcpServers && config.mcpServers[options.name])) return [3 /*break*/, 10];
+                    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;
+                    newContent = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedPath, newContent, { createBackup: true })];
+                case 9:
+                    _c.sent();
+                    results.push("App config (".concat(path.getDisplayPath(configPaths.app), ")"));
+                    found = true;
+                    _c.label = 10;
+                case 10: return [3 /*break*/, 12];
+                case 11:
+                    _b = _c.sent();
+                    return [3 /*break*/, 12];
+                case 12:
+                    if (!found) {
+                        throw new Error("MCP server not found: ".concat(options.name));
+                    }
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Successfully updated MCP server: ".concat(options.name, "\nUpdated in: ").concat(results.join(', ')),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+function handleMCPInstall(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, options, target, source, installDir, mkdir, serverName, serverConfig, installPath, _a, packageName, version, execSync, packageJsonPath, packageJsonContent, packageJson, entryPoint, binName, repo, repoName, execSync, packageJsonPath, packageJsonContent, packageJson, entryPoint, distPath, packageJsonPath, packageJsonContent, packageJson, entryPoint, entryPath, configPaths, results, validatedConfigPath, config, content_4, _b, content, validatedConfigPath, config, content_5, _c, content;
+        var _d;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        source: zod_1.z.enum(['npm', 'github', 'local', 'url']).optional(),
+                        package: zod_1.z.string(),
+                        name: zod_1.z.string().optional(),
+                        version: zod_1.z.string().optional(),
+                        env: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+                        description: zod_1.z.string().optional(),
+                        args: zod_1.z.array(zod_1.z.string()).optional(),
+                        installDir: zod_1.z.string().optional(),
+                        force: zod_1.z.boolean().optional(),
+                        target: zod_1.z.enum(['cli', 'app', 'both']).optional(),
+                    });
+                    options = schema.parse(args);
+                    target = options.target || 'both';
+                    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';
+                        }
+                    }
+                    installDir = options.installDir || (0, node_path_1.join)(path.getHomeDir(), '.claude', 'mcp-servers');
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('node:fs/promises'); })];
+                case 1:
+                    mkdir = (_e.sent()).mkdir;
+                    return [4 /*yield*/, mkdir(installDir, { recursive: true })];
+                case 2:
+                    _e.sent();
+                    serverName = options.name;
+                    serverConfig = {};
+                    _a = source;
+                    switch (_a) {
+                        case 'npm': return [3 /*break*/, 3];
+                        case 'github': return [3 /*break*/, 8];
+                        case 'local': return [3 /*break*/, 12];
+                        case 'url': return [3 /*break*/, 14];
+                    }
+                    return [3 /*break*/, 15];
+                case 3:
+                    packageName = options.package;
+                    version = options.version || 'latest';
+                    serverName = serverName || packageName.replace(/^@[^/]+\//, '').replace(/^mcp-server-/, '').replace(/^server-/, '');
+                    installPath = (0, node_path_1.join)(installDir, 'node_modules', packageName);
+                    if (!(!options.force && path.pathExists((0, node_path_1.join)(installPath, 'package.json')))) return [3 /*break*/, 4];
+                    return [3 /*break*/, 6];
+                case 4: return [4 /*yield*/, Promise.resolve().then(function () { return require('node:child_process'); })];
+                case 5:
+                    execSync = (_e.sent()).execSync;
+                    execSync("bun install ".concat(packageName, "@").concat(version), {
+                        cwd: installDir,
+                        stdio: 'inherit',
+                    });
+                    _e.label = 6;
+                case 6:
+                    packageJsonPath = (0, node_path_1.join)(installPath, 'package.json');
+                    return [4 /*yield*/, file.safeReadFile(packageJsonPath)];
+                case 7:
+                    packageJsonContent = _e.sent();
+                    packageJson = JSON.parse(packageJsonContent);
+                    entryPoint = packageJson.bin || packageJson.main || 'index.js';
+                    if (typeof entryPoint === 'string') {
+                        serverConfig.command = 'node';
+                        serverConfig.args = __spreadArray([(0, node_path_1.join)(installPath, entryPoint)], (options.args || []), true);
+                    }
+                    else if (typeof entryPoint === 'object') {
+                        binName = Object.keys(entryPoint)[0];
+                        serverConfig.command = 'node';
+                        serverConfig.args = __spreadArray([(0, node_path_1.join)(installPath, entryPoint[binName])], (options.args || []), true);
+                    }
+                    serverConfig.description = options.description || packageJson.description;
+                    return [3 /*break*/, 16];
+                case 8:
+                    repo = options.package.replace(/\.git$/, '');
+                    repoName = repo.split('/').pop() || 'mcp-server';
+                    serverName = serverName || repoName.replace(/^mcp-/, '').replace(/^server-/, '');
+                    installPath = (0, node_path_1.join)(installDir, repoName);
+                    if (!(options.force || !path.pathExists((0, node_path_1.join)(installPath, '.git')))) return [3 /*break*/, 10];
+                    return [4 /*yield*/, Promise.resolve().then(function () { return require('node:child_process'); })];
+                case 9:
+                    execSync = (_e.sent()).execSync;
+                    execSync("git clone ".concat(options.package, " \"").concat(installPath, "\""), {
+                        stdio: 'inherit',
+                    });
+                    _e.label = 10;
+                case 10:
+                    packageJsonPath = (0, node_path_1.join)(installPath, 'package.json');
+                    return [4 /*yield*/, file.safeReadFile(packageJsonPath)];
+                case 11:
+                    packageJsonContent = _e.sent();
+                    packageJson = JSON.parse(packageJsonContent);
+                    entryPoint = packageJson.main || 'dist/index.js';
+                    distPath = (0, node_path_1.join)(installPath, entryPoint);
+                    serverConfig.command = 'node';
+                    serverConfig.args = __spreadArray([distPath], (options.args || []), true);
+                    serverConfig.description = options.description || packageJson.description;
+                    return [3 /*break*/, 16];
+                case 12:
+                    // Link local package
+                    installPath = (0, node_path_1.resolve)(options.package);
+                    if (!path.pathExists(installPath)) {
+                        throw new Error("Local path does not exist: ".concat(installPath));
+                    }
+                    packageJsonPath = (0, node_path_1.join)(installPath, 'package.json');
+                    return [4 /*yield*/, file.safeReadFile(packageJsonPath)];
+                case 13:
+                    packageJsonContent = _e.sent();
+                    packageJson = JSON.parse(packageJsonContent);
+                    serverName = serverName || ((_d = packageJson.name) === null || _d === void 0 ? void 0 : _d.replace(/^@[^/]+\//, '').replace(/^mcp-server-/, '').replace(/^server-/, '')) || 'local-mcp';
+                    entryPoint = packageJson.bin || packageJson.main || 'dist/index.js';
+                    entryPath = typeof entryPoint === 'string' ? (0, node_path_1.join)(installPath, entryPoint) : installPath;
+                    serverConfig.command = 'node';
+                    serverConfig.args = __spreadArray([entryPath], (options.args || []), true);
+                    serverConfig.description = options.description || packageJson.description;
+                    return [3 /*break*/, 16];
+                case 14:
+                    {
+                        // Download from URL and install
+                        throw new Error('URL source not yet implemented');
+                    }
+                    _e.label = 15;
+                case 15:
+                    {
+                        throw new Error("Unknown source type: ".concat(source));
+                    }
+                    _e.label = 16;
+                case 16:
+                    // Add environment variables
+                    if (options.env) {
+                        serverConfig.env = options.env;
+                    }
+                    configPaths = (0, path_js_1.getMCPConfigPaths)(target);
+                    results = [];
+                    if (!configPaths.cli) return [3 /*break*/, 22];
+                    validatedConfigPath = path.validatePath(configPaths.cli);
+                    config = void 0;
+                    _e.label = 17;
+                case 17:
+                    _e.trys.push([17, 19, , 20]);
+                    return [4 /*yield*/, file.safeReadFile(validatedConfigPath)];
+                case 18:
+                    content_4 = _e.sent();
+                    config = file.safeJSONParse(content_4, validatedConfigPath);
+                    return [3 /*break*/, 20];
+                case 19:
+                    _b = _e.sent();
+                    config = { mcpServers: {} };
+                    return [3 /*break*/, 20];
+                case 20:
+                    if (!config.mcpServers) {
+                        config.mcpServers = {};
+                    }
+                    config.mcpServers[serverName] = serverConfig;
+                    content = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedConfigPath, content, { createBackup: true })];
+                case 21:
+                    _e.sent();
+                    results.push("CLI config (".concat(path.getDisplayPath(configPaths.cli), ")"));
+                    _e.label = 22;
+                case 22:
+                    if (!configPaths.app) return [3 /*break*/, 28];
+                    validatedConfigPath = path.validatePath(configPaths.app);
+                    config = void 0;
+                    _e.label = 23;
+                case 23:
+                    _e.trys.push([23, 25, , 26]);
+                    return [4 /*yield*/, file.safeReadFile(validatedConfigPath)];
+                case 24:
+                    content_5 = _e.sent();
+                    config = file.safeJSONParse(content_5, validatedConfigPath);
+                    return [3 /*break*/, 26];
+                case 25:
+                    _c = _e.sent();
+                    config = { mcpServers: {} };
+                    return [3 /*break*/, 26];
+                case 26:
+                    if (!config.mcpServers) {
+                        config.mcpServers = {};
+                    }
+                    config.mcpServers[serverName] = serverConfig;
+                    content = file.formatJSON(config);
+                    return [4 /*yield*/, file.atomicWrite(validatedConfigPath, content, { createBackup: true })];
+                case 27:
+                    _e.sent();
+                    results.push("App config (".concat(path.getDisplayPath(configPaths.app), ")"));
+                    _e.label = 28;
+                case 28: return [2 /*return*/, {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    message: "Successfully installed MCP server: ".concat(serverName),
+                                    addedTo: results,
+                                    server: {
+                                        name: serverName,
+                                        source: source,
+                                        package: options.package,
+                                        installPath: installPath,
+                                        config: serverConfig,
+                                    },
+                                }, null, 2),
+                            },
+                        ],
+                    }];
+            }
+        });
+    });
+}
+function handleMCPSync(args) {
+    return __awaiter(this, void 0, void 0, function () {
+        var schema, _a, _b, source, _c, dryRun, sourcePath, targetPath, sourceLabel, targetLabel, sourceConfig, validatedSourcePath, content_6, _d, sourceServers, targetConfig, validatedTargetPath_1, content_7, _e, sourceServerNames, targetServerNames, toAdd, toUpdate, toRemove, summary, results, _i, toAdd_1, name_3, _f, toUpdate_1, name_4, _g, toRemove_1, name_5, validatedTargetPath, content;
+        return __generator(this, function (_h) {
+            switch (_h.label) {
+                case 0:
+                    schema = zod_1.z.object({
+                        source: zod_1.z.enum(['cli', 'app']).optional(),
+                        dryRun: zod_1.z.boolean().optional(),
+                    });
+                    _a = schema.parse(args), _b = _a.source, source = _b === void 0 ? 'app' : _b, _c = _a.dryRun, dryRun = _c === void 0 ? false : _c;
+                    sourcePath = source === 'cli' ? path.getClaudeCliConfigPath() : path.getConfigPaths().appConfig;
+                    targetPath = source === 'cli' ? path.getConfigPaths().appConfig : path.getClaudeCliConfigPath();
+                    sourceLabel = source === 'cli' ? 'CLI' : 'App';
+                    targetLabel = source === 'cli' ? 'App' : 'CLI';
+                    _h.label = 1;
+                case 1:
+                    _h.trys.push([1, 3, , 4]);
+                    validatedSourcePath = path.validatePath(sourcePath);
+                    return [4 /*yield*/, file.safeReadFile(validatedSourcePath)];
+                case 2:
+                    content_6 = _h.sent();
+                    sourceConfig = file.safeJSONParse(content_6, validatedSourcePath);
+                    return [3 /*break*/, 4];
+                case 3:
+                    _d = _h.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: "Source ".concat(sourceLabel, " config not found or empty"),
+                                },
+                            ],
+                        }];
+                case 4:
+                    sourceServers = sourceConfig.mcpServers || {};
+                    _h.label = 5;
+                case 5:
+                    _h.trys.push([5, 7, , 8]);
+                    validatedTargetPath_1 = path.validatePath(targetPath);
+                    return [4 /*yield*/, file.safeReadFile(validatedTargetPath_1)];
+                case 6:
+                    content_7 = _h.sent();
+                    targetConfig = file.safeJSONParse(content_7, validatedTargetPath_1);
+                    return [3 /*break*/, 8];
+                case 7:
+                    _e = _h.sent();
+                    targetConfig = { mcpServers: {} };
+                    return [3 /*break*/, 8];
+                case 8:
+                    if (!targetConfig.mcpServers) {
+                        targetConfig.mcpServers = {};
+                    }
+                    sourceServerNames = new Set(Object.keys(sourceServers));
+                    targetServerNames = new Set(Object.keys(targetConfig.mcpServers));
+                    toAdd = __spreadArray([], sourceServerNames, true).filter(function (name) { return !targetServerNames.has(name); });
+                    toUpdate = __spreadArray([], sourceServerNames, true).filter(function (name) {
+                        return targetServerNames.has(name) &&
+                            JSON.stringify(sourceServers[name]) !== JSON.stringify(targetConfig.mcpServers[name]);
+                    });
+                    toRemove = __spreadArray([], targetServerNames, true).filter(function (name) { return !sourceServerNames.has(name); });
+                    summary = {
+                        source: sourceLabel,
+                        target: targetLabel,
+                        toAdd: toAdd,
+                        toUpdate: toUpdate,
+                        toRemove: toRemove,
+                        totalChanges: toAdd.length + toUpdate.length + toRemove.length,
+                    };
+                    if (dryRun) {
+                        return [2 /*return*/, {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: JSON.stringify(__assign(__assign({ mode: 'dry-run' }, summary), { message: "Would sync ".concat(summary.totalChanges, " changes from ").concat(sourceLabel, " to ").concat(targetLabel) }), null, 2),
+                                    },
+                                ],
+                            }];
+                    }
+                    results = [];
+                    // Add new servers
+                    for (_i = 0, toAdd_1 = toAdd; _i < toAdd_1.length; _i++) {
+                        name_3 = toAdd_1[_i];
+                        targetConfig.mcpServers[name_3] = sourceServers[name_3];
+                        results.push("Added: ".concat(name_3));
+                    }
+                    // Update existing servers
+                    for (_f = 0, toUpdate_1 = toUpdate; _f < toUpdate_1.length; _f++) {
+                        name_4 = toUpdate_1[_f];
+                        targetConfig.mcpServers[name_4] = sourceServers[name_4];
+                        results.push("Updated: ".concat(name_4));
+                    }
+                    // Remove servers not in source
+                    for (_g = 0, toRemove_1 = toRemove; _g < toRemove_1.length; _g++) {
+                        name_5 = toRemove_1[_g];
+                        delete targetConfig.mcpServers[name_5];
+                        results.push("Removed: ".concat(name_5));
+                    }
+                    validatedTargetPath = path.validatePath(targetPath);
+                    content = file.formatJSON(targetConfig);
+                    return [4 /*yield*/, file.atomicWrite(validatedTargetPath, content, { createBackup: true })];
+                case 9:
+                    _h.sent();
+                    return [2 /*return*/, {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(__assign(__assign({ mode: 'sync' }, summary), { changes: results, message: "Synced ".concat(summary.totalChanges, " changes from ").concat(sourceLabel, " to ").concat(targetLabel) }), null, 2),
+                                },
+                            ],
+                        }];
+            }
+        });
+    });
+}
+// ============================================================================
+// Server Startup
+// ============================================================================
+function main() {
+    return __awaiter(this, void 0, void 0, function () {
+        var transport;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    transport = new stdio_js_1.StdioServerTransport();
+                    return [4 /*yield*/, server.connect(transport)];
+                case 1:
+                    _a.sent();
+                    console.error('Claude Code Config MCP Server running');
+                    console.error('Version: 1.0.0');
+                    console.error('Runtime: Bun');
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+main().catch(function (error) {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});