ai-cli-mcp 2.14.1 → 2.15.0

package/dist/cli-process-service.js

@@ -1,10 +1,10 @@
 import { spawn } from 'node:child_process';
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
 function resolveDefaultStateDir() {
     return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
@@ -27,6 +27,27 @@ function normalizeCwdForStorage(cwd) {
         .map((char) => (/^[A-Za-z0-9.-]$/.test(char) ? char : `_${char.charCodeAt(0).toString(16).padStart(2, '0')}`))
         .join('');
 }
+function parseAgentOutput(agent, stdout, stderr) {
+    if (agent === 'codex') {
+        return parseCodexOutput(`${stdout}\n${stderr}`);
+    }
+    if (!stdout) {
+        return null;
+    }
+    if (agent === 'claude') {
+        return parseClaudeOutput(stdout);
+    }
+    if (agent === 'gemini') {
+        return parseGeminiOutput(stdout);
+    }
+    if (agent === 'forge') {
+        return parseForgeOutput(stdout);
+    }
+    if (agent === 'opencode') {
+        return parseOpenCodeOutput(stdout);
+    }
+    return null;
+}
 export class CliProcessService {
     stateDir;
     cliPaths;
@@ -37,6 +58,7 @@ export class CliProcessService {
             codex: findCodexCli(),
             gemini: findGeminiCli(),
             forge: findForgeCli(),
+            opencode: findOpencodeCli(),
         };
         mkdirSync(this.stateDir, { recursive: true });
     }
@@ -50,6 +72,9 @@ export class CliProcessService {
             reasoning_effort: options.reasoning_effort,
             cliPaths: this.cliPaths,
         });
+        if (cmd.agent === 'opencode') {
+            return this.startDetachedOpenCodeProcess(cmd, options.model);
+        }
         const stdoutPath = this.resolveStdoutPathForPidPlaceholder();
         const stderrPath = this.resolveStderrPathForPidPlaceholder();
         let stdoutFd;
