ai-cli-mcp 2.14.1 → 2.15.0

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({
@@ -126,6 +128,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 +232,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 +266,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 +326,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 +374,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 +436,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 +487,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 +498,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');
+    });
 });

package/dist/__tests__/e2e.test.js

@@ -1,9 +1,10 @@
 import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { createTestClient } from './utils/mcp-client.js';
 import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 describe('Claude Code MCP E2E Tests', () => {
     let client;
     let testDir;
@@ -30,40 +31,10 @@ describe('Claude Code MCP E2E Tests', () => {
             const tools = await client.listTools();
             expect(tools).toHaveLength(6);
             const claudeCodeTool = tools.find((t) => t.name === 'run');
-            expect(claudeCodeTool).toEqual({
-                name: 'run',
-                description: expect.stringContaining('AI Agent Runner'),
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        prompt: {
-                            type: 'string',
-                            description: expect.stringContaining('Either this or prompt_file is required'),
-                        },
-                        prompt_file: {
-                            type: 'string',
-                            description: expect.stringContaining('Path to a file containing the prompt'),
-                        },
-                        workFolder: {
-                            type: 'string',
-                            description: expect.stringContaining('working directory'),
-                        },
-                        model: {
-                            type: 'string',
-                            description: expect.stringContaining('sonnet'),
-                        },
-                        reasoning_effort: {
-                            type: 'string',
-                            description: expect.stringContaining('model_reasoning_effort'),
-                        },
-                        session_id: {
-                            type: 'string',
-                            description: expect.stringContaining('session ID'),
-                        },
-                    },
-                    required: ['workFolder'],
-                },
-            });
+            expect(claudeCodeTool.inputSchema.properties.model.description).toContain('sonnet');
+            expect(claudeCodeTool.inputSchema.properties.model.description).toContain('opencode');
+            expect(claudeCodeTool.inputSchema.properties.model.description).toContain('oc-<provider/model>');
+            expect(claudeCodeTool.inputSchema.properties.reasoning_effort.description).toContain('OpenCode');
             // Verify other tools exist
             expect(tools.some((t) => t.name === 'list_processes')).toBe(true);
             expect(tools.some((t) => t.name === 'get_result')).toBe(true);
@@ -180,6 +151,70 @@ describe('Claude Code MCP E2E Tests', () => {
                 }]);
         });
     });
