@dotcontext/cli 0.8.1 → 0.9.0

package/dist/services/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/cli/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,iBAAiB,EACjB,KAAK,6BAA6B,EAClC,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,eAAe,GACrB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,aAAa,EACb,OAAO,IAAI,oBAAoB,EAC/B,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC"}

package/dist/services/cli/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * CLI service exports.
+ *
+ * These services belong to the operator-facing CLI boundary.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultStateDetector = exports.StateDetector = exports.MCPInstallService = void 0;
+var mcpInstallService_1 = require("./mcpInstallService");
+Object.defineProperty(exports, "MCPInstallService", { enumerable: true, get: function () { return mcpInstallService_1.MCPInstallService; } });
+var stateDetector_1 = require("./stateDetector");
+Object.defineProperty(exports, "StateDetector", { enumerable: true, get: function () { return stateDetector_1.StateDetector; } });
+Object.defineProperty(exports, "DefaultStateDetector", { enumerable: true, get: function () { return __importDefault(stateDetector_1).default; } });
+//# sourceMappingURL=index.js.map

package/dist/services/cli/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/services/cli/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;;;;AAEH,yDAM6B;AAL3B,sHAAA,iBAAiB,OAAA;AAOnB,iDAMyB;AALvB,8GAAA,aAAa,OAAA;AACb,sIAAA,OAAO,OAAwB"}

package/dist/services/cli/mcpInstallService.d.ts

@@ -0,0 +1,57 @@
+/**
+ * MCP Install Service
+ *
+ * CLI-facing installation service for configuring the dotcontext MCP server
+ * in various AI tools. This belongs to the operator surface, not the
+ * reusable harness runtime.
+ */
+import { BaseDependencies, OperationResult } from '../shared/types';
+import { ToolDefinition } from '../shared/toolRegistry';
+export type MCPInstallServiceDependencies = BaseDependencies;
+export interface MCPInstallOptions {
+    /** Specific tool to install for (e.g., 'claude', 'cursor') */
+    tool?: string;
+    /** Install globally (home directory) vs locally (project directory) */
+    global?: boolean;
+    /** Preview changes without writing */
+    dryRun?: boolean;
+    /** Verbose output */
+    verbose?: boolean;
+    /** Repository path for local installation */
+    repoPath?: string;
+}
+export interface MCPInstallResult extends OperationResult {
+    installations: MCPInstallation[];
+}
+export interface MCPInstallation {
+    tool: string;
+    toolDisplayName: string;
+    configPath: string;
+    action: 'created' | 'updated' | 'skipped';
+    dryRun: boolean;
+}
+export declare class MCPInstallService {
+    private deps;
+    constructor(deps: MCPInstallServiceDependencies);
+    /**
+     * Get list of tools that support MCP installation
+     */
+    getSupportedTools(): ToolDefinition[];
+    /**
+     * Get list of supported tool IDs
+     */
+    getSupportedToolIds(): string[];
+    /**
+     * Detect which supported tools are installed on the system
+     */
+    detectInstalledTools(): Promise<string[]>;
+    /**
+     * Install MCP configuration for specified tools
+     */
+    run(options?: MCPInstallOptions): Promise<MCPInstallResult>;
+    /**
+     * Install MCP configuration for a single tool
+     */
+    private installForTool;
+}
+//# sourceMappingURL=mcpInstallService.d.ts.map

package/dist/services/cli/mcpInstallService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpInstallService.d.ts","sourceRoot":"","sources":["../../../src/services/cli/mcpInstallService.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,EACL,gBAAgB,EAChB,eAAe,EAGhB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAA8B,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAMpF,MAAM,MAAM,6BAA6B,GAAG,gBAAgB,CAAC;AAE7D,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sCAAsC;IACtC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,qBAAqB;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAC1C,MAAM,EAAE,OAAO,CAAC;CACjB;AA+aD,qBAAa,iBAAiB;IAChB,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,6BAA6B;IAEvD;;OAEG;IACH,iBAAiB,IAAI,cAAc,EAAE;IAIrC;;OAEG;IACH,mBAAmB,IAAI,MAAM,EAAE;IAI/B;;OAEG;IACG,oBAAoB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAkB/C;;OAEG;IACG,GAAG,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAgErE;;OAEG;YACW,cAAc;CA8G7B"}

package/dist/services/cli/mcpInstallService.js

