ai-cli-mcp 2.14.1 → 2.16.0

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,23 +1,35 @@
 import { spawn } from 'node:child_process';
 import {
+  chmodSync,
   closeSync,
   existsSync,
   mkdirSync,
   openSync,
+  readSync,
   readFileSync,
   readdirSync,
   realpathSync,
   renameSync,
   rmSync,
+  statSync,
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
 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, PeekMessageExtractor } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
+import {
+  appendPeekMessages,
+  buildNotFoundPeekProcess,
+  observedDurationSec,
+  validatePeekPids,
+  validatePeekTimeSec,
+  type PeekProcessResult,
+  type PeekResponse,
+} from './peek.js';
 import type { AgentType, ProcessListItem } from './process-service.js';
 
 interface StoredProcess {
@@ -31,6 +43,12 @@ interface StoredProcess {
   stdoutPath: string;
   stderrPath: string;
   status: 'running' | 'completed' | 'failed';
+  exitCode?: number;
+}
+
+interface StoredExitStatus {
+  status: 'completed' | 'failed';
+  exitCode?: number;
 }
 
 interface CliProcessServiceOptions {
@@ -70,6 +88,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'];
@@ -81,6 +123,7 @@ export class CliProcessService {
       codex: findCodexCli(),
       gemini: findGeminiCli(),
       forge: findForgeCli(),
+      opencode: findOpencodeCli(),
     };
     mkdirSync(this.stateDir, { recursive: true });
   }
@@ -96,6 +139,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;
@@ -172,25 +219,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,
@@ -220,6 +255,97 @@ export class CliProcessService {
     }
   }
 
+  async peekProcesses(pids: number[], peekTimeSec = 10): Promise<PeekResponse> {
+    const targetPids = validatePeekPids(pids);
+    const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
+    const processes: PeekProcessResult[] = [];
+    const observers: Array<{
+      process: StoredProcess;
+      result: PeekProcessResult;
+      stdoutExtractor: PeekMessageExtractor;
+      stderrExtractor: PeekMessageExtractor;
+      stdoutOffset: number;
+      stderrOffset: number;
+    }> = [];
+
+    for (const pid of targetPids) {
+      let process: StoredProcess;
+      try {
+        process = this.refreshStatus(this.readProcess(pid));
+      } catch {
+        processes.push(buildNotFoundPeekProcess(pid));
+        continue;
+      }
+
+      const result: PeekProcessResult = {
+        pid,
+        agent: process.toolType,
+        status: process.status,
+        messages: [],
+        truncated: false,
+        error: null,
+      };
+      processes.push(result);
+      observers.push({
+        process,
+        result,
+        stdoutExtractor: new PeekMessageExtractor(process.toolType),
+        stderrExtractor: new PeekMessageExtractor(process.toolType),
+        stdoutOffset: this.fileSizeSafe(process.stdoutPath),
+        stderrOffset: this.fileSizeSafe(process.stderrPath),
+      });
+    }
+
+    const startedAt = new Date();
+    const startedAtMs = Date.now();
+    const deadlineMs = startedAtMs + targetPeekTimeSec * 1000;
+
+    while (Date.now() <= deadlineMs) {
+      const observedAt = new Date().toISOString();
+      let allTerminal = true;
+
+      for (const observer of observers) {
+        const stdoutRead = this.readTextFromOffset(observer.process.stdoutPath, observer.stdoutOffset);
+        observer.stdoutOffset = stdoutRead.offset;
+        appendPeekMessages(observer.result, observer.stdoutExtractor.push(stdoutRead.text, observedAt));
+
+        const stderrRead = this.readTextFromOffset(observer.process.stderrPath, observer.stderrOffset);
+        observer.stderrOffset = stderrRead.offset;
+        appendPeekMessages(observer.result, observer.stderrExtractor.push(stderrRead.text, observedAt));
+
+        observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
+        observer.result.status = observer.process.status;
+        if (observer.process.status === 'running') {
+          allTerminal = false;
+        }
+      }
+
+      if (allTerminal) {
+        break;
+      }
+
+      const remainingMs = deadlineMs - Date.now();
+      if (remainingMs <= 0) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(50, remainingMs)));
+    }
+
+    const flushTs = new Date().toISOString();
+    for (const observer of observers) {
+      observer.process = this.refreshStatus(this.readProcess(observer.process.pid));
+      observer.result.status = observer.process.status;
+      appendPeekMessages(observer.result, observer.stdoutExtractor.flush(flushTs));
+      appendPeekMessages(observer.result, observer.stderrExtractor.flush(flushTs));
+    }
+
+    return {
+      peek_started_at: startedAt.toISOString(),
+      observed_duration_sec: observedDurationSec(startedAtMs),
+      processes,
+    };
+  }
+
   async killProcess(pid: number): Promise<{ pid: number; status: string; message: string }> {
     const process = this.readProcess(pid);
     const refreshed = this.refreshStatus(process);
@@ -277,6 +403,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)) {
@@ -320,13 +499,47 @@ export class CliProcessService {
   }
 
   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 '';
@@ -334,6 +547,37 @@ export class CliProcessService {
     return readFileSync(filePath, 'utf-8');
   }
 
+  private fileSizeSafe(filePath: string): number {
+    if (!existsSync(filePath)) {
+      return 0;
+    }
+    return statSync(filePath).size;
+  }
+
+  private readTextFromOffset(filePath: string, offset: number): { text: string; offset: number } {
+    if (!existsSync(filePath)) {
+      return { text: '', offset };
+    }
+
+    const size = statSync(filePath).size;
+    if (size <= offset) {
+      return { text: '', offset: size };
+    }
+
+    const fd = openSync(filePath, 'r');
+    try {
+      const length = size - offset;
+      const buffer = Buffer.alloc(length);
+      const bytesRead = readSync(fd, buffer, 0, length, offset);
+      return {
+        text: buffer.subarray(0, bytesRead).toString('utf-8'),
+        offset: size,
+      };
+    } finally {
+      closeSync(fd);
+    }
+  }
+
   private resolveCwdsDir(): string {
     return join(this.stateDir, 'cwds');
   }
@@ -365,6 +609,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`);
   }
@@ -373,6 +625,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);
   }

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