+    describe('OpenCode flows', () => {
+        it('should execute and resume OpenCode runs through the MCP client', async () => {
+            await client.disconnect();
+            const opencodeArgsLogPath = join(testDir, 'opencode-args.log');
+            const { scriptPath } = createOpenCodeMock(testDir, {
+                argsLogPath: opencodeArgsLogPath,
+                defaultSessionId: 'ses-opencode-e2e',
+            });
+            client = createTestClient({
+                debug: false,
+                env: {
+                    OPENCODE_CLI_NAME: scriptPath,
+                },
+            });
+            await client.connect();
+            const runResponse = await client.callTool('run', {
+                prompt: 'e2e OpenCode initial prompt',
+                workFolder: testDir,
+                model: 'opencode',
+            });
+            const runData = JSON.parse(runResponse[0].text);
+            expect(runData.agent).toBe('opencode');
+            const initialWait = JSON.parse((await client.callTool('wait', { pids: [runData.pid], timeout: 5 }))[0].text);
+            expect(initialWait).toHaveLength(1);
+            expect(initialWait[0]).toMatchObject({
+                pid: runData.pid,
+                agent: 'opencode',
+                status: 'completed',
+                exitCode: 0,
+                model: 'opencode',
+                session_id: 'ses-opencode-e2e',
+                agentOutput: {
+                    message: 'Initial: e2e OpenCode initial prompt',
+                    session_id: 'ses-opencode-e2e',
+                },
+            });
+            const resumedResponse = await client.callTool('run', {
+                prompt: 'e2e OpenCode resumed prompt',
+                workFolder: testDir,
+                model: 'oc-openai/gpt-5.4',
+                session_id: 'ses-opencode-e2e',
+            });
+            const resumedRunData = JSON.parse(resumedResponse[0].text);
+            const resumedWait = JSON.parse((await client.callTool('wait', { pids: [resumedRunData.pid], timeout: 5 }))[0].text);
+            expect(resumedWait).toHaveLength(1);
+            expect(resumedWait[0]).toMatchObject({
+                pid: resumedRunData.pid,
+                agent: 'opencode',
+                status: 'completed',
+                exitCode: 0,
+                model: 'oc-openai/gpt-5.4',
+                session_id: 'ses-opencode-e2e',
+                agentOutput: {
+                    message: 'Resumed model openai/gpt-5.4: e2e OpenCode resumed prompt',
+                    session_id: 'ses-opencode-e2e',
+                },
+            });
+            const invocationLog = readFileSync(opencodeArgsLogPath, 'utf-8').trim().split('\n');
+            expect(invocationLog[0]).toContain(`--dir ${testDir}`);
+            expect(invocationLog[0]).not.toContain('--model');
+            expect(invocationLog[1]).toContain('--session ses-opencode-e2e');
+            expect(invocationLog[1]).toContain('--model openai/gpt-5.4');
+        });
+    });
     describe('Debug Mode', () => {
         it('should log debug information when enabled', async () => {
             // Debug logs go to stderr, which we capture in the client
@@ -205,25 +240,16 @@ describe('Integration Tests (Local Only)', () => {
         }
         rmSync(testDir, { recursive: true, force: true });
     });
-    // These tests will only run locally when Claude is available
-    it.skip('should create a file with real Claude CLI', async () => {
-        await client.connect();
-        const response = await client.callTool('run', {
-            prompt: 'Create a file called hello.txt with content "Hello from Claude"',
-            workFolder: testDir,
-        });
-        const filePath = join(testDir, 'hello.txt');
-        expect(existsSync(filePath)).toBe(true);
-        expect(readFileSync(filePath, 'utf-8')).toContain('Hello from Claude');
-    });
-    it.skip('should handle git operations with real Claude CLI', async () => {
+    // This smoke test only verifies that a real Claude CLI can be invoked.
+    it.skip('should invoke the real Claude CLI', async () => {
         await client.connect();
-        // Initialize git repo
         const response = await client.callTool('run', {
-            prompt: 'Initialize a git repository and create a README.md file',
+            prompt: 'Reply with hi',
             workFolder: testDir,
         });
-        expect(existsSync(join(testDir, '.git'))).toBe(true);
-        expect(existsSync(join(testDir, 'README.md'))).toBe(true);
+        expect(response).toEqual([{
+                type: 'text',
+                text: expect.stringContaining('pid'),
+            }]);
     });
 });

package/dist/__tests__/mcp-contract.test.js

@@ -3,6 +3,7 @@ import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'nod
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { cleanupSharedMock, getSharedMock } from './utils/persistent-mock.js';
+import { createOpenCodeMock } from './utils/opencode-mock.js';
 import { createTestClient } from './utils/mcp-client.js';
 function parseToolJson(content) {
     expect(content).toHaveLength(1);
@@ -96,6 +97,11 @@ describe('MCP Contract Tests', () => {
             'session_id',
             'workFolder',
         ]);
+        expect(runTool.description).toContain('OpenCode');
+        expect(runTool.inputSchema.properties.model.description).toContain('opencode');
+        expect(runTool.inputSchema.properties.model.description).toContain('oc-<provider/model>');
+        expect(runTool.inputSchema.properties.reasoning_effort.description).toContain('OpenCode do not support reasoning_effort');
+        expect(runTool.inputSchema.properties.session_id.description).toBe('Optional session ID to resume a previous session. Supported for Claude, Codex, Gemini, Forge, and OpenCode. OpenCode resumes in-place via --session and may also be combined with explicit oc-<provider/model> selection.');
         const getResultTool = tools.find((tool) => tool.name === 'get_result');
         expect(getResultTool.inputSchema.required).toEqual(['pid']);
         expect(Object.keys(getResultTool.inputSchema.properties).sort()).toEqual([
@@ -407,6 +413,154 @@ printf '%s\n' '{"type":"system","session_id":"session-verbose-1"}'
             reasoning_effort: 'high',
         })).rejects.toThrow(/reasoning_effort is not supported for forge/i);
     });
+    it('covers OpenCode end-to-end through the MCP process path', async () => {
+        await client.disconnect();
+        const opencodeArgsLogPath = join(testDir, 'opencode-args.log');
+        const { scriptPath: openCodeMockPath } = createOpenCodeMock(testDir, {
+            argsLogPath: opencodeArgsLogPath,
+            defaultSessionId: 'ses-opencode-contract',
+        });
+        client = createTestClient({
+            debug: false,
+            env: {
+                OPENCODE_CLI_NAME: openCodeMockPath,
+            },
+        });
+        await client.connect();
+        const initialRunResponse = await client.callTool('run', {
+            prompt: 'opencode-initial-prompt',
+            workFolder: testDir,
+            model: 'opencode',
+        });
+        const initialRunData = parseToolJson(initialRunResponse);
+        expect(initialRunData).toEqual({
+            pid: expect.any(Number),
+            status: 'started',
+            agent: 'opencode',
+            message: expect.any(String),
+        });
+        const initialWaitResponse = await client.callTool('wait', { pids: [initialRunData.pid], timeout: 5 });
+        const initialWaitData = parseToolJson(initialWaitResponse);
+        expect(initialWaitData).toHaveLength(1);
+        expect(initialWaitData[0]).toMatchObject({
+            pid: initialRunData.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'opencode',
+            session_id: 'ses-opencode-contract',
+            agentOutput: {
+                message: 'Initial: opencode-initial-prompt',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        const resumedDefaultRunResponse = await client.callTool('run', {
+            prompt: 'opencode-resume-default',
+            workFolder: testDir,
+            model: 'opencode',
+            session_id: 'ses-opencode-contract',
+        });
+        const resumedDefaultRunData = parseToolJson(resumedDefaultRunResponse);
+        const resumedDefaultWaitResponse = await client.callTool('wait', { pids: [resumedDefaultRunData.pid], timeout: 5 });
+        const resumedDefaultWaitData = parseToolJson(resumedDefaultWaitResponse);
+        expect(resumedDefaultWaitData).toHaveLength(1);
+        expect(resumedDefaultWaitData[0]).toMatchObject({
+            pid: resumedDefaultRunData.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'opencode',
+            session_id: 'ses-opencode-contract',
+            agentOutput: {
+                message: 'Resumed: opencode-resume-default',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        const resumedExplicitRunResponse = await client.callTool('run', {
+            prompt: 'opencode-resume-explicit',
+            workFolder: testDir,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+        });
+        const resumedExplicitRunData = parseToolJson(resumedExplicitRunResponse);
+        const resumedExplicitWaitResponse = await client.callTool('wait', { pids: [resumedExplicitRunData.pid], timeout: 5 });
+        const resumedExplicitWaitData = parseToolJson(resumedExplicitWaitResponse);
+        expect(resumedExplicitWaitData).toHaveLength(1);
+        expect(resumedExplicitWaitData[0]).toMatchObject({
+            pid: resumedExplicitRunData.pid,
+            agent: 'opencode',
+            status: 'completed',
+            exitCode: 0,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+            agentOutput: {
+                message: 'Resumed model openai/gpt-5.4: opencode-resume-explicit',
+                session_id: 'ses-opencode-contract',
+                tokens: { total: 11833 },
+                cost: 0,
+            },
+        });
+        const failedRunResponse = await client.callTool('run', {
+            prompt: 'please fail',
+            workFolder: testDir,
+            model: 'oc-openai/gpt-5.4',
+        });
+        const failedRunData = parseToolJson(failedRunResponse);
+        const compactFailedWait = parseToolJson(await client.callTool('wait', { pids: [failedRunData.pid], timeout: 5 }));
+        expect(compactFailedWait).toHaveLength(1);
+        expect(compactFailedWait[0]).toMatchObject({
+            pid: failedRunData.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+            stdout: expect.stringContaining('Partial failure output'),
+            stderr: expect.stringContaining('OpenCode failed for openai/gpt-5.4'),
+        });
+        expect(compactFailedWait[0]).not.toHaveProperty('agentOutput');
+        const verboseFailedResult = parseToolJson(await client.callTool('get_result', { pid: failedRunData.pid, verbose: true }));
+        expect(verboseFailedResult).toMatchObject({
+            pid: failedRunData.pid,
+            agent: 'opencode',
+            status: 'failed',
+            exitCode: 7,
+            model: 'oc-openai/gpt-5.4',
+            session_id: 'ses-opencode-contract',
+            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-contract',
+                tokens: { total: 42 },
+                cost: 0,
+            },
+        });
+        const openCodeInvocations = readFileSync(opencodeArgsLogPath, 'utf-8').trim().split('\n');
+        expect(openCodeInvocations).toHaveLength(4);
+        expect(openCodeInvocations[0]).toContain('run --format json');
+        expect(openCodeInvocations[0]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[0]).not.toContain('--session');
+        expect(openCodeInvocations[0]).not.toContain('--model');
+        expect(openCodeInvocations[1]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[1]).toContain('--session ses-opencode-contract');
+        expect(openCodeInvocations[1]).not.toContain('--model');
+        expect(openCodeInvocations[2]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[2]).toContain('--session ses-opencode-contract');
+        expect(openCodeInvocations[2]).toContain('--model openai/gpt-5.4');
+        expect(openCodeInvocations[3]).toContain(`--dir ${testDir}`);
+        expect(openCodeInvocations[3]).toContain('--model openai/gpt-5.4');
+        await expect(client.callTool('run', {
+            prompt: 'opencode-invalid-reasoning',
+            workFolder: testDir,
+            model: 'opencode',
+            reasoning_effort: 'high',
+        })).rejects.toThrow(/reasoning_effort is not supported for opencode/i);
+    });
     it('keeps key invalid-input errors stable', async () => {
         await expect(client.callTool('run', {
             prompt: 'missing workFolder',

package/dist/__tests__/parsers.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { parseCodexOutput, parseClaudeOutput, parseForgeOutput } from '../parsers.js';
+import { parseCodexOutput, parseClaudeOutput, parseForgeOutput, parseOpenCodeOutput } from '../parsers.js';
 describe('parseCodexOutput', () => {
     it('should parse basic Codex output with message and session_id', () => {
         const output = `
@@ -132,3 +132,64 @@ still streaming`;
         expect(parseForgeOutput('plain text')).toBeNull();
     });
 });
+describe('parseOpenCodeOutput', () => {
+    it('parses a single completed OpenCode step', () => {
+        const output = `{"type":"step_start","sessionID":"ses_1"}
+{"type":"text","sessionID":"ses_1","part":{"type":"text","text":"Hello"}}
+{"type":"step_finish","sessionID":"ses_1","part":{"type":"step-finish","tokens":{"total":11833},"cost":0}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Hello',
+            session_id: 'ses_1',
+            tokens: { total: 11833 },
+            cost: 0,
+        });
+    });
+    it('returns the last completed step for multi-step output', () => {
+        const output = `{"type":"step_start","sessionID":"ses_2"}
+{"type":"text","sessionID":"ses_2","part":{"type":"text","text":"First"}}
+{"type":"step_finish","sessionID":"ses_2","part":{"type":"step-finish","tokens":{"total":10},"cost":0}}
+{"type":"step_start","sessionID":"ses_2"}
+{"type":"text","sessionID":"ses_2","part":{"type":"text","text":"Second"}}
+{"type":"step_finish","sessionID":"ses_2","part":{"type":"step-finish","tokens":{"total":20},"cost":1}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Second',
+            session_id: 'ses_2',
+            tokens: { total: 20 },
+            cost: 1,
+        });
+    });
+    it('resets the current-step buffer on each step_start', () => {
+        const output = `{"type":"step_start","sessionID":"ses_3"}
+{"type":"text","sessionID":"ses_3","part":{"type":"text","text":"Discard me"}}
+{"type":"step_start","sessionID":"ses_3"}
+{"type":"text","sessionID":"ses_3","part":{"type":"text","text":"Keep me"}}
+{"type":"step_finish","sessionID":"ses_3","part":{"type":"step-finish","tokens":{"total":5},"cost":0}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Keep me',
+            session_id: 'ses_3',
+            tokens: { total: 5 },
+            cost: 0,
+        });
+    });
+    it('returns partial output when text exists without step_finish', () => {
+        const output = `{"type":"step_start","sessionID":"ses_4"}
+{"type":"text","sessionID":"ses_4","part":{"type":"text","text":"Partial"}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Partial',
+            session_id: 'ses_4',
+        });
+    });
+    it('ignores malformed lines and unknown event types', () => {
+        const output = `not-json
+{"type":"unknown","sessionID":"ses_5"}
+{"type":"text","sessionID":"ses_5","part":{"type":"text","text":"Hello"}}`;
+        expect(parseOpenCodeOutput(output)).toEqual({
+            message: 'Hello',
+            session_id: 'ses_5',
+        });
+    });
+    it('returns null when no useful OpenCode events exist', () => {
+        expect(parseOpenCodeOutput('{"type":"unknown"}')).toBeNull();
+        expect(parseOpenCodeOutput('')).toBeNull();
+    });
+});

package/dist/__tests__/process-management.test.js

@@ -60,7 +60,7 @@ describe('Process Management Tests', () => {
     });
     async function setupServer() {
         const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
-        vi.mocked(Server).mockImplementation(() => {
+        vi.mocked(Server).mockImplementation(function () {
             mockServerInstance = {
                 setRequestHandler: vi.fn((schema, handler) => {
                     handlers.set(schema.name, handler);