@@ -0,0 +1,607 @@
+"use strict";
+/**
+ * MCP Install Service
+ *
+ * CLI-facing installation service for configuring the dotcontext MCP server
+ * in various AI tools. This belongs to the operator surface, not the
+ * reusable harness runtime.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCPInstallService = void 0;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs-extra"));
+const types_1 = require("../shared/types");
+const toolRegistry_1 = require("../shared/toolRegistry");
+/**
+ * Standard MCP server configuration for dotcontext
+ */
+const AI_CONTEXT_MCP_SERVER = {
+    command: 'npx',
+    args: ['-y', '@dotcontext/mcp@latest'],
+    env: {},
+};
+const parseJsonConfig = (content) => JSON.parse(content);
+const serializeJsonConfig = (config) => JSON.stringify(config, null, 2);
+function buildCodexTomlConfig(existingConfig, server) {
+    const lines = [
+        '[mcp_servers.dotcontext]',
+        `command = ${JSON.stringify(server.command)}`,
+        `args = [${server.args.map(arg => JSON.stringify(arg)).join(', ')}]`,
+    ];
+    if (server.env && Object.keys(server.env).length > 0) {
+        lines.push('[mcp_servers.dotcontext.env]');
+        for (const [key, value] of Object.entries(server.env)) {
+            lines.push(`${key} = ${JSON.stringify(value)}`);
+        }
+    }
+    const trimmed = existingConfig.trimEnd();
+    const block = lines.join('\n');
+    return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
+}
+/**
+ * MCP configuration templates for each supported tool
+ */
+const MCP_CONFIG_TEMPLATES = [
+    // Claude Code
+    {
+        toolId: 'claude',
+        globalConfigPath: '.claude.json',
+        localConfigPath: '.mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Cursor AI
+    {
+        toolId: 'cursor',
+        globalConfigPath: '.cursor/mcp.json',
+        localConfigPath: '.cursor/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': {
+                        type: 'stdio',
+                        ...server,
+                    },
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Windsurf (Codeium)
+    {
+        toolId: 'windsurf',
+        globalConfigPath: '.codeium/windsurf/mcp_config.json',
+        localConfigPath: '.codeium/windsurf/mcp_config.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Continue.dev — standalone per-server file
+    {
+        toolId: 'continue',
+        globalConfigPath: '.continue/mcpServers/dotcontext.json',
+        localConfigPath: '.continue/mcpServers/dotcontext.json',
+        generateConfig: (_existing, server) => {
+            return {
+                command: server.command,
+                args: server.args,
+                env: server.env || {},
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            return !!c?.command;
+        },
+    },
+    // Claude Desktop - Cross-platform paths
+    {
+        toolId: 'claude-desktop',
+        globalConfigPath: process.platform === 'darwin'
+            ? path.join('Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+            : path.join('AppData', 'Roaming', 'Claude', 'claude_desktop_config.json'),
+        localConfigPath: '.claude-desktop/mcp_servers.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // VS Code (GitHub Copilot)
+    {
+        toolId: 'vscode',
+        globalConfigPath: '.vscode/mcp.json',
+        localConfigPath: '.vscode/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                servers: {
+                    ...(config.servers || {}),
+                    'dotcontext': {
+                        type: 'stdio',
+                        ...server,
+                    },
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.servers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Roo Code
+    {
+        toolId: 'roo',
+        globalConfigPath: '.roo/mcp_settings.json',
+        localConfigPath: '.roo/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Amazon Q Developer CLI
+    {
+        toolId: 'amazonq',
+        globalConfigPath: '.aws/amazonq/mcp.json',
+        localConfigPath: '.amazonq/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Gemini CLI
+    {
+        toolId: 'gemini-cli',
+        globalConfigPath: '.gemini/settings.json',
+        localConfigPath: '.gemini/settings.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Codex CLI - TOML config
+    {
+        toolId: 'codex',
+        globalConfigPath: '.codex/config.toml',
+        localConfigPath: '.codex/config.toml',
+        generateConfig: (existing, server) => buildCodexTomlConfig(typeof existing === 'string' ? existing : '', server),
+        isConfigured: (config) => (typeof config === 'string' && /^\s*\[mcp_servers\.dotcontext\]\s*$/m.test(config)),
+        parseConfig: (content) => content,
+        serializeConfig: (config) => (typeof config === 'string' ? config : String(config ?? '')),
+    },
+    // Kiro
+    {
+        toolId: 'kiro',
+        globalConfigPath: '.kiro/settings/mcp.json',
+        localConfigPath: '.kiro/settings/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Zed Editor - Uses context_servers instead of mcpServers
+    {
+        toolId: 'zed',
+        globalConfigPath: '.config/zed/settings.json',
+        localConfigPath: '.zed/settings.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                context_servers: {
+                    ...(config.context_servers || {}),
+                    'dotcontext': {
+                        command: server.command,
+                        args: server.args,
+                        env: server.env || {},
+                    },
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.context_servers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // JetBrains IDEs - Uses servers array with name field
+    {
+        toolId: 'jetbrains',
+        globalConfigPath: '.config/JetBrains/mcp.json',
+        localConfigPath: '.jb-mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            const existingServers = config.servers || [];
+            const filtered = existingServers.filter(s => s.name !== 'dotcontext');
+            return {
+                servers: [
+                    ...filtered,
+                    {
+                        name: 'dotcontext',
+                        command: server.command,
+                        args: server.args,
+                        env: server.env || {},
+                    },
+                ],
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.servers;
+            return Array.isArray(servers) && servers.some(s => s.name === 'dotcontext');
+        },
+    },
+    // Trae AI (ByteDance)
+    {
+        toolId: 'trae',
+        globalConfigPath: '.trae/mcp.json',
+        localConfigPath: '.trae/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+    // Kilo Code
+    {
+        toolId: 'kilo',
+        globalConfigPath: '.kilo/mcp.json',
+        localConfigPath: '.kilo/mcp.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcp: {
+                    ...(config.mcp || {}),
+                    'dotcontext': {
+                        type: 'local',
+                        command: [server.command, ...server.args],
+                        enabled: true,
+                    },
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const mcp = c?.mcp;
+            return !!mcp?.['dotcontext'];
+        },
+    },
+    // GitHub Copilot CLI
+    {
+        toolId: 'copilot-cli',
+        globalConfigPath: '.copilot/mcp-config.json',
+        localConfigPath: '.copilot/mcp-config.json',
+        generateConfig: (existing, server) => {
+            const config = existing || {};
+            return {
+                ...config,
+                mcpServers: {
+                    ...(config.mcpServers || {}),
+                    'dotcontext': server,
+                },
+            };
+        },
+        isConfigured: (config) => {
+            const c = config;
+            const servers = c?.mcpServers;
+            return !!servers?.['dotcontext'];
+        },
+    },
+];
+// ============================================================================
+// Service Implementation
+// ============================================================================
+class MCPInstallService {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * Get list of tools that support MCP installation
+     */
+    getSupportedTools() {
+        return MCP_CONFIG_TEMPLATES.map(t => (0, toolRegistry_1.getToolById)(t.toolId)).filter(Boolean);
+    }
+    /**
+     * Get list of supported tool IDs
+     */
+    getSupportedToolIds() {
+        return MCP_CONFIG_TEMPLATES.map(t => t.toolId);
+    }
+    /**
+     * Detect which supported tools are installed on the system
+     */
+    async detectInstalledTools() {
+        const installed = [];
+        const homeDir = os.homedir();
+        for (const template of MCP_CONFIG_TEMPLATES) {
+            const tool = (0, toolRegistry_1.getToolById)(template.toolId);
+            if (!tool)
+                continue;
+            // Check if tool directory exists in home
+            const toolDir = path.join(homeDir, tool.directoryPrefix);
+            if (await fs.pathExists(toolDir)) {
+                installed.push(template.toolId);
+            }
+        }
+        return installed;
+    }
+    /**
+     * Install MCP configuration for specified tools
+     */
+    async run(options = {}) {
+        const result = {
+            ...(0, types_1.createEmptyResult)(),
+            installations: [],
+        };
+        const { tool, global: isGlobal = true, dryRun = false, verbose = false, repoPath } = options;
+        // Determine base path
+        const basePath = isGlobal ? os.homedir() : (repoPath ? path.resolve(repoPath) : process.cwd());
+        // Determine which tools to install
+        let toolsToInstall;
+        if (tool) {
+            if (tool === 'all') {
+                toolsToInstall = await this.detectInstalledTools();
+                if (toolsToInstall.length === 0) {
+                    toolsToInstall = this.getSupportedToolIds();
+                }
+            }
+            else {
+                const template = MCP_CONFIG_TEMPLATES.find(t => t.toolId === tool);
+                if (!template) {
+                    this.deps.ui.displayError(this.deps.t('errors.mcp.unsupportedTool', { tool, supported: this.getSupportedToolIds().join(', ') }));
+                    return result;
+                }
+                toolsToInstall = [tool];
+            }
+        }
+        else {
+            // No tool specified - install for all detected
+            toolsToInstall = await this.detectInstalledTools();
+            if (toolsToInstall.length === 0) {
+                toolsToInstall = this.getSupportedToolIds();
+            }
+        }
+        if (toolsToInstall.length === 0) {
+            this.deps.ui.displayWarning(this.deps.t('warnings.mcp.noToolsDetected'));
+            return result;
+        }
+        // Install for each tool
+        for (const toolId of toolsToInstall) {
+            const installation = await this.installForTool(toolId, basePath, isGlobal, dryRun, verbose);
+            result.installations.push(installation);
+            if (installation.action === 'created' || installation.action === 'updated') {
+                result.filesCreated++;
+            }
+            else if (installation.action === 'skipped') {
+                result.filesSkipped++;
+            }
+        }
+        // Display summary
+        if (!dryRun && result.filesCreated > 0) {
+            this.deps.ui.displaySuccess(this.deps.t('success.mcp.installed', { count: result.filesCreated }));
+        }
+        return result;
+    }
+    /**
+     * Install MCP configuration for a single tool
+     */
+    async installForTool(toolId, basePath, isGlobal, dryRun, verbose) {
+        const template = MCP_CONFIG_TEMPLATES.find(t => t.toolId === toolId);
+        const toolDef = (0, toolRegistry_1.getToolById)(toolId);
+        if (!template || !toolDef) {
+            return {
+                tool: toolId,
+                toolDisplayName: toolId,
+                configPath: '',
+                action: 'skipped',
+                dryRun,
+            };
+        }
+        const configPath = isGlobal ? template.globalConfigPath : template.localConfigPath;
+        const fullConfigPath = path.join(basePath, configPath);
+        const parseConfig = template.parseConfig ?? parseJsonConfig;
+        const serializeConfig = template.serializeConfig ?? serializeJsonConfig;
+        // Read existing config if it exists
+        let existingConfig = {};
+        const configExists = await fs.pathExists(fullConfigPath);
+        if (configExists) {
+            try {
+                const content = await fs.readFile(fullConfigPath, 'utf-8');
+                existingConfig = parseConfig(content);
+            }
+            catch {
+                // File exists but could not be parsed, we'll overwrite while preserving custom formats when possible.
+                existingConfig = {};
+            }
+        }
+        // Check if already configured
+        if (template.isConfigured(existingConfig)) {
+            if (verbose) {
+                this.deps.ui.displayInfo(toolDef.displayName, this.deps.t('info.mcp.alreadyConfigured', { tool: toolDef.displayName }));
+            }
+            return {
+                tool: toolId,
+                toolDisplayName: toolDef.displayName,
+                configPath: fullConfigPath,
+                action: 'skipped',
+                dryRun,
+            };
+        }
+        // Generate new config
+        const newConfig = template.generateConfig(existingConfig, AI_CONTEXT_MCP_SERVER);
+        if (dryRun) {
+            const serializedConfig = serializeConfig(newConfig);
+            this.deps.ui.displayInfo(toolDef.displayName, this.deps.t('info.mcp.wouldInstall', { tool: toolDef.displayName, path: fullConfigPath }));
+            if (verbose) {
+                console.log(serializedConfig);
+            }
+            return {
+                tool: toolId,
+                toolDisplayName: toolDef.displayName,
+                configPath: fullConfigPath,
+                action: 'created',
+                dryRun: true,
+            };
+        }
+        // Write config
+        try {
+            await fs.ensureDir(path.dirname(fullConfigPath));
+            await fs.writeFile(fullConfigPath, serializeConfig(newConfig), 'utf-8');
+            if (verbose) {
+                this.deps.ui.displayInfo(toolDef.displayName, this.deps.t('info.mcp.installed', { tool: toolDef.displayName, path: fullConfigPath }));
+            }
+            const action = configExists ? 'updated' : 'created';
+            return {
+                tool: toolId,
+                toolDisplayName: toolDef.displayName,
+                configPath: fullConfigPath,
+                action,
+                dryRun: false,
+            };
+        }
+        catch (error) {
+            this.deps.ui.displayError(this.deps.t('errors.mcp.installFailed', { tool: toolDef.displayName }), error);
+            return {
+                tool: toolId,
+                toolDisplayName: toolDef.displayName,
+                configPath: fullConfigPath,
+                action: 'skipped',
+                dryRun: false,
+            };
+        }
+    }
+}
+exports.MCPInstallService = MCPInstallService;
+//# sourceMappingURL=mcpInstallService.js.map