ai-cli-mcp 2.14.1 → 2.16.0

package/dist/__tests__/cli-bin-smoke.test.js

@@ -19,6 +19,44 @@ afterEach(() => {
         rmSync(dir, { recursive: true, force: true });
     }
 });
+describe('cli helper entrypoint smoke', () => {
+    it('prints help for cli.run with OpenCode examples', () => {
+        const output = execFileSync('node', ['--import', 'tsx', 'src/cli.ts', '--help'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            env: process.env,
+        });
+        expect(output).toContain('Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]');
+        expect(output).toContain('opencode');
+        expect(output).toContain('oc-openai/gpt-5.4');
+        expect(output).toContain('OpenCode');
+        expect(output).toContain('npm run -s cli.run.parse -- --agent opencode < raw.txt');
+    });
+    it('prints help for cli.run.parse with OpenCode agent support', () => {
+        const output = execFileSync('node', ['--import', 'tsx', 'src/cli-parse.ts', '--help'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            env: process.env,
+        });
+        expect(output).toContain('Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge|opencode>');
+        expect(output).toContain('Agent type: claude, codex, gemini, forge, or opencode');
+        expect(output).toContain('npm run -s cli.run.parse -- --agent opencode < raw.txt');
+    });
+    it('parses OpenCode NDJSON through cli.run.parse', () => {
+        const output = execFileSync('node', ['--import', 'tsx', 'src/cli-parse.ts', '--agent', 'opencode'], {
+            cwd: process.cwd(),
+            encoding: 'utf8',
+            env: process.env,
+            input: '{"type":"step_start","sessionID":"ses_cli_parse"}\n{"type":"text","sessionID":"ses_cli_parse","part":{"type":"text","text":"Hello from cli.parse"}}\n{"type":"step_finish","sessionID":"ses_cli_parse","part":{"type":"step-finish","tokens":{"total":9},"cost":1}}\n',
+        });
+        expect(JSON.parse(output)).toEqual({
+            message: 'Hello from cli.parse',
+            session_id: 'ses_cli_parse',
+            tokens: { total: 9 },
+            cost: 1,
+        });
+    });
+});
 describe('ai-cli entrypoint smoke', () => {
     it('prints doctor output for the ai-cli entrypoint', () => {
         const fakeBinDir = makeTempDir('ai-cli-bin-');
@@ -26,6 +64,7 @@ describe('ai-cli entrypoint smoke', () => {
         writeExecutable(fakeBinDir, 'codex');
         writeExecutable(fakeBinDir, 'gemini');
         writeExecutable(fakeBinDir, 'forge');
+        writeExecutable(fakeBinDir, 'opencode');
         const output = execFileSync('node', ['--import', 'tsx', 'src/bin/ai-cli.ts', 'doctor'], {
             cwd: process.cwd(),
             encoding: 'utf8',
@@ -36,12 +75,14 @@ describe('ai-cli entrypoint smoke', () => {
                 CODEX_CLI_NAME: 'codex',
                 GEMINI_CLI_NAME: 'gemini',
                 FORGE_CLI_NAME: 'forge',
+                OPENCODE_CLI_NAME: 'opencode',
             },
         });
         expect(output).toContain('"claude"');
         expect(output).toContain('"codex"');
         expect(output).toContain('"gemini"');
         expect(output).toContain('"forge"');
+        expect(output).toContain('"opencode"');
         expect(output).toContain('"available": true');
     });
     it('prints run help for the ai-cli entrypoint', () => {
@@ -54,5 +95,7 @@ describe('ai-cli entrypoint smoke', () => {
         expect(output).toContain('--model <model>');
         expect(output).toContain('claude-ultra');
         expect(output).toContain('forge');
+        expect(output).toContain('opencode');
+        expect(output).toContain('oc-openai/gpt-5.4');
     });
 });

package/dist/__tests__/cli-builder.test.js

@@ -15,6 +15,7 @@ const DEFAULT_CLI_PATHS = {
     codex: '/usr/bin/codex',
     gemini: '/usr/bin/gemini',
     forge: '/usr/bin/forge',
+    opencode: '/usr/bin/opencode',
 };
 describe('cli-builder', () => {
     beforeEach(() => {
@@ -74,6 +75,10 @@ describe('cli-builder', () => {
         it('should reject reasoning_effort for forge explicitly', () => {
             expect(() => getReasoningEffort('forge', 'high')).toThrow('reasoning_effort is not supported for forge.');
         });
+        it('should reject reasoning_effort for opencode explicitly', () => {
+            expect(() => getReasoningEffort('opencode', 'high')).toThrow('reasoning_effort is not supported for opencode.');
+            expect(() => getReasoningEffort('oc-openai/gpt-5.4', 'high')).toThrow('reasoning_effort is not supported for opencode.');
+        });
     });
     describe('buildCliCommand', () => {
         describe('validation', () => {
@@ -300,7 +305,7 @@ describe('cli-builder', () => {
                 expect(cmd.cliPath).toBe('/usr/bin/gemini');
                 expect(cmd.args).toContain('-y');
                 expect(cmd.args).toContain('--output-format');
-                expect(cmd.args).toContain('json');
+                expect(cmd.args).toContain('stream-json');
                 expect(cmd.args).toContain('--model');
                 expect(cmd.args).toContain('gemini-2.5-pro');
             });
@@ -326,37 +331,110 @@ describe('cli-builder', () => {
                 expect(cmd.resolvedModel).toBe('gemini-3.1-pro-preview');
             });
         });
-        describe('forge agent', () => {
-            it('should build forge command without model flags', () => {
+        describe('opencode agent', () => {
+            it('should build default opencode command without --model', () => {
                 const cmd = buildCliCommand({
                     prompt: 'test',
                     workFolder: '/tmp',
-                    model: 'forge',
+                    model: 'opencode',
                     cliPaths: DEFAULT_CLI_PATHS,
                 });
-                expect(cmd.agent).toBe('forge');
-                expect(cmd.cliPath).toBe('/usr/bin/forge');
-                expect(cmd.resolvedModel).toBe('forge');
-                expect(cmd.args).toEqual(['-C', '/tmp', '-p', 'test']);
+                expect(cmd.agent).toBe('opencode');
+                expect(cmd.cliPath).toBe('/usr/bin/opencode');
+                expect(cmd.cwd).toBe('/tmp');
+                expect(cmd.args).toEqual(['run', '--format', 'json', '--dir', '/tmp', 'test']);
+                expect(cmd.args).not.toContain('--model');
             });
-            it('should map session_id to --conversation-id for forge', () => {
+            it('should route valid explicit OpenCode model syntax', () => {
                 const cmd = buildCliCommand({
                     prompt: 'test',
                     workFolder: '/tmp',
-                    model: 'forge',
-                    session_id: 'forge-conv-123',
+                    model: 'oc-openai/gpt-5.4',
                     cliPaths: DEFAULT_CLI_PATHS,
                 });
-                expect(cmd.args).toEqual(['-C', '/tmp', '--conversation-id', 'forge-conv-123', '-p', 'test']);
+                expect(cmd.agent).toBe('opencode');
+                expect(cmd.resolvedModel).toBe('oc-openai/gpt-5.4');
+                expect(cmd.args).toEqual([
+                    'run',
+                    '--format',
+                    'json',
+                    '--dir',
+                    '/tmp',
+                    '--model',
+                    'openai/gpt-5.4',
+                    'test',
+                ]);
+            });
+            it.each([
+                'oc-',
+                'oc-openai',
+                'oc-/gpt-5.4',
+                'oc-openai/',
+            ])('should reject invalid explicit OpenCode syntax: %s', (model) => {
+                expect(() => buildCliCommand({
+                    prompt: 'test',
+                    workFolder: '/tmp',
+                    model,
+                    cliPaths: DEFAULT_CLI_PATHS,
+                })).toThrow('Invalid OpenCode model. Expected exact syntax oc-<provider/model>.');
             });
-            it('should reject reasoning_effort for forge in command building', () => {
+            it.each([' oc-openai/gpt-5.4', 'oc-openai/gpt-5.4 '])('should reject explicit OpenCode models with surrounding whitespace: %s', (model) => {
                 expect(() => buildCliCommand({
                     prompt: 'test',
                     workFolder: '/tmp',
-                    model: 'forge',
+                    model,
+                    cliPaths: DEFAULT_CLI_PATHS,
+                })).toThrow('Invalid OpenCode model. Expected exact syntax oc-<provider/model>.');
+            });
+            it('should reject reasoning_effort for OpenCode in command building', () => {
+                expect(() => buildCliCommand({
+                    prompt: 'test',
+                    workFolder: '/tmp',
+                    model: 'opencode',
                     reasoning_effort: 'high',
                     cliPaths: DEFAULT_CLI_PATHS,
-                })).toThrow('reasoning_effort is not supported for forge.');
+                })).toThrow('reasoning_effort is not supported for opencode.');
+            });
+            it('should build resumed default OpenCode command', () => {
+                const cmd = buildCliCommand({
+                    prompt: 'resume prompt',
+                    workFolder: '/tmp',
+                    model: 'opencode',
+                    session_id: 'ses-123',
+                    cliPaths: DEFAULT_CLI_PATHS,
+                });
+                expect(cmd.args).toEqual([
+                    'run',
+                    '--format',
+                    'json',
+                    '--dir',
+                    '/tmp',
+                    '--session',
+                    'ses-123',
+                    'resume prompt',
+                ]);
+                expect(cmd.args).not.toContain('--model');
+            });
+            it('should build resumed explicit OpenCode command', () => {
+                const cmd = buildCliCommand({
+                    prompt: 'resume prompt',
+                    workFolder: '/tmp',
+                    model: 'oc-openai/gpt-5.4',
+                    session_id: 'ses-456',
+                    cliPaths: DEFAULT_CLI_PATHS,
+                });
+                expect(cmd.args).toEqual([
+                    'run',
+                    '--format',
+                    'json',
+                    '--dir',
+                    '/tmp',
+                    '--session',
+                    'ses-456',
+                    '--model',
+                    'openai/gpt-5.4',
+                    'resume prompt',
+                ]);
             });
         });
     });

package/dist/__tests__/cli-process-service.test.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { CliProcessService } from '../cli-process-service.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 function createMockCliScript(dir, name, options = {}) {
     const scriptPath = join(dir, name);
     writeFileSync(scriptPath, `#!/bin/bash
@@ -57,6 +58,7 @@ describe('CliProcessService', () => {
                 codex: scriptPath,
                 gemini: scriptPath,
                 forge: scriptPath,
+                opencode: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -105,6 +107,65 @@ describe('CliProcessService', () => {
         expect(result).not.toHaveProperty('prompt');
         expect(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
     });
+    it('peeks only appended natural-language messages from detached logs', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const scriptPath = join(root, 'mock-claude-peek');
+        writeFileSync(scriptPath, `#!/bin/bash
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"old cli message"}]}}'
+sleep 2
+printf '%s\n' '{"type":"assistant","message":{"content":[{"type":"text","text":"new cli message"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}'
+printf '%s\n' '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}'
+`);
+        chmodSync(scriptPath, 0o755);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'work');
+        mkdirSync(workFolder, { recursive: true });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: scriptPath,
+                codex: scriptPath,
+                gemini: scriptPath,
+                forge: scriptPath,
+                opencode: scriptPath,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'hello peek',
+            cwd: workFolder,
+        });
+        const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(runResult.pid));
+        const stdoutPath = join(processDir, 'stdout.log');
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < 5000 && !readFileSync(stdoutPath, 'utf-8').includes('old cli message')) {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        expect(readFileSync(stdoutPath, 'utf-8')).toContain('old cli message');
+        const peekResult = await service.peekProcesses([runResult.pid, runResult.pid, 999999], 3);
+        expect(peekResult.processes).toHaveLength(2);
+        expect(peekResult.processes[0]).toMatchObject({
+            pid: runResult.pid,
+            agent: 'claude',
+            status: 'completed',
+            messages: [
+                {
+                    ts: expect.any(String),
+                    text: 'new cli message',
+                },
+            ],
+            truncated: false,
+            error: null,
+        });
+        expect(peekResult.processes[1]).toEqual({
+            pid: 999999,
+            agent: null,
+            status: 'not_found',
+            messages: [],
+            truncated: false,
+            error: 'process not found',
+        });
+    });
     it('returns compact results by default and full results when verbose is true', async () => {
         const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
         tempDirs.push(root);
@@ -126,6 +187,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: scriptPath,
                 gemini: scriptPath,
                 forge: scriptPath,
+                opencode: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -229,6 +291,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: scriptPath,
                 gemini: scriptPath,
                 forge: scriptPath,
+                opencode: scriptPath,
             },
         });
         const runResult = await service.startProcess({
@@ -262,6 +325,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         writeFileSync(join(processDir, 'meta.json'), JSON.stringify({
@@ -321,6 +385,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
@@ -368,6 +433,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         const result = await service.cleanupProcesses();
@@ -429,6 +495,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
@@ -479,6 +546,7 @@ Forge assistant reply
                 codex: '/bin/sh',
                 gemini: '/bin/sh',
                 forge: '/bin/sh',
+                opencode: '/bin/sh',
             },
         });
         const result = await service.getProcessResult(pid, false);
@@ -489,4 +557,98 @@ Forge assistant reply
             session_id: 'forge-conv-1',
         });
     });
+    it('parses successful OpenCode detached runs from stdout only', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'opencode-project');
+        mkdirSync(workFolder, { recursive: true });
+        const argsLogPath = join(root, 'opencode-args.log');
+        const { scriptPath } = createOpenCodeMock(root, { argsLogPath });
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+                opencode: scriptPath,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'hello opencode',
+            cwd: workFolder,
+            model: 'opencode',
+        });
+        const waited = await service.waitForProcesses([runResult.pid], 5);
+        expect(waited).toHaveLength(1);
+        expect(waited[0]).toMatchObject({
+            pid: runResult.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'opencode',
+            session_id: 'ses-opencode-default',
+            agentOutput: {
+                message: 'Initial: hello opencode',
+                session_id: 'ses-opencode-default',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        expect(waited[0]).not.toHaveProperty('stdout');
+        expect(waited[0]).not.toHaveProperty('stderr');
+        expect(readFileSync(argsLogPath, 'utf8')).toContain(`--dir ${workFolder}`);
+    });
+    it('preserves raw stdout and stderr for failed detached OpenCode runs', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+        tempDirs.push(root);
+        const stateDir = join(root, 'state');
+        const workFolder = join(root, 'opencode-fail-project');
+        mkdirSync(workFolder, { recursive: true });
+        const { scriptPath } = createOpenCodeMock(root);
+        const service = new CliProcessService({
+            stateDir,
+            cliPaths: {
+                claude: '/bin/sh',
+                codex: '/bin/sh',
+                gemini: '/bin/sh',
+                forge: '/bin/sh',
+                opencode: scriptPath,
+            },
+        });
+        const runResult = await service.startProcess({
+            prompt: 'please fail',
+            cwd: workFolder,
+            model: 'oc-openai/gpt-5.4',
+        });
+        const [compactResult] = await service.waitForProcesses([runResult.pid], 5);
+        expect(compactResult).toMatchObject({
+            pid: runResult.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-default',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+        });
+        expect(compactResult).not.toHaveProperty('agentOutput');
+        const verboseResult = await service.getProcessResult(runResult.pid, true);
+        expect(verboseResult).toMatchObject({
+            pid: runResult.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            session_id: 'ses-opencode-default',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+            agentOutput: {
+                message: 'Partial failure output',
+                session_id: 'ses-opencode-default',
+                tokens: { total: 42 },
+                cost: 0,
+            },
+        });
+    });
 });

package/dist/__tests__/cli-utils.test.js

@@ -16,6 +16,7 @@ describe('cli-utils doctor status', () => {
         delete process.env.CODEX_CLI_NAME;
         delete process.env.GEMINI_CLI_NAME;
         delete process.env.FORGE_CLI_NAME;
+        delete process.env.OPENCODE_CLI_NAME;
         process.env.PATH = '/mock/bin:/usr/bin';
     });
     afterEach(() => {
@@ -43,6 +44,12 @@ describe('cli-utils doctor status', () => {
             available: false,
             lookup: 'path',
         });
+        expect(status.opencode).toEqual({
+            configuredCommand: 'opencode',
+            resolvedPath: null,
+            available: false,
+            lookup: 'path',
+        });
     });
     it('does not mark non-executable PATH entries as available', async () => {
         mockAccessSync.mockImplementation(() => {
@@ -62,6 +69,12 @@ describe('cli-utils doctor status', () => {
             available: false,
             lookup: 'path',
         });
+        expect(status.opencode).toEqual({
+            configuredCommand: 'opencode',
+            resolvedPath: null,
+            available: false,
+            lookup: 'path',
+        });
     });
     it('reports invalid relative env paths as doctor errors', async () => {
         process.env.CLAUDE_CLI_NAME = './relative/claude';
@@ -137,4 +150,22 @@ describe('cli-utils doctor status', () => {
         });
         expect(findForgeCli()).toBe('forge-custom');
     });
+    it('supports OpenCode lookup via OPENCODE_CLI_NAME', async () => {
+        process.env.OPENCODE_CLI_NAME = 'opencode-custom';
+        mockAccessSync.mockImplementation((filePath) => {
+            if (filePath === '/mock/bin/opencode-custom') {
+                return undefined;
+            }
+            throw new Error('not executable');
+        });
+        const { getCliDoctorStatus, findOpencodeCli } = await import('../cli-utils.js');
+        const status = getCliDoctorStatus();
+        expect(status.opencode).toEqual({
+            configuredCommand: 'opencode-custom',
+            resolvedPath: '/mock/bin/opencode-custom',
+            available: true,
+            lookup: 'env',
+        });
+        expect(findOpencodeCli()).toBe('opencode-custom');
+    });
 });