ai-cli-mcp 2.11.0 → 2.13.0

package/dist/parsers.js

@@ -163,3 +163,58 @@ export function parseGeminiOutput(stdout) {
         return null;
     }
 }
+/**
+ * Parse Forge output framed by Initialize/Continue/Finished markers.
+ */
+export function parseForgeOutput(stdout) {
+    if (!stdout)
+        return null;
+    const lines = stdout.split('\n');
+    const markerPattern = /^● \[[^\]]+\] (Initialize|Continue|Finished) (\S+)\s*$/;
+    let collecting = false;
+    let currentConversationId = null;
+    let currentBody = [];
+    let lastConversationId = null;
+    let lastMessage = null;
+    for (const line of lines) {
+        const match = line.match(markerPattern);
+        if (match) {
+            const [, action, conversationId] = match;
+            lastConversationId = conversationId;
+            if (action === 'Initialize' || action === 'Continue') {
+                collecting = true;
+                currentConversationId = conversationId;
+                currentBody = [];
+            }
+            else if (collecting && currentConversationId === conversationId) {
+                const message = currentBody.join('\n').trim();
+                if (message) {
+                    lastMessage = message;
+                }
+                collecting = false;
+                currentConversationId = null;
+                currentBody = [];
+            }
+            continue;
+        }
+        if (collecting) {
+            currentBody.push(line);
+        }
+    }
+    if (collecting) {
+        const message = currentBody.join('\n').trim();
+        if (message) {
+            lastMessage = message;
+        }
+        if (currentConversationId) {
+            lastConversationId = currentConversationId;
+        }
+    }
+    if (!lastMessage && !lastConversationId) {
+        return null;
+    }
+    return {
+        message: lastMessage,
+        session_id: lastConversationId,
+    };
+}

package/dist/process-service.js

@@ -0,0 +1,201 @@
+import { spawn } from 'node:child_process';
+import { buildCliCommand } from './cli-builder.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+export class ProcessService {
+    processManager = new Map();
+    cliPaths;
+    constructor(options) {
+        this.cliPaths = options.cliPaths;
+    }
+    startProcess(options) {
+        const cmd = buildCliCommand({
+            ...options,
+            cliPaths: this.cliPaths,
+        });
+        const { cliPath, args: processArgs, cwd: effectiveCwd, agent, prompt } = cmd;
+        const childProcess = spawn(cliPath, processArgs, {
+            cwd: effectiveCwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            detached: false,
+        });
+        const pid = childProcess.pid;
+        if (!pid) {
+            throw new Error(`Failed to start ${agent} CLI process`);
+        }
+        const processEntry = {
+            pid,
+            process: childProcess,
+            prompt,
+            workFolder: effectiveCwd,
+            model: options.model,
+            toolType: agent,
+            startTime: new Date().toISOString(),
+            stdout: '',
+            stderr: '',
+            status: 'running',
+        };
+        this.processManager.set(pid, processEntry);
+        childProcess.stdout.on('data', (data) => {
+            const entry = this.processManager.get(pid);
+            if (entry) {
+                entry.stdout += data.toString();
+            }
+        });
+        childProcess.stderr.on('data', (data) => {
+            const entry = this.processManager.get(pid);
+            if (entry) {
+                entry.stderr += data.toString();
+            }
+        });
+        childProcess.on('close', (code) => {
+            const entry = this.processManager.get(pid);
+            if (entry) {
+                entry.status = code === 0 ? 'completed' : 'failed';
+                entry.exitCode = code !== null ? code : undefined;
+            }
+        });
+        childProcess.on('error', (error) => {
+            const entry = this.processManager.get(pid);
+            if (entry) {
+                entry.status = 'failed';
+                entry.stderr += `\nProcess error: ${error.message}`;
+            }
+        });
+        return {
+            pid,
+            status: 'started',
+            agent,
+            message: `${agent} process started successfully`,
+        };
+    }
+    listProcesses() {
+        const processes = [];
+        for (const [pid, process] of this.processManager.entries()) {
+            processes.push({
+                pid,
+                agent: process.toolType,
+                status: process.status,
+            });
+        }
+        return processes;
+    }
+    getProcessResult(pid, verbose = false) {
+        const process = this.processManager.get(pid);
+        if (!process) {
+            throw new Error(`Process with PID ${pid} not found`);
+        }
+        let agentOutput = null;
+        if (process.toolType === 'codex') {
+            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);
+            }
+            else if (process.toolType === 'forge') {
+                agentOutput = parseForgeOutput(process.stdout);
+            }
+        }
+        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 (agentOutput) {
+            if (!verbose && agentOutput.tools) {
+                const { tools, ...rest } = agentOutput;
+                response.agentOutput = rest;
+            }
+            else {
+                response.agentOutput = agentOutput;
+            }
+            if (agentOutput.session_id) {
+                response.session_id = agentOutput.session_id;
+            }
+        }
+        else {
+            response.stdout = process.stdout;
+            response.stderr = process.stderr;
+        }
+        return response;
+    }
+    async waitForProcesses(pids, timeoutSeconds = 180) {
+        for (const pid of pids) {
+            if (!this.processManager.has(pid)) {
+                throw new Error(`Process with PID ${pid} not found`);
+            }
+        }
+        const waitPromises = pids.map((pid) => {
+            const processEntry = this.processManager.get(pid);
+            if (processEntry.status !== 'running') {
+                return Promise.resolve();
+            }
+            return new Promise((resolve) => {
+                processEntry.process.once('close', () => {
+                    resolve();
+                });
+            });
+        });
+        const timeoutMs = timeoutSeconds * 1000;
+        let timeoutHandle;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutHandle = setTimeout(() => {
+                reject(new Error(`Timed out after ${timeoutSeconds} seconds waiting for processes`));
+            }, timeoutMs);
+            timeoutHandle.unref?.();
+        });
+        try {
+            await Promise.race([Promise.all(waitPromises), timeoutPromise]);
+            return pids.map((pid) => this.getProcessResult(pid, false));
+        }
+        finally {
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+            }
+        }
+    }
+    killProcess(pid) {
+        const processEntry = this.processManager.get(pid);
+        if (!processEntry) {
+            throw new Error(`Process with PID ${pid} not found`);
+        }
+        if (processEntry.status !== 'running') {
+            return {
+                pid,
+                status: processEntry.status,
+                message: 'Process already terminated',
+            };
+        }
+        processEntry.process.kill('SIGTERM');
+        processEntry.status = 'failed';
+        processEntry.stderr += '\nProcess terminated by user';
+        return {
+            pid,
+            status: 'terminated',
+            message: 'Process terminated successfully',
+        };
+    }
+    cleanupProcesses() {
+        const removedPids = [];
+        for (const [pid, process] of this.processManager.entries()) {
+            if (process.status === 'completed' || process.status === 'failed') {
+                removedPids.push(pid);
+                this.processManager.delete(pid);
+            }
+        }
+        return {
+            removed: removedPids.length,
+            removedPids,
+            message: `Cleaned up ${removedPids.length} finished process(es)`,
+        };
+    }
+}