@@ -119,26 +144,12 @@ export class CliProcessService {
         const refreshed = this.refreshStatus(storedProcess);
         const stdout = this.readTextFileSafe(refreshed.stdoutPath);
         const stderr = this.readTextFileSafe(refreshed.stderrPath);
-        let agentOutput = null;
-        if (refreshed.toolType === 'codex') {
-            agentOutput = parseCodexOutput(`${stdout}\n${stderr}`);
-        }
-        else if (stdout) {
-            if (refreshed.toolType === 'claude') {
-                agentOutput = parseClaudeOutput(stdout);
-            }
-            else if (refreshed.toolType === 'gemini') {
-                agentOutput = parseGeminiOutput(stdout);
-            }
-            else if (refreshed.toolType === 'forge') {
-                agentOutput = parseForgeOutput(stdout);
-            }
-        }
+        const agentOutput = parseAgentOutput(refreshed.toolType, stdout, stderr);
         return buildProcessResult({
             pid,
             agent: refreshed.toolType,
             status: refreshed.status,
-            exitCode: undefined,
+            exitCode: refreshed.exitCode,
             startTime: refreshed.startTime,
             workFolder: refreshed.workFolder,
             prompt: refreshed.prompt,
@@ -209,6 +220,49 @@ export class CliProcessService {
             message: `Removed ${removed} processes`,
         };
     }
+    async startDetachedOpenCodeProcess(cmd, model) {
+        const cwdKey = this.resolveCwdKey(cmd.cwd);
+        const wrapperPath = this.ensureOpenCodeWrapperScript();
+        const childProcess = spawn(wrapperPath, [this.stateDir, cwdKey, cmd.cliPath, ...cmd.args], {
+            cwd: cmd.cwd,
+            detached: true,
+            stdio: 'ignore',
+        });
+        const pid = childProcess.pid;
+        childProcess.unref();
+        if (!pid) {
+            throw new Error(`Failed to start ${cmd.agent} CLI process`);
+        }
+        const processDir = this.resolveProcessDir(cmd.cwd, pid);
+        mkdirSync(processDir, { recursive: true });
+        const stdoutPath = this.resolveStdoutPath(processDir);
+        const stderrPath = this.resolveStderrPath(processDir);
+        if (!existsSync(stdoutPath)) {
+            writeFileSync(stdoutPath, '');
+        }
+        if (!existsSync(stderrPath)) {
+            writeFileSync(stderrPath, '');
+        }
+        const storedProcess = {
+            pid,
+            prompt: cmd.prompt,
+            workFolder: cmd.cwd,
+            cwdKey,
+            model,
+            toolType: cmd.agent,
+            startTime: new Date().toISOString(),
+            stdoutPath,
+            stderrPath,
+            status: 'running',
+        };
+        this.writeProcess(storedProcess);
+        return {
+            pid,
+            status: 'started',
+            agent: cmd.agent,
+            message: `${cmd.agent} process started successfully`,
+        };
+    }
     readAllProcesses() {
         const cwdsDir = this.resolveCwdsDir();
         if (!existsSync(cwdsDir)) {
@@ -246,12 +300,41 @@ export class CliProcessService {
         writeFileSync(this.resolveMetaPath(processDir), JSON.stringify(process, null, 2));
     }
     refreshStatus(process) {
-        if (process.status === 'running' && !isProcessRunning(process.pid)) {
+        if (process.status !== 'running') {
+            return process;
+        }
+        const persistedExitStatus = this.readExitStatus(process);
+        if (persistedExitStatus) {
+            process.status = persistedExitStatus.status;
+            process.exitCode = persistedExitStatus.exitCode;
+            this.writeProcess(process);
+            return process;
+        }
+        if (!isProcessRunning(process.pid)) {
             process.status = 'completed';
             this.writeProcess(process);
         }
         return process;
     }
+    readExitStatus(process) {
+        if (process.toolType !== 'opencode') {
+            return null;
+        }
+        const exitMetaPath = this.resolveExitStatusPath(this.resolveStoredProcessDir(process));
+        if (!existsSync(exitMetaPath)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(readFileSync(exitMetaPath, 'utf-8'));
+            if (parsed.status === 'completed' || parsed.status === 'failed') {
+                return parsed;
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
     readTextFileSafe(filePath) {
         if (!existsSync(filePath)) {
             return '';
@@ -282,12 +365,48 @@ export class CliProcessService {
     resolveStderrPath(processDir) {
         return join(processDir, 'stderr.log');
     }
+    resolveExitStatusPath(processDir) {
+        return join(processDir, 'exit-status.json');
+    }
+    resolveOpenCodeWrapperPath() {
+        return join(this.stateDir, 'opencode-detached-wrapper.sh');
+    }
     resolveStdoutPathForPidPlaceholder() {
         return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stdout.log`);
     }
     resolveStderrPathForPidPlaceholder() {
         return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stderr.log`);
     }
+    ensureOpenCodeWrapperScript() {
+        const wrapperPath = this.resolveOpenCodeWrapperPath();
+        if (existsSync(wrapperPath)) {
+            return wrapperPath;
+        }
+        writeFileSync(wrapperPath, `#!/bin/sh
+set +e
+state_dir="$1"
+cwd_key="$2"
+shift 2
+pid="$$"
+process_dir="$state_dir/cwds/$cwd_key/$pid"
+stdout_path="$process_dir/stdout.log"
+stderr_path="$process_dir/stderr.log"
+exit_meta_path="$process_dir/exit-status.json"
+mkdir -p "$process_dir"
+: > "$stdout_path"
+: > "$stderr_path"
+"$@" >> "$stdout_path" 2>> "$stderr_path"
+exit_code="$?"
+status="completed"
+if [ "$exit_code" -ne 0 ]; then
+  status="failed"
+fi
+printf '{\n  "status": "%s",\n  "exitCode": %s\n}\n' "$status" "$exit_code" > "$exit_meta_path"
+exit "$exit_code"
+`);
+        chmodSync(wrapperPath, 0o755);
+        return wrapperPath;
+    }
     renamePlaceholderFile(fromPath, toPath) {
         renameSync(fromPath, toPath);
     }

package/dist/cli-utils.js

@@ -2,9 +2,7 @@ import { accessSync, constants } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import * as path from 'path';
-// Define debugMode globally using const
 const debugMode = process.env.MCP_CLAUDE_DEBUG === 'true';
-// Dedicated debug logging function
 export function debugLog(message, ...optionalParams) {
     if (debugMode) {
         console.error(message, ...optionalParams);
@@ -77,7 +75,7 @@ function inspectCliBinary(options) {
             lookup: 'env',
         };
     }
-    if (isExecutableFile(options.localInstallPath)) {
+    if (options.localInstallPath && isExecutableFile(options.localInstallPath)) {
         return {
             configuredCommand,
             resolvedPath: options.localInstallPath,
@@ -136,6 +134,13 @@ function getCliBinaryConfig(name) {
             localInstallPath: join(homedir(), '.forge', 'local', 'forge'),
         };
     }
+    if (name === 'opencode') {
+        return {
+            envVarName: 'OPENCODE_CLI_NAME',
+            customCliName: process.env.OPENCODE_CLI_NAME,
+            defaultCliName: 'opencode',
+        };
+    }
     return {
         envVarName: 'GEMINI_CLI_NAME',
         customCliName: process.env.GEMINI_CLI_NAME,
@@ -152,43 +157,29 @@ export function getCliDoctorStatus() {
         codex: getCliBinaryStatus('codex'),
         gemini: getCliBinaryStatus('gemini'),
         forge: getCliBinaryStatus('forge'),
+        opencode: getCliBinaryStatus('opencode'),
     };
 }
-/**
- * Determine the Gemini CLI command/path.
- * Similar to findClaudeCli but for Gemini
- */
 export function findGeminiCli() {
     debugLog('[Debug] Attempting to find Gemini CLI...');
     const status = getCliBinaryStatus('gemini');
     return getCliCommandOrThrow(status);
 }
-/**
- * Determine the Codex CLI command/path.
- * Similar to findClaudeCli but for Codex
- */
 export function findCodexCli() {
     debugLog('[Debug] Attempting to find Codex CLI...');
     const status = getCliBinaryStatus('codex');
     return getCliCommandOrThrow(status);
 }
-/**
- * Determine the Forge CLI command/path.
- */
 export function findForgeCli() {
     debugLog('[Debug] Attempting to find Forge CLI...');
     const status = getCliBinaryStatus('forge');
     return getCliCommandOrThrow(status);
 }
-/**
- * Determine the Claude CLI command/path.
- * 1. Checks for CLAUDE_CLI_NAME environment variable:
- *    - If absolute path, uses it directly
- *    - If relative path, throws error
- *    - If simple name, continues with path resolution
- * 2. Checks for Claude CLI at the local user path: ~/.claude/local/claude.
- * 3. If not found, defaults to the CLI name (or 'claude'), relying on the system's PATH for lookup.
- */
+export function findOpencodeCli() {
+    debugLog('[Debug] Attempting to find OpenCode CLI...');
+    const status = getCliBinaryStatus('opencode');
+    return getCliCommandOrThrow(status);
+}
 export function findClaudeCli() {
     debugLog('[Debug] Attempting to find Claude CLI...');
     const status = getCliBinaryStatus('claude');

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
 /**
  * Minimal argv parser. No external dependencies.
  * Supports: --key value, --key=value
@@ -35,17 +35,18 @@ function parseArgs(argv) {
 const USAGE = `Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]
 
 Options:
-  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro, forge)
+  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro, forge, opencode, oc-openai/gpt-5.4)
   --workFolder         Working directory (absolute path)
   --prompt             Prompt string (mutually exclusive with --prompt_file)
   --prompt_file        Path to a file containing the prompt
-  --session_id         Session ID to resume
-  --reasoning_effort   Claude/Codex only: Claude=low|medium|high, Codex=low|medium|high|xhigh
+  --session_id         Session ID to resume, including OpenCode in-place resumes
+  --reasoning_effort   Claude/Codex only: Claude=low|medium|high, Codex=low|medium|high|xhigh; unsupported for Gemini, Forge, and OpenCode
   --help               Show this help message
 
 Raw CLI output goes to stdout. Use cli.run.parse to parse the output:
   npm run -s cli.run -- ... > raw.txt
   npm run -s cli.run.parse -- --agent claude < raw.txt
+  npm run -s cli.run.parse -- --agent opencode < raw.txt
 `;
 async function main() {
     const args = parseArgs(process.argv.slice(2));
@@ -69,6 +70,7 @@ async function main() {
         codex: findCodexCli(),
         gemini: findGeminiCli(),
         forge: findForgeCli(),
+        opencode: findOpencodeCli(),
     };
     // Build command
     let cmd;

package/dist/model-catalog.js

@@ -20,6 +20,7 @@ export const GEMINI_MODELS = [
     'gemini-3-flash-preview',
 ];
 export const FORGE_MODELS = ['forge'];
+export const OPENCODE_MODELS = ['opencode'];
 export const MODEL_ALIASES = {
     'claude-ultra': 'opus',
     'codex-ultra': 'gpt-5.4',
@@ -37,10 +38,12 @@ export function getSupportedModelsDescription() {
         ...CODEX_MODELS.map((model) => `"${model}"`),
         ...GEMINI_MODELS.map((model) => `"${model}"`),
         ...FORGE_MODELS.map((model) => `"${model}"`),
+        ...OPENCODE_MODELS.map((model) => `"${model}"`),
+        '"oc-<provider/model>"',
     ].join(', ');
 }
 export function getModelParameterDescription() {
-    return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS].map((model) => `"${model}"`).join(', ')}. "forge" is a provider key, not a Forge model family selector.`;
+    return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS, ...OPENCODE_MODELS].map((model) => `"${model}"`).join(', ')}. OpenCode also accepts explicit dynamic models using "oc-<provider/model>". "forge" is a provider key, not a Forge model family selector.`;
 }
 export function getModelsPayload() {
     return {
@@ -49,5 +52,14 @@ export function getModelsPayload() {
         codex: CODEX_MODELS,
         gemini: GEMINI_MODELS,
         forge: FORGE_MODELS,
+        opencode: OPENCODE_MODELS,
+        dynamicModelBackends: {
+            opencode: {
+                explicitPrefix: 'oc-',
+                explicitPattern: 'oc-<provider/model>',
+                discoveryCommand: 'opencode models',
+                modelsAreDynamic: true,
+            },
+        },
     };
 }

package/dist/parsers.js

@@ -1,7 +1,4 @@
 import { debugLog } from './cli-utils.js';
-/**
- * Parse Codex NDJSON output to extract the last agent message and token count
- */
 export function parseCodexOutput(stdout) {
     if (!stdout)
         return null;
@@ -25,7 +22,6 @@ export function parseCodexOutput(stdout) {
                         lastMessage = parsed.msg.message;
                     }
                     else if (parsed.item?.type === 'reasoning') {
-                        // Ignore reasoning-only items for message selection.
                     }
                     else if (parsed.msg?.type === 'token_count') {
                         tokenCount = parsed.msg;
@@ -34,7 +30,7 @@ export function parseCodexOutput(stdout) {
                         tools.push({
                             server: parsed.item.server,
                             tool: parsed.item.tool,
-                            input: parsed.item.arguments, // Map arguments to input to match common patterns
+                            input: parsed.item.arguments,
                             output: parsed.item.result
                         });
                     }
@@ -48,7 +44,6 @@ export function parseCodexOutput(stdout) {
                     }
                 }
                 catch (e) {
-                    // Skip invalid JSON lines
                     debugLog(`[Debug] Skipping invalid JSON line: ${line}`);
                 }
             }
@@ -67,56 +62,46 @@ export function parseCodexOutput(stdout) {
     }
     return null;
 }
-/**
- * Parse Claude Output (supports both JSON and stream-json/NDJSON)
- */
 export function parseClaudeOutput(stdout) {
     if (!stdout)
         return null;
-    // First try parsing as a single JSON object (backward compatibility)
     try {
         return JSON.parse(stdout);
     }
     catch (e) {
-        // If not valid single JSON, proceed to parse as NDJSON
     }
     try {
         const lines = stdout.trim().split('\n');
         let lastMessage = null;
         let sessionId = null;
-        const toolsMap = new Map(); // Map by tool_use id for matching results
+        const toolsMap = new Map();
         for (const line of lines) {
             if (!line.trim())
                 continue;
             try {
                 const parsed = JSON.parse(line);
-                // Extract session ID from any message that has it
                 if (parsed.session_id) {
                     sessionId = parsed.session_id;
                 }
-                // Extract final result message
                 if (parsed.type === 'result' && parsed.result) {
                     lastMessage = parsed.result;
                 }
-                // Extract tool usage from assistant messages
                 if (parsed.type === 'assistant' && parsed.message?.content) {
                     for (const content of parsed.message.content) {
                         if (content.type === 'tool_use') {
                             toolsMap.set(content.id, {
                                 tool: content.name,
                                 input: content.input,
-                                output: null // Will be filled when tool_result is found
+                                output: null
                             });
                         }
                     }
                 }
-                // Match tool results from user messages
                 if (parsed.type === 'user' && parsed.message?.content) {
                     for (const content of parsed.message.content) {
                         if (content.type === 'tool_result' && content.tool_use_id) {
                             const tool = toolsMap.get(content.tool_use_id);
                             if (tool) {
-                                // Extract text from content array
                                 if (Array.isArray(content.content)) {
                                     const textContent = content.content.find((c) => c.type === 'text');
                                     tool.output = textContent?.text || null;
@@ -133,11 +118,10 @@ export function parseClaudeOutput(stdout) {
                 debugLog(`[Debug] Skipping invalid JSON line in Claude output: ${line}`);
             }
         }
-        // Convert Map to array
         const tools = Array.from(toolsMap.values());
         if (lastMessage || sessionId || tools.length > 0) {
             return {
-                message: lastMessage, // This is the final result text
+                message: lastMessage,
                 session_id: sessionId,
                 tools: tools.length > 0 ? tools : undefined
             };
@@ -149,9 +133,6 @@ export function parseClaudeOutput(stdout) {
     }
     return null;
 }
-/**
- * Parse Gemini JSON output
- */
 export function parseGeminiOutput(stdout) {
     if (!stdout)
         return null;
@@ -163,9 +144,6 @@ export function parseGeminiOutput(stdout) {
         return null;
     }
 }
-/**
- * Parse Forge output framed by Initialize/Continue/Finished markers.
- */
 export function parseForgeOutput(stdout) {
     if (!stdout)
         return null;
@@ -218,3 +196,56 @@ export function parseForgeOutput(stdout) {
         session_id: lastConversationId,
     };
 }
+export function parseOpenCodeOutput(stdout) {
+    if (!stdout) {
+        return null;
+    }
+    let sessionId = null;
+    let currentStepBuffer = '';
+    let latestCompletedStep = null;
+    let hasStepFinish = false;
+    let hasParseableAssistantText = false;
+    for (const line of stdout.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed.sessionID === 'string' && parsed.sessionID) {
+            sessionId = parsed.sessionID;
+        }
+        if (parsed.type === 'step_start') {
+            currentStepBuffer = '';
+            continue;
+        }
+        if (parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string') {
+            currentStepBuffer += parsed.part.text;
+            hasParseableAssistantText = true;
+            continue;
+        }
+        if (parsed.type === 'step_finish') {
+            hasStepFinish = true;
+            latestCompletedStep = {
+                message: currentStepBuffer,
+                session_id: sessionId || undefined,
+                tokens: parsed.part?.tokens,
+                cost: parsed.part?.cost,
+            };
+        }
+    }
+    if (hasStepFinish && latestCompletedStep) {
+        return latestCompletedStep;
+    }
+    if (hasParseableAssistantText) {
+        return {
+            message: currentStepBuffer,
+            session_id: sessionId || undefined,
+        };
+    }
+    return null;
+}

package/dist/process-result.js

@@ -23,6 +23,9 @@ function hasMeaningfulParsedOutput(agentOutput) {
         return true;
     });
 }
+function shouldPreserveRawFailureOutput(context) {
+    return context.agent === 'opencode' && context.status === 'failed';
+}
 export function buildProcessResult(context, agentOutput, verbose = false) {
     const response = {
         pid: context.pid,
@@ -40,12 +43,16 @@ export function buildProcessResult(context, agentOutput, verbose = false) {
         response.session_id = agentOutput.session_id;
     }
     const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
-    if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+    const preserveRawFailureOutput = shouldPreserveRawFailureOutput(context);
+    if (hasMeaningfulParsedOutput(shapedAgentOutput) && (verbose || !preserveRawFailureOutput)) {
         response.agentOutput = shapedAgentOutput;
     }
-    if (!response.agentOutput) {
+    if (!response.agentOutput || preserveRawFailureOutput) {
         response.stdout = context.stdout;
         response.stderr = context.stderr;
     }
+    if (verbose && preserveRawFailureOutput && hasMeaningfulParsedOutput(shapedAgentOutput)) {
+        response.agentOutput = shapedAgentOutput;
+    }
     return response;
 }

package/dist/process-service.js

@@ -1,7 +1,28 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
+function parseAgentOutput(agent, stdout, stderr) {
+    if (agent === 'codex') {
+        return parseCodexOutput(`${stdout || ''}\n${stderr || ''}`);
+    }
+    if (!stdout) {
+        return null;
+    }
+    if (agent === 'claude') {
+        return parseClaudeOutput(stdout);
+    }
+    if (agent === 'gemini') {
+        return parseGeminiOutput(stdout);
+    }
+    if (agent === 'forge') {
+        return parseForgeOutput(stdout);
+    }
+    if (agent === 'opencode') {
+        return parseOpenCodeOutput(stdout);
+    }
+    return null;
+}
 export class ProcessService {
     processManager = new Map();
     cliPaths;
@@ -85,22 +106,7 @@ export class ProcessService {
         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 agentOutput = parseAgentOutput(process.toolType, process.stdout, process.stderr);
         return buildProcessResult({
             pid,
             agent: process.toolType,

package/dist/server.js

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
 export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';
 import { runMcpServer } from './app/mcp.js';