ai-cli-mcp 2.14.0 → 2.15.0

package/src/cli-builder.ts

@@ -1,11 +1,21 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve as pathResolve, isAbsolute } from 'node:path';
+import type { CliPaths } from './cli-utils.js';
 import { MODEL_ALIASES } from './model-catalog.js';
 
 export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
 const CLAUDE_REASONING_EFFORTS = new Set(['low', 'medium', 'high']);
+const OPENCODE_MODEL_ERROR = 'Invalid OpenCode model. Expected exact syntax oc-<provider/model>.';
 
-function getAgentForModel(model: string): 'codex' | 'claude' | 'gemini' | 'forge' {
+type Agent = 'codex' | 'claude' | 'gemini' | 'forge' | 'opencode';
+
+interface ModelSelection {
+  agent: Agent;
+  resolvedModel: string;
+  openCodeModel: string | null;
+}
+
+function getStandardAgentForModel(model: string): Exclude<Agent, 'opencode'> {
   if (model === 'forge') {
     return 'forge';
   }
@@ -18,20 +28,63 @@ function getAgentForModel(model: string): 'codex' | 'claude' | 'gemini' | 'forge
   return 'claude';
 }
 
-/**
- * Resolves model aliases to their full model names
- * @param model - The model name or alias to resolve
- * @returns The full model name, or the original value if no alias exists
- */
+function isPotentialOpenCodeExplicitModel(rawModel: string): boolean {
+  return rawModel.startsWith('oc-') || rawModel.trim().startsWith('oc-');
+}
+
+function extractOpenCodeModel(rawModel: string): string {
+  if (rawModel !== rawModel.trim()) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  if (!rawModel.startsWith('oc-')) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  const remainder = rawModel.slice(3);
+  const slashIndex = remainder.indexOf('/');
+  if (slashIndex === -1) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  const provider = remainder.slice(0, slashIndex);
+  const model = remainder.slice(slashIndex + 1);
+  if (!provider || !model) {
+    throw new Error(OPENCODE_MODEL_ERROR);
+  }
+
+  return remainder;
+}
+
+function resolveModelSelection(rawModel: string): ModelSelection {
+  if (rawModel === 'opencode') {
+    return {
+      agent: 'opencode',
+      resolvedModel: rawModel,
+      openCodeModel: null,
+    };
+  }
+
+  if (isPotentialOpenCodeExplicitModel(rawModel)) {
+    return {
+      agent: 'opencode',
+      resolvedModel: rawModel,
+      openCodeModel: extractOpenCodeModel(rawModel),
+    };
+  }
+
+  const resolvedModel = resolveModelAlias(rawModel);
+  return {
+    agent: getStandardAgentForModel(resolvedModel),
+    resolvedModel,
+    openCodeModel: null,
+  };
+}
+
 export function resolveModelAlias(model: string): string {
   return MODEL_ALIASES[model] || model;
 }
 
-/**
- * Validates and normalizes reasoning effort parameter.
- * @returns normalized reasoning effort string, or '' if not applicable
- * @throws Error for invalid values (plain Error, not MCP-specific)
- */
 export function getReasoningEffort(model: string, rawValue: unknown): string {
   if (typeof rawValue !== 'string') {
     return '';
@@ -40,13 +93,18 @@ export function getReasoningEffort(model: string, rawValue: unknown): string {
   if (!trimmed) {
     return '';
   }
+
+  if (model === 'opencode' || model.startsWith('oc-')) {
+    throw new Error('reasoning_effort is not supported for opencode.');
+  }
+
   const normalized = trimmed.toLowerCase();
   if (!ALLOWED_REASONING_EFFORTS.has(normalized)) {
     throw new Error(
       `Invalid reasoning_effort: ${rawValue}. Allowed values: low, medium, high, xhigh.`
     );
   }
-  const agent = getAgentForModel(model);
+  const agent = getStandardAgentForModel(model);
   if (agent === 'forge') {
     throw new Error('reasoning_effort is not supported for forge.');
   }
@@ -67,7 +125,7 @@ export interface CliCommand {
   cliPath: string;
   args: string[];
   cwd: string;
-  agent: 'claude' | 'codex' | 'gemini' | 'forge';
+  agent: Agent;
   prompt: string;
   resolvedModel: string;
 }
@@ -79,21 +137,14 @@ export interface BuildCliCommandOptions {
   model?: string;
   session_id?: string;
   reasoning_effort?: string;
-  cliPaths: { claude: string; codex: string; gemini: string; forge: string };
+  cliPaths: CliPaths;
 }
 
-/**
- * Build a CLI command from the given options.
- * This is a pure function (aside from filesystem reads for prompt_file / workFolder validation).
- * @throws Error on validation failures
- */
 export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
-  // Validate workFolder
   if (!options.workFolder || typeof options.workFolder !== 'string') {
     throw new Error('Missing or invalid required parameter: workFolder');
   }
 
-  // Validate prompt / prompt_file
   const hasPrompt = !!options.prompt && typeof options.prompt === 'string' && options.prompt.trim() !== '';
   const hasPromptFile = !!options.prompt_file && typeof options.prompt_file === 'string' && options.prompt_file.trim() !== '';
 
@@ -105,7 +156,6 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     throw new Error('Cannot specify both prompt and prompt_file. Please use only one.');
   }
 
-  // Determine prompt
   let prompt: string;
   if (hasPrompt) {
     prompt = options.prompt!;
@@ -125,18 +175,14 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
   }
 
-  // Resolve workFolder
   const cwd = pathResolve(options.workFolder);
   if (!existsSync(cwd)) {
     throw new Error(`Working folder does not exist: ${options.workFolder}`);
   }
 
-  // Resolve model
   const rawModel = options.model || '';
-  const resolvedModel = resolveModelAlias(rawModel);
-  const agent = getAgentForModel(resolvedModel);
+  const { agent, resolvedModel, openCodeModel } = resolveModelSelection(rawModel);
 
-  // Special handling for ultra aliases: default to higher reasoning if not specified
   let reasoningEffortArg: string | undefined = options.reasoning_effort;
   if (!reasoningEffortArg) {
     if (rawModel === 'codex-ultra') {
@@ -146,9 +192,11 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
   }
 
-  const reasoningEffort = getReasoningEffort(resolvedModel, reasoningEffortArg);
+  const reasoningTargetModel = rawModel === 'opencode' || rawModel.startsWith('oc-')
+    ? rawModel
+    : (resolvedModel || rawModel);
+  const reasoningEffort = getReasoningEffort(reasoningTargetModel, reasoningEffortArg);
 
-  // Build CLI path and args
   let cliPath: string;
   let args: string[];
 
@@ -169,7 +217,6 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
 
     args.push('--skip-git-repo-check', '--full-auto', '--json', prompt);
-
   } else if (agent === 'gemini') {
     cliPath = options.cliPaths.gemini;
     args = ['-y', '--output-format', 'json'];
@@ -183,7 +230,6 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
 
     args.push(prompt);
-
   } else if (agent === 'forge') {
     cliPath = options.cliPaths.forge;
     args = ['-C', cwd];
@@ -193,6 +239,19 @@ export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
     }
 
     args.push('-p', prompt);
+  } else if (agent === 'opencode') {
+    cliPath = options.cliPaths.opencode;
+    args = ['run', '--format', 'json', '--dir', cwd];
+
+    if (options.session_id && typeof options.session_id === 'string') {
+      args.push('--session', options.session_id);
+    }
+
+    if (openCodeModel) {
+      args.push('--model', openCodeModel);
+    }
+
+    args.push(prompt);
   } else {
     cliPath = options.cliPaths.claude;
     args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];

package/src/cli-parse.ts

@@ -1,21 +1,24 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
 
-const AGENTS = ['claude', 'codex', 'gemini', 'forge'] as const;
+const AGENTS = ['claude', 'codex', 'gemini', 'forge', 'opencode'] as const;
 type Agent = typeof AGENTS[number];
 
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge>
+const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge|opencode>
 
 Reads raw CLI output from stdin and outputs parsed JSON to stdout.
 
 Options:
-  --agent   Agent type: claude, codex, gemini, or forge (required)
+  --agent   Agent type: claude, codex, gemini, forge, or opencode (required)
   --help    Show this help message
 
 Examples:
   npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" > raw.txt
   npm run -s cli.run.parse -- --agent claude < raw.txt
 
+  npm run -s cli.run -- --model opencode --workFolder /tmp --prompt "hi" > raw.txt
+  npm run -s cli.run.parse -- --agent opencode < raw.txt
+
   # Or pipe directly
   npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" | npm run -s cli.run.parse -- --agent claude
 `;
@@ -62,7 +65,7 @@ async function main(): Promise<void> {
 
   const agent = args.agent as Agent;
   if (!agent || !AGENTS.includes(agent)) {
-    process.stderr.write(`Error: --agent is required (claude, codex, gemini, or forge)\n\n`);
+    process.stderr.write(`Error: --agent is required (claude, codex, gemini, forge, or opencode)\n\n`);
     process.stderr.write(USAGE);
     process.exit(1);
   }
@@ -88,6 +91,9 @@ async function main(): Promise<void> {
     case 'forge':
       parsed = parseForgeOutput(input);
       break;
+    case 'opencode':
+      parsed = parseOpenCodeOutput(input);
+      break;
   }
 
   process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');

package/src/cli-process-service.ts

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import {
+  chmodSync,
   closeSync,
   existsSync,
   mkdirSync,
@@ -12,11 +13,11 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { buildCliCommand, type BuildCliCommandOptions } 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';
 import type { AgentType, ProcessListItem } from './process-service.js';
 
@@ -24,12 +25,19 @@ interface StoredProcess {
   pid: number;
   prompt: string;
   workFolder: string;
+  cwdKey?: string;
   model?: string;
   toolType: AgentType;
   startTime: string;
   stdoutPath: string;
   stderrPath: string;
   status: 'running' | 'completed' | 'failed';
+  exitCode?: number;
+}
+
+interface StoredExitStatus {
+  status: 'completed' | 'failed';
+  exitCode?: number;
 }
 
 interface CliProcessServiceOptions {
@@ -69,6 +77,30 @@ function normalizeCwdForStorage(cwd: string): string {
     .join('');
 }
 
+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 CliProcessService {
   private readonly stateDir: string;
   private readonly cliPaths: BuildCliCommandOptions['cliPaths'];
@@ -80,6 +112,7 @@ export class CliProcessService {
       codex: findCodexCli(),
       gemini: findGeminiCli(),
       forge: findForgeCli(),
+      opencode: findOpencodeCli(),
     };
     mkdirSync(this.stateDir, { recursive: true });
   }
@@ -95,6 +128,10 @@ export class CliProcessService {
       cliPaths: this.cliPaths,
     });
 
+    if (cmd.agent === 'opencode') {
+      return this.startDetachedOpenCodeProcess(cmd, options.model);
+    }
+
     const stdoutPath = this.resolveStdoutPathForPidPlaceholder();
     const stderrPath = this.resolveStderrPathForPidPlaceholder();
     let stdoutFd: number | undefined;
@@ -128,6 +165,7 @@ export class CliProcessService {
         pid,
         prompt: cmd.prompt,
         workFolder: cmd.cwd,
+        cwdKey: this.resolveCwdKey(cmd.cwd),
         model: options.model,
         toolType: cmd.agent,
         startTime: new Date().toISOString(),
@@ -170,25 +208,13 @@ export class CliProcessService {
     const refreshed = this.refreshStatus(storedProcess);
     const stdout = this.readTextFileSafe(refreshed.stdoutPath);
     const stderr = this.readTextFileSafe(refreshed.stderrPath);
-
-    let agentOutput: any = 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,
@@ -260,7 +286,7 @@ export class CliProcessService {
         continue;
       }
 
-      const processDir = this.resolveProcessDir(refreshed.workFolder, refreshed.pid);
+      const processDir = this.resolveStoredProcessDir(refreshed);
       if (existsSync(processDir)) {
         rmSync(processDir, { recursive: true, force: true });
         removed++;
@@ -275,6 +301,59 @@ export class CliProcessService {
     };
   }
 
+  private async startDetachedOpenCodeProcess(
+    cmd: Awaited<ReturnType<typeof buildCliCommand>>,
+    model: string | undefined,
+  ): Promise<{ pid: number; status: 'started'; agent: AgentType; message: string }> {
+    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: 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`,
+    };
+  }
+
   private readAllProcesses(): StoredProcess[] {
     const cwdsDir = this.resolveCwdsDir();
     if (!existsSync(cwdsDir)) {
@@ -304,23 +383,61 @@ export class CliProcessService {
   }
 
   private parseProcessFile(metaPath: string): StoredProcess {
-    return JSON.parse(readFileSync(metaPath, 'utf-8')) as StoredProcess;
+    const process = JSON.parse(readFileSync(metaPath, 'utf-8')) as StoredProcess;
+    if (!process.cwdKey) {
+      process.cwdKey = basename(dirname(dirname(metaPath)));
+    }
+    return process;
   }
 
   private writeProcess(process: StoredProcess): void {
-    const processDir = this.resolveProcessDir(process.workFolder, process.pid);
+    const processDir = this.resolveStoredProcessDir(process);
     mkdirSync(processDir, { recursive: true });
     writeFileSync(this.resolveMetaPath(processDir), JSON.stringify(process, null, 2));
   }
 
   private refreshStatus(process: StoredProcess): StoredProcess {
-    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;
   }
 
+  private readExitStatus(process: StoredProcess): StoredExitStatus | null {
+    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')) as StoredExitStatus;
+      if (parsed.status === 'completed' || parsed.status === 'failed') {
+        return parsed;
+      }
+    } catch {
+      return null;
+    }
+
+    return null;
+  }
+
   private readTextFileSafe(filePath: string): string {
     if (!existsSync(filePath)) {
       return '';
@@ -333,7 +450,18 @@ export class CliProcessService {
   }
 
   private resolveProcessDir(cwd: string, pid: number): string {
-    return join(this.resolveCwdsDir(), normalizeCwdForStorage(realpathSync(cwd)), String(pid));
+    return join(this.resolveCwdsDir(), this.resolveCwdKey(cwd), String(pid));
+  }
+
+  private resolveStoredProcessDir(process: StoredProcess): string {
+    if (!process.cwdKey) {
+      process.cwdKey = this.resolveCwdKey(process.workFolder);
+    }
+    return join(this.resolveCwdsDir(), process.cwdKey, String(process.pid));
+  }
+
+  private resolveCwdKey(cwd: string): string {
+    return normalizeCwdForStorage(realpathSync(cwd));
   }
 
   private resolveMetaPath(processDir: string): string {
@@ -348,6 +476,14 @@ export class CliProcessService {
     return join(processDir, 'stderr.log');
   }
 
+  private resolveExitStatusPath(processDir: string): string {
+    return join(processDir, 'exit-status.json');
+  }
+
+  private resolveOpenCodeWrapperPath(): string {
+    return join(this.stateDir, 'opencode-detached-wrapper.sh');
+  }
+
   private resolveStdoutPathForPidPlaceholder(): string {
     return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stdout.log`);
   }
@@ -356,6 +492,41 @@ export class CliProcessService {
     return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stderr.log`);
   }
 
+  private ensureOpenCodeWrapperScript(): string {
+    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;
+  }
+
   private renamePlaceholderFile(fromPath: string, toPath: string): void {
     renameSync(fromPath, toPath);
   }