ai-cli-mcp 2.11.0 → 2.13.0

package/dist/server.js

@@ -1,582 +1,8 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
-import { spawn } from 'node:child_process';
-import { parseCodexOutput, parseClaudeOutput, parseGeminiOutput } from './parsers.js';
-import { buildCliCommand } from './cli-builder.js';
-import { debugLog, findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
-// Re-export for backward compatibility
-export { debugLog, findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
-// Server version - update this when releasing new versions
-const SERVER_VERSION = "2.2.0";
-// Track if this is the first tool use for version printing
-let isFirstToolUse = true;
-// Capture server startup time when the module loads
-const serverStartupTime = new Date().toISOString();
-// Global process manager
-const processManager = new Map();
-// Ensure spawnAsync is defined correctly *before* the class
-export async function spawnAsync(command, args, options) {
-    return new Promise((resolve, reject) => {
-        debugLog(`[Spawn] Running command: ${command} ${args.join(' ')}`);
-        const process = spawn(command, args, {
-            shell: false, // Reverted to false
-            timeout: options?.timeout,
-            cwd: options?.cwd,
-            stdio: ['ignore', 'pipe', 'pipe']
-        });
-        let stdout = '';
-        let stderr = '';
-        process.stdout.on('data', (data) => { stdout += data.toString(); });
-        process.stderr.on('data', (data) => {
-            stderr += data.toString();
-            debugLog(`[Spawn Stderr Chunk] ${data.toString()}`);
-        });
-        process.on('error', (error) => {
-            debugLog(`[Spawn Error Event] Full error object:`, error);
-            let errorMessage = `Spawn error: ${error.message}`;
-            if (error.path) {
-                errorMessage += ` | Path: ${error.path}`;
-            }
-            if (error.syscall) {
-                errorMessage += ` | Syscall: ${error.syscall}`;
-            }
-            errorMessage += `\nStderr: ${stderr.trim()}`;
-            reject(new Error(errorMessage));
-        });
-        process.on('close', (code) => {
-            debugLog(`[Spawn Close] Exit code: ${code}`);
-            debugLog(`[Spawn Stderr Full] ${stderr.trim()}`);
-            debugLog(`[Spawn Stdout Full] ${stdout.trim()}`);
-            if (code === 0) {
-                resolve({ stdout, stderr });
-            }
-            else {
-                reject(new Error(`Command failed with exit code ${code}\nStderr: ${stderr.trim()}\nStdout: ${stdout.trim()}`));
-            }
-        });
-    });
-}
-/**
- * MCP Server for Claude Code
- * Provides a simple MCP tool to run Claude CLI in one-shot mode
- */
-export class ClaudeCodeServer {
-    server;
-    claudeCliPath;
-    codexCliPath;
-    geminiCliPath;
-    sigintHandler;
-    packageVersion;
-    constructor() {
-        // Use the simplified findClaudeCli function
-        this.claudeCliPath = findClaudeCli(); // Removed debugMode argument
-        this.codexCliPath = findCodexCli();
-        this.geminiCliPath = findGeminiCli();
-        console.error(`[Setup] Using Claude CLI command/path: ${this.claudeCliPath}`);
-        console.error(`[Setup] Using Codex CLI command/path: ${this.codexCliPath}`);
-        console.error(`[Setup] Using Gemini CLI command/path: ${this.geminiCliPath}`);
-        this.packageVersion = SERVER_VERSION;
-        this.server = new Server({
-            name: 'ai_cli_mcp',
-            version: SERVER_VERSION,
-        }, {
-            capabilities: {
-                tools: {},
-            },
-        });
-        this.setupToolHandlers();
-        this.server.onerror = (error) => console.error('[Error]', error);
-        this.sigintHandler = async () => {
-            await this.server.close();
-            process.exit(0);
-        };
-        process.on('SIGINT', this.sigintHandler);
-    }
-    /**
-     * Set up the MCP tool handlers
-     */
-    setupToolHandlers() {
-        // Define available tools
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'run',
-                    description: `AI Agent Runner: Starts a Claude, Codex, or Gemini CLI process in the background and returns a PID immediately. Use list_processes and get_result to monitor progress.
-
-• File ops: Create, read, (fuzzy) edit, move, copy, delete, list files, analyze/ocr images, file content analysis
-• Code: Generate / analyse / refactor / fix
-• Git: Stage ▸ commit ▸ push ▸ tag (any workflow)
-• Terminal: Run any CLI cmd or open URLs
-• Web search + summarise content on-the-fly
-• Multi-step workflows & GitHub integration
-
-**IMPORTANT**: This tool now returns immediately with a PID. Use other tools to check status and get results.
-
-**Supported models**:
-"claude-ultra", "codex-ultra", "gemini-ultra", "sonnet", "sonnet[1m]", "opus", "opusplan", "haiku", "gpt-5.4", "gpt-5.3-codex", "gpt-5.2-codex", "gpt-5.1-codex-mini", "gpt-5.1-codex-max", "gpt-5.2", "gpt-5.1", "gpt-5.1-codex", "gpt-5-codex", "gpt-5-codex-mini", "gpt-5", "gemini-2.5-pro", "gemini-2.5-flash", "gemini-3.1-pro-preview", "gemini-3-pro-preview", "gemini-3-flash-preview"
-
-**Prompt input**: You must provide EITHER prompt (string) OR prompt_file (file path), but not both.
-
-**Prompt tips**
-1. Be concise, explicit & step-by-step for complex tasks.
-2. Check process status with list_processes
-3. Get results with get_result using the returned PID
-4. Kill long-running processes with kill_process if needed
-
-        `,
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            prompt: {
-                                type: 'string',
-                                description: 'The detailed natural language prompt for the agent to execute. Either this or prompt_file is required.',
-                            },
-                            prompt_file: {
-                                type: 'string',
-                                description: 'Path to a file containing the prompt. Either this or prompt is required. Must be an absolute path or relative to workFolder.',
-                            },
-                            workFolder: {
-                                type: 'string',
-                                description: 'The working directory for the agent execution. Must be an absolute path.',
-                            },
-                            model: {
-                                type: 'string',
-                                description: 'The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: "sonnet", "sonnet[1m]", "opus", "opusplan", "haiku", "gpt-5.4", "gpt-5.3-codex", "gpt-5.2-codex", "gpt-5.1-codex-mini", "gpt-5.1", "gemini-2.5-pro", "gemini-3.1-pro-preview", "gemini-3-pro-preview", "gemini-3-flash-preview", etc.',
-                            },
-                            reasoning_effort: {
-                                type: 'string',
-                                description: 'Reasoning control for Claude and Codex. Claude uses --effort with "low", "medium", "high". Codex uses model_reasoning_effort with "low", "medium", "high", "xhigh".',
-                            },
-                            session_id: {
-                                type: 'string',
-                                description: 'Optional session ID to resume a previous session. Supported for: haiku, sonnet, opus, gemini-2.5-pro, gemini-2.5-flash, gemini-3.1-pro-preview, gemini-3-pro-preview, gemini-3-flash-preview.',
-                            },
-                        },
-                        required: ['workFolder'],
-                    },
-                },
-                {
-                    name: 'list_processes',
-                    description: 'List all running and completed AI agent processes. Returns a simple list with PID, agent type, and status for each process.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                },
-                {
-                    name: 'get_result',
-                    description: 'Get the current output and status of an AI agent process by PID. Returns the output from the agent including session_id (if applicable), along with process metadata.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            pid: {
-                                type: 'number',
-                                description: 'The process ID returned by run tool.',
-                            },
-                            verbose: {
-                                type: 'boolean',
-                                description: 'Optional: If true, returns detailed execution information including tool usage history. Defaults to false.',
-                            }
-                        },
-                        required: ['pid'],
-                    },
-                },
-                {
-                    name: 'wait',
-                    description: 'Wait for multiple AI agent processes to complete and return their results. Blocks until all specified PIDs finish or timeout occurs.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            pids: {
-                                type: 'array',
-                                items: { type: 'number' },
-                                description: 'List of process IDs to wait for (returned by the run tool).',
-                            },
-                            timeout: {
-                                type: 'number',
-                                description: 'Optional: Maximum time to wait in seconds. Defaults to 180 (3 minutes).',
-                            },
-                        },
-                        required: ['pids'],
-                    },
-                },
-                {
-                    name: 'kill_process',
-                    description: 'Terminate a running AI agent process by PID.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            pid: {
-                                type: 'number',
-                                description: 'The process ID to terminate.',
-                            },
-                        },
-                        required: ['pid'],
-                    },
-                },
-                {
-                    name: 'cleanup_processes',
-                    description: 'Remove all completed and failed processes from the process list to free up memory.',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {},
-                    },
-                }
-            ],
-        }));
-        // Handle tool calls
-        const executionTimeoutMs = 1800000; // 30 minutes timeout
-        this.server.setRequestHandler(CallToolRequestSchema, async (args, call) => {
-            debugLog('[Debug] Handling CallToolRequest:', args);
-            const toolName = args.params.name;
-            const toolArguments = args.params.arguments || {};
-            switch (toolName) {
-                case 'run':
-                    return this.handleRun(toolArguments);
-                case 'list_processes':
-                    return this.handleListProcesses();
-                case 'get_result':
-                    return this.handleGetResult(toolArguments);
-                case 'wait':
-                    return this.handleWait(toolArguments);
-                case 'kill_process':
-                    return this.handleKillProcess(toolArguments);
-                case 'cleanup_processes':
-                    return this.handleCleanupProcesses();
-                default:
-                    throw new McpError(ErrorCode.MethodNotFound, `Tool ${toolName} not found`);
-            }
-        });
-    }
-    /**
-     * Handle run tool - starts Claude or Codex process and returns PID immediately
-     */
-    async handleRun(toolArguments) {
-        // Print version on first use
-        if (isFirstToolUse) {
-            console.error(`ai_cli_mcp v${SERVER_VERSION} started at ${serverStartupTime}`);
-            isFirstToolUse = false;
-        }
-        // Build CLI command (validation + args assembly)
-        let cmd;
-        try {
-            cmd = buildCliCommand({
-                prompt: toolArguments.prompt,
-                prompt_file: toolArguments.prompt_file,
-                workFolder: toolArguments.workFolder,
-                model: toolArguments.model,
-                session_id: toolArguments.session_id,
-                reasoning_effort: toolArguments.reasoning_effort,
-                cliPaths: {
-                    claude: this.claudeCliPath,
-                    codex: this.codexCliPath,
-                    gemini: this.geminiCliPath,
-                },
-            });
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InvalidParams, error.message);
-        }
-        const { cliPath, args: processArgs, cwd: effectiveCwd, agent, prompt } = cmd;
-        // Spawn process without waiting
-        const childProcess = spawn(cliPath, processArgs, {
-            cwd: effectiveCwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            detached: false
-        });
-        const pid = childProcess.pid;
-        if (!pid) {
-            throw new McpError(ErrorCode.InternalError, `Failed to start ${agent} CLI process`);
-        }
-        // Create process tracking entry
-        const processEntry = {
-            pid,
-            process: childProcess,
-            prompt,
-            workFolder: effectiveCwd,
-            model: toolArguments.model,
-            toolType: agent,
-            startTime: new Date().toISOString(),
-            stdout: '',
-            stderr: '',
-            status: 'running'
-        };
-        // Track the process
-        processManager.set(pid, processEntry);
-        // Set up output collection
-        childProcess.stdout.on('data', (data) => {
-            const entry = processManager.get(pid);
-            if (entry) {
-                entry.stdout += data.toString();
-            }
-        });
-        childProcess.stderr.on('data', (data) => {
-            const entry = processManager.get(pid);
-            if (entry) {
-                entry.stderr += data.toString();
-            }
-        });
-        childProcess.on('close', (code) => {
-            const entry = processManager.get(pid);
-            if (entry) {
-                entry.status = code === 0 ? 'completed' : 'failed';
-                entry.exitCode = code !== null ? code : undefined;
-            }
-        });
-        childProcess.on('error', (error) => {
-            const entry = processManager.get(pid);
-            if (entry) {
-                entry.status = 'failed';
-                entry.stderr += `\nProcess error: ${error.message}`;
-            }
-        });
-        // Return PID immediately
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        pid,
-                        status: 'started',
-                        agent,
-                        message: `${agent} process started successfully`
-                    }, null, 2)
-                }]
-        };
-    }
-    /**
-     * Handle list_processes tool
-     */
-    async handleListProcesses() {
-        const processes = [];
-        for (const [pid, process] of processManager.entries()) {
-            const processInfo = {
-                pid,
-                agent: process.toolType,
-                status: process.status
-            };
-            processes.push(processInfo);
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(processes, null, 2)
-                }]
-        };
-    }
-    /**
-     * Helper to get process result object
-     */
-    getProcessResultHelper(pid, verbose = false) {
-        const process = processManager.get(pid);
-        if (!process) {
-            throw new McpError(ErrorCode.InvalidParams, `Process with PID ${pid} not found`);
-        }
-        // Parse output based on agent type
-        let agentOutput = null;
-        if (process.toolType === 'codex') {
-            // Codex may output structured logs to stderr
-            const combinedOutput = (process.stdout || '') + '\n' + (process.stderr || '');
-            agentOutput = parseCodexOutput(combinedOutput);
-        }
-        else if (process.stdout) {
-            if (process.toolType === 'claude') {
-                agentOutput = parseClaudeOutput(process.stdout);
-            }
-            else if (process.toolType === 'gemini') {
-                agentOutput = parseGeminiOutput(process.stdout);
-            }
-        }
-        // Construct response with agent's output and process metadata
-        const response = {
-            pid,
-            agent: process.toolType,
-            status: process.status,
-            exitCode: process.exitCode,
-            startTime: process.startTime,
-            workFolder: process.workFolder,
-            prompt: process.prompt,
-            model: process.model
-        };
-        // If we have valid output from agent, include it
-        if (agentOutput) {
-            // Filter out tools if not verbose
-            if (!verbose && agentOutput.tools) {
-                const { tools, ...rest } = agentOutput;
-                response.agentOutput = rest;
-            }
-            else {
-                response.agentOutput = agentOutput;
-            }
-            // Extract session_id if available
-            if (agentOutput.session_id) {
-                response.session_id = agentOutput.session_id;
-            }
-        }
-        else {
-            // Fallback to raw output
-            response.stdout = process.stdout;
-            response.stderr = process.stderr;
-        }
-        return response;
-    }
-    /**
-     * Handle get_result tool
-     */
-    async handleGetResult(toolArguments) {
-        if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
-            throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');
-        }
-        const pid = toolArguments.pid;
-        const verbose = !!toolArguments.verbose;
-        const response = this.getProcessResultHelper(pid, verbose);
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(response, null, 2)
-                }]
-        };
-    }
-    /**
-     * Handle wait tool
-     */
-    async handleWait(toolArguments) {
-        if (!toolArguments.pids || !Array.isArray(toolArguments.pids) || toolArguments.pids.length === 0) {
-            throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pids (must be a non-empty array of numbers)');
-        }
-        const pids = toolArguments.pids;
-        // Default timeout: 3 minutes (180 seconds)
-        const timeoutSeconds = typeof toolArguments.timeout === 'number' ? toolArguments.timeout : 180;
-        const timeoutMs = timeoutSeconds * 1000;
-        // Validate all PIDs exist first
-        for (const pid of pids) {
-            if (!processManager.has(pid)) {
-                throw new McpError(ErrorCode.InvalidParams, `Process with PID ${pid} not found`);
-            }
-        }
-        // Create promises for each process
-        const waitPromises = pids.map(pid => {
-            const processEntry = processManager.get(pid);
-            if (processEntry.status !== 'running') {
-                return Promise.resolve();
-            }
-            return new Promise((resolve) => {
-                processEntry.process.once('close', () => {
-                    resolve();
-                });
-            });
-        });
-        // Create a timeout promise
-        const timeoutPromise = new Promise((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`Timed out after ${timeoutSeconds} seconds waiting for processes`));
-            }, timeoutMs);
-        });
-        try {
-            // Wait for all processes to finish or timeout
-            await Promise.race([Promise.all(waitPromises), timeoutPromise]);
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InternalError, error.message);
-        }
-        // Collect results (verbose=false for wait)
-        const results = pids.map(pid => this.getProcessResultHelper(pid, false));
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(results, null, 2)
-                }]
-        };
-    }
-    /**
-     * Handle kill_process tool
-     */
-    async handleKillProcess(toolArguments) {
-        if (!toolArguments.pid || typeof toolArguments.pid !== 'number') {
-            throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: pid');
-        }
-        const pid = toolArguments.pid;
-        const processEntry = processManager.get(pid);
-        if (!processEntry) {
-            throw new McpError(ErrorCode.InvalidParams, `Process with PID ${pid} not found`);
-        }
-        if (processEntry.status !== 'running') {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            pid,
-                            status: processEntry.status,
-                            message: 'Process already terminated'
-                        }, null, 2)
-                    }]
-            };
-        }
-        try {
-            processEntry.process.kill('SIGTERM');
-            processEntry.status = 'failed';
-            processEntry.stderr += '\nProcess terminated by user';
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            pid,
-                            status: 'terminated',
-                            message: 'Process terminated successfully'
-                        }, null, 2)
-                    }]
-            };
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InternalError, `Failed to terminate process: ${error.message}`);
-        }
-    }
-    /**
-     * Handle cleanup_processes tool
-     */
-    async handleCleanupProcesses() {
-        const removedPids = [];
-        // Iterate through all processes and collect PIDs to remove
-        for (const [pid, process] of processManager.entries()) {
-            if (process.status === 'completed' || process.status === 'failed') {
-                removedPids.push(pid);
-                processManager.delete(pid);
-            }
-        }
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({
-                        removed: removedPids.length,
-                        removedPids,
-                        message: `Cleaned up ${removedPids.length} finished process(es)`
-                    }, null, 2)
-                }]
-        };
-    }
-    /**
-     * Start the MCP server
-     */
-    async run() {
-        // Revert to original server start logic if listen caused errors
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
-        console.error('AI CLI MCP server running on stdio');
-    }
-    /**
-     * Clean up resources (for testing)
-     */
-    async cleanup() {
-        if (this.sigintHandler) {
-            process.removeListener('SIGINT', this.sigintHandler);
-        }
-        await this.server.close();
-    }
-}
-// Create and run the server (skip during tests)
+export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';
+import { runMcpServer } from './app/mcp.js';
 if (!process.env.VITEST) {
-    const server = new ClaudeCodeServer();
-    server.run().catch(console.error);
+    runMcpServer().catch(console.error);
 }