ai-cli-mcp 2.14.1 → 2.16.0

package/dist/cli-builder.js

@@ -3,7 +3,8 @@ import { resolve as pathResolve, isAbsolute } from 'node:path';
 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']);
-function getAgentForModel(model) {
+const OPENCODE_MODEL_ERROR = 'Invalid OpenCode model. Expected exact syntax oc-<provider/model>.';
+function getStandardAgentForModel(model) {
     if (model === 'forge') {
         return 'forge';
     }
@@ -15,19 +16,53 @@ function getAgentForModel(model) {
     }
     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) {
+    return rawModel.startsWith('oc-') || rawModel.trim().startsWith('oc-');
+}
+function extractOpenCodeModel(rawModel) {
+    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) {
+    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) {
     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, rawValue) {
     if (typeof rawValue !== 'string') {
         return '';
@@ -36,11 +71,14 @@ export function getReasoningEffort(model, rawValue) {
     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.');
     }
@@ -52,17 +90,10 @@ export function getReasoningEffort(model, rawValue) {
     }
     return normalized;
 }
-/**
- * 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) {
-    // 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() !== '';
     if (!hasPrompt && !hasPromptFile) {
@@ -71,7 +102,6 @@ export function buildCliCommand(options) {
     if (hasPrompt && hasPromptFile) {
         throw new Error('Cannot specify both prompt and prompt_file. Please use only one.');
     }
-    // Determine prompt
     let prompt;
     if (hasPrompt) {
         prompt = options.prompt;
@@ -90,16 +120,12 @@ export function buildCliCommand(options) {
             throw new Error(`Failed to read prompt file: ${error.message}`);
         }
     }
-    // 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);
-    // Special handling for ultra aliases: default to higher reasoning if not specified
+    const { agent, resolvedModel, openCodeModel } = resolveModelSelection(rawModel);
     let reasoningEffortArg = options.reasoning_effort;
     if (!reasoningEffortArg) {
         if (rawModel === 'codex-ultra') {
@@ -109,8 +135,10 @@ export function buildCliCommand(options) {
             reasoningEffortArg = 'high';
         }
     }
-    const reasoningEffort = getReasoningEffort(resolvedModel, reasoningEffortArg);
-    // Build CLI path and args
+    const reasoningTargetModel = rawModel === 'opencode' || rawModel.startsWith('oc-')
+        ? rawModel
+        : (resolvedModel || rawModel);
+    const reasoningEffort = getReasoningEffort(reasoningTargetModel, reasoningEffortArg);
     let cliPath;
     let args;
     if (agent === 'codex') {
@@ -131,7 +159,7 @@ export function buildCliCommand(options) {
     }
     else if (agent === 'gemini') {
         cliPath = options.cliPaths.gemini;
-        args = ['-y', '--output-format', 'json'];
+        args = ['-y', '--output-format', 'stream-json'];
         if (options.session_id && typeof options.session_id === 'string') {
             args.push('-r', options.session_id);
         }
@@ -148,6 +176,17 @@ export function buildCliCommand(options) {
         }
         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/dist/cli-parse.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
-const AGENTS = ['claude', 'codex', 'gemini', 'forge'];
-const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge>
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
+const AGENTS = ['claude', 'codex', 'gemini', 'forge', 'opencode'];
+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
 `;
@@ -56,7 +59,7 @@ async function main() {
     }
     const agent = args.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);
     }
@@ -79,6 +82,9 @@ async function main() {
         case 'forge':
             parsed = parseForgeOutput(input);
             break;
+        case 'opencode':
+            parsed = parseOpenCodeOutput(input);
+            break;
     }
     process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
 }

package/dist/cli-process-service.js

@@ -1,11 +1,12 @@
 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, 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 } 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, } from './peek.js';
 function resolveDefaultStateDir() {
     return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
 }
@@ -27,6 +28,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 +59,7 @@ export class CliProcessService {
             codex: findCodexCli(),
             gemini: findGeminiCli(),
             forge: findForgeCli(),
+            opencode: findOpencodeCli(),
         };
         mkdirSync(this.stateDir, { recursive: true });
     }
@@ -50,6 +73,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 +145,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,
@@ -163,6 +175,79 @@ export class CliProcessService {
             await new Promise((resolve) => setTimeout(resolve, 50));
         }
     }
+    async peekProcesses(pids, peekTimeSec = 10) {
+        const targetPids = validatePeekPids(pids);
+        const targetPeekTimeSec = validatePeekTimeSec(peekTimeSec);
+        const processes = [];
+        const observers = [];
+        for (const pid of targetPids) {
+            let process;
+            try {
+                process = this.refreshStatus(this.readProcess(pid));
+            }
+            catch {
+                processes.push(buildNotFoundPeekProcess(pid));
+                continue;
+            }
+            const result = {
+                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) {
         const process = this.readProcess(pid);
         const refreshed = this.refreshStatus(process);
@@ -209,6 +294,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,18 +374,75 @@ 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 '';
         }
         return readFileSync(filePath, 'utf-8');
     }
+    fileSizeSafe(filePath) {
+        if (!existsSync(filePath)) {
+            return 0;
+        }
+        return statSync(filePath).size;
+    }
+    readTextFromOffset(filePath, offset) {
+        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);
+        }
+    }
     resolveCwdsDir() {
         return join(this.stateDir, 'cwds');
     }
@@ -282,12 +467,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;