ai-cli-mcp 2.14.0 → 2.15.0

package/src/cli-utils.ts

@@ -3,10 +3,8 @@ 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?: any, ...optionalParams: any[]): void {
   if (debugMode) {
     console.error(message, ...optionalParams);
@@ -21,6 +19,24 @@ export interface CliBinaryStatus {
   error?: string;
 }
 
+export type CliBinaryName = 'claude' | 'codex' | 'gemini' | 'forge' | 'opencode';
+
+export interface CliPaths {
+  claude: string;
+  codex: string;
+  gemini: string;
+  forge: string;
+  opencode: string;
+}
+
+export interface CliDoctorStatus {
+  claude: CliBinaryStatus;
+  codex: CliBinaryStatus;
+  gemini: CliBinaryStatus;
+  forge: CliBinaryStatus;
+  opencode: CliBinaryStatus;
+}
+
 function getPathDelimiter(): string {
   return process.platform === 'win32' ? ';' : ':';
 }
@@ -75,7 +91,7 @@ function inspectCliBinary(options: {
   envVarName: string;
   customCliName: string | undefined;
   defaultCliName: string;
-  localInstallPath: string;
+  localInstallPath?: string;
 }): CliBinaryStatus {
   const configuredCommand = options.customCliName || options.defaultCliName;
 
@@ -109,7 +125,7 @@ function inspectCliBinary(options: {
     };
   }
 
-  if (isExecutableFile(options.localInstallPath)) {
+  if (options.localInstallPath && isExecutableFile(options.localInstallPath)) {
     return {
       configuredCommand,
       resolvedPath: options.localInstallPath,
@@ -148,13 +164,11 @@ function isExecutableFile(filePath: string): boolean {
   }
 }
 
-type CliBinaryName = 'claude' | 'codex' | 'gemini' | 'forge';
-
 function getCliBinaryConfig(name: CliBinaryName): {
   envVarName: string;
   customCliName: string | undefined;
   defaultCliName: string;
-  localInstallPath: string;
+  localInstallPath?: string;
 } {
   if (name === 'claude') {
     return {
@@ -183,6 +197,14 @@ function getCliBinaryConfig(name: CliBinaryName): {
     };
   }
 
+  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,
@@ -195,58 +217,40 @@ function getCliBinaryStatus(name: CliBinaryName): CliBinaryStatus {
   return inspectCliBinary(getCliBinaryConfig(name));
 }
 
-export function getCliDoctorStatus(): {
-  claude: CliBinaryStatus;
-  codex: CliBinaryStatus;
-  gemini: CliBinaryStatus;
-  forge: CliBinaryStatus;
-} {
+export function getCliDoctorStatus(): CliDoctorStatus {
   return {
     claude: getCliBinaryStatus('claude'),
     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(): string {
   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(): string {
   debugLog('[Debug] Attempting to find Codex CLI...');
   const status = getCliBinaryStatus('codex');
   return getCliCommandOrThrow(status);
 }
 
-/**
- * Determine the Forge CLI command/path.
- */
 export function findForgeCli(): string {
   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(): string {
+  debugLog('[Debug] Attempting to find OpenCode CLI...');
+  const status = getCliBinaryStatus('opencode');
+  return getCliCommandOrThrow(status);
+}
+
 export function findClaudeCli(): string {
   debugLog('[Debug] Attempting to find Claude CLI...');
   const status = getCliBinaryStatus('claude');

package/src/cli.ts

@@ -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.
@@ -35,17 +35,18 @@ function parseArgs(argv: string[]): Record<string, string> {
 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(): Promise<void> {
@@ -74,6 +75,7 @@ async function main(): Promise<void> {
     codex: findCodexCli(),
     gemini: findGeminiCli(),
     forge: findForgeCli(),
+    opencode: findOpencodeCli(),
   };
 
   // Build command

package/src/model-catalog.ts

@@ -20,6 +20,7 @@ export const GEMINI_MODELS = [
   'gemini-3-flash-preview',
 ] as const;
 export const FORGE_MODELS = ['forge'] as const;
+export const OPENCODE_MODELS = ['opencode'] as const;
 
 export const MODEL_ALIASES: Record<string, string> = {
   'claude-ultra': 'opus',
@@ -33,6 +34,13 @@ export const MODEL_ALIAS_DETAILS = [
   { name: 'gemini-ultra', resolvesTo: 'gemini-3.1-pro-preview', agent: 'gemini' },
 ] as const;
 
+export interface DynamicModelBackendDescription {
+  explicitPrefix: string;
+  explicitPattern: string;
+  discoveryCommand: string;
+  modelsAreDynamic: boolean;
+}
+
 export function getSupportedModelsDescription(): string {
   return [
     '"claude-ultra", "codex-ultra", "gemini-ultra"',
@@ -40,11 +48,13 @@ export function getSupportedModelsDescription(): string {
     ...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(): string {
-  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(): {
@@ -53,6 +63,10 @@ export function getModelsPayload(): {
   codex: ReadonlyArray<string>;
   gemini: ReadonlyArray<string>;
   forge: ReadonlyArray<string>;
+  opencode: ReadonlyArray<string>;
+  dynamicModelBackends: {
+    opencode: DynamicModelBackendDescription;
+  };
 } {
   return {
     aliases: MODEL_ALIAS_DETAILS,
@@ -60,5 +74,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/src/parsers.ts

@@ -1,18 +1,15 @@
 import { debugLog } from './cli-utils.js';
 
-/**
- * Parse Codex NDJSON output to extract the last agent message and token count
- */
 export function parseCodexOutput(stdout: string): any {
   if (!stdout) return null;
-  
+
   try {
     const lines = stdout.trim().split('\n');
     let lastMessage = null;
     let tokenCount = null;
     let threadId = null;
     const tools: any[] = [];
-    
+
     for (const line of lines) {
       if (line.trim()) {
         try {
@@ -24,14 +21,13 @@ export function parseCodexOutput(stdout: string): any {
           } else if (parsed.msg?.type === 'agent_message') {
             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;
           } else if (parsed.type === 'item.completed' && parsed.item?.type === 'mcp_tool_call') {
             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
             });
           } else if (parsed.type === 'item.completed' && parsed.item?.type === 'command_execution') {
@@ -43,12 +39,11 @@ export function parseCodexOutput(stdout: string): any {
             });
           }
         } catch (e) {
-          // Skip invalid JSON lines
           debugLog(`[Debug] Skipping invalid JSON line: ${line}`);
         }
       }
     }
-    
+
     if (lastMessage || tokenCount || threadId || tools.length > 0) {
       return {
         message: lastMessage,
@@ -60,28 +55,23 @@ export function parseCodexOutput(stdout: string): any {
   } catch (e) {
     debugLog(`[Debug] Failed to parse Codex NDJSON output: ${e}`);
   }
-  
+
   return null;
 }
 
-/**
- * Parse Claude Output (supports both JSON and stream-json/NDJSON)
- */
 export function parseClaudeOutput(stdout: string): any {
   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<string, any>(); // Map by tool_use id for matching results
+    const toolsMap = new Map<string, any>();
 
     for (const line of lines) {
       if (!line.trim()) continue;
@@ -89,36 +79,31 @@ export function parseClaudeOutput(stdout: string): any {
       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: any) => c.type === 'text');
                   tool.output = textContent?.text || null;
@@ -135,12 +120,11 @@ export function parseClaudeOutput(stdout: string): any {
       }
     }
 
-    // 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
       };
@@ -150,13 +134,10 @@ export function parseClaudeOutput(stdout: string): any {
     debugLog(`[Debug] Failed to parse Claude NDJSON output: ${e}`);
     return null;
   }
-  
+
   return null;
 }
 
-/**
- * Parse Gemini JSON output
- */
 export function parseGeminiOutput(stdout: string): any {
   if (!stdout) return null;
 
@@ -168,9 +149,6 @@ export function parseGeminiOutput(stdout: string): any {
   }
 }
 
-/**
- * Parse Forge output framed by Initialize/Continue/Finished markers.
- */
 export function parseForgeOutput(stdout: string): any {
   if (!stdout) return null;
 
@@ -228,3 +206,71 @@ export function parseForgeOutput(stdout: string): any {
     session_id: lastConversationId,
   };
 }
+
+export function parseOpenCodeOutput(stdout: string): any {
+  if (!stdout) {
+    return null;
+  }
+
+  let sessionId: string | null = null;
+  let currentStepBuffer = '';
+  let latestCompletedStep: {
+    message: string;
+    session_id?: string;
+    tokens?: any;
+    cost?: number;
+  } | null = null;
+  let hasStepFinish = false;
+  let hasParseableAssistantText = false;
+
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    let parsed: any;
+    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/src/process-result.ts

@@ -45,6 +45,10 @@ function hasMeaningfulParsedOutput(agentOutput: any): boolean {
   });
 }
 
+function shouldPreserveRawFailureOutput(context: ProcessResultContext): boolean {
+  return context.agent === 'opencode' && context.status === 'failed';
+}
+
 export function buildProcessResult(context: ProcessResultContext, agentOutput: any, verbose = false): any {
   const response: any = {
     pid: context.pid,
@@ -65,15 +69,20 @@ export function buildProcessResult(context: ProcessResultContext, agentOutput: a
   }
 
   const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
+  const preserveRawFailureOutput = shouldPreserveRawFailureOutput(context);
 
-  if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+  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/src/process-service.ts

@@ -1,9 +1,9 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import { buildCliCommand, type BuildCliCommandOptions } 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';
 
-export type AgentType = 'claude' | 'codex' | 'gemini' | 'forge';
+export type AgentType = 'claude' | 'codex' | 'gemini' | 'forge' | 'opencode';
 export type ProcessStatus = 'running' | 'completed' | 'failed';
 
 interface TrackedProcess {
@@ -37,6 +37,31 @@ interface ProcessServiceOptions {
   cliPaths: BuildCliCommandOptions['cliPaths'];
 }
 
+function parseAgentOutput(agent: AgentType, stdout: string, stderr: string): any {
+  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 {
   private readonly processManager = new Map<number, TrackedProcess>();
   private readonly cliPaths: BuildCliCommandOptions['cliPaths'];
@@ -136,19 +161,7 @@ export class ProcessService {
       throw new Error(`Process with PID ${pid} not found`);
     }
 
-    let agentOutput: any = 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,

package/src/server.ts

@@ -1,5 +1,5 @@
-#!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+import { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } 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';
 

package/vitest.config.unit.ts

@@ -17,13 +17,12 @@ export default defineConfig({
     },
     exclude: [
       'node_modules/**',
+      'dist/**',
       'src/__tests__/e2e.test.ts',
       'src/__tests__/edge-cases.test.ts',
-      'dist/__tests__/e2e.test.js',
-      'dist/__tests__/edge-cases.test.js',
     ],
     mockReset: true,
     clearMocks: true,
     restoreMocks: true,
   },
-});
+});