ai-cli-mcp 2.14.1 → 2.16.0

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;
@@ -28,45 +29,16 @@ describe('Claude Code MCP E2E Tests', () => {
     describe('Tool Registration', () => {
         it('should register run tool', async () => {
             const tools = await client.listTools();
-            expect(tools).toHaveLength(6);
+            expect(tools).toHaveLength(7);
             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);
+            expect(tools.some((t) => t.name === 'peek')).toBe(true);
             expect(tools.some((t) => t.name === 'kill_process')).toBe(true);
         });
     });
@@ -180,6 +152,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 +241,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);
@@ -83,6 +84,7 @@ describe('MCP Contract Tests', () => {
             'get_result',
             'kill_process',
             'list_processes',
+            'peek',
             'run',
             'wait',
         ]);
@@ -96,6 +98,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([
@@ -109,6 +116,13 @@ describe('MCP Contract Tests', () => {
             'timeout',
             'verbose',
         ]);
+        const peekTool = tools.find((tool) => tool.name === 'peek');
+        expect(peekTool.inputSchema.required).toEqual(['pids']);
+        expect(Object.keys(peekTool.inputSchema.properties).sort()).toEqual([
+            'peek_time_sec',
+            'pids',
+        ]);
+        expect(peekTool.description).toContain('One-shot');
     });
     it('preserves the stdio MCP smoke flow and response shapes', async () => {
         const runResponse = await client.callTool('run', {
@@ -407,6 +421,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, parseGeminiOutput, parseOpenCodeOutput, PeekMessageExtractor } from '../parsers.js';
 describe('parseCodexOutput', () => {
     it('should parse basic Codex output with message and session_id', () => {
         const output = `
@@ -58,6 +58,168 @@ INVALID_JSON
         expect(result.message).toBe("Still parses valid lines");
     });
 });
+describe('PeekMessageExtractor', () => {
+    const ts = '2026-04-11T12:34:56.789Z';
+    it('extracts only Codex agent_message text', () => {
+        const extractor = new PeekMessageExtractor('codex');
+        const output = [
+            '{"type":"item.completed","item":{"type":"reasoning","text":"hidden"}}',
+            '{"type":"item.completed","item":{"type":"command_execution","aggregated_output":"secret command output"}}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"Visible Codex message"}}',
+            '{"msg":{"type":"token_count","total":123}}',
+            '{"msg":{"type":"agent_message","message":"Visible legacy Codex message"}}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { ts, text: 'Visible Codex message' },
+            { ts, text: 'Visible legacy Codex message' },
+        ]);
+    });
+    it('extracts only Claude assistant text content', () => {
+        const extractor = new PeekMessageExtractor('claude');
+        const output = [
+            '{"type":"assistant","message":{"content":[{"type":"text","text":"Visible Claude text"},{"type":"tool_use","id":"tool-1","name":"Read","input":{"file_path":"/tmp/a"}}]}}',
+            '{"type":"user","message":{"content":[{"type":"tool_result","tool_use_id":"tool-1","content":"secret"}]}}',
+            '{"type":"result","result":"Final result is not peek assistant text"}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { ts, text: 'Visible Claude text' },
+        ]);
+    });
+    it('extracts only Gemini assistant message content', () => {
+        const extractor = new PeekMessageExtractor('gemini');
+        const output = [
+            '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+            '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Visible Gemini text","delta":true}',
+            '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+            '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+            '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result is not peek assistant text"}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { ts, text: 'Visible Gemini text' },
+        ]);
+    });
+    it('joins split Gemini assistant chunks into one peek message on flush', () => {
+        const extractor = new PeekMessageExtractor('gemini');
+        const output = [
+            '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Step 2 done. Starting step ","delta":true}',
+            '{"type":"message","timestamp":"2026-04-11T14:44:53.821Z","role":"assistant","content":"3.","delta":true}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([]);
+        expect(extractor.flush('2026-04-11T12:34:59.000Z')).toEqual([
+            { ts: '2026-04-11T12:34:59.000Z', text: 'Step 2 done. Starting step 3.' },
+        ]);
+    });
+    it('emits separate Gemini peek messages when a boundary separates logical messages', () => {
+        const extractor = new PeekMessageExtractor('gemini');
+        const output = [
+            '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Starting step ","delta":true}',
+            '{"type":"message","timestamp":"2026-04-11T14:44:53.821Z","role":"assistant","content":"1.","delta":true}',
+            '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.822Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+            '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+            '{"type":"message","timestamp":"2026-04-11T14:45:10.315Z","role":"assistant","content":"Final ","delta":true}',
+            '{"type":"message","timestamp":"2026-04-11T14:45:10.316Z","role":"assistant","content":"answer.","delta":true}',
+            '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result response is not peek text","stats":{"total_tokens":21999}}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { ts, text: 'Starting step 1.' },
+            { ts, text: 'Final answer.' },
+        ]);
+        expect(extractor.flush(ts)).toEqual([]);
+    });
+    it('does not emit Gemini user, tool, tool result, stats, or result response text', () => {
+        const extractor = new PeekMessageExtractor('gemini');
+        const output = [
+            '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+            '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","parameters":{"command":"echo secret"}}',
+            '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","status":"success","output":"secret command output"}',
+            '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Final result response is not peek text","stats":{"total_tokens":21999}}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([]);
+        expect(extractor.flush(ts)).toEqual([]);
+    });
+    it('denies unsupported agents and invalid shapes by default', () => {
+        const extractor = new PeekMessageExtractor('forge');
+        const output = [
+            '{"type":"assistant","message":{"content":[{"type":"text","text":"not supported here"}]}}',
+            '{"type":"item.completed","item":{"type":"agent_message","text":"not supported here"}}',
+            '{"type":"text","part":{"type":"text","text":"not supported here"}}',
+            '{"type":"message","role":"assistant","content":"not supported here"}',
+            'plain stdout',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([]);
+    });
+    it('extracts only OpenCode natural-language text events', () => {
+        const extractor = new PeekMessageExtractor('opencode');
+        const output = [
+            '{"type":"text","timestamp":1775918783605,"sessionID":"ses-1","part":{"type":"text","text":"OpenCode visible text"}}',
+            '{"type":"tool_use","timestamp":1775918783606,"sessionID":"ses-1","part":{"type":"tool","state":{"output":"secret command output"},"metadata":{"output":"secret metadata output"}}}',
+            '{"type":"text","timestamp":1775918783607,"sessionID":"ses-1","part":{"type":"tool","text":"wrong part type"}}',
+        ].join('\n') + '\n';
+        expect(extractor.push(output, ts)).toEqual([
+            { ts, text: 'OpenCode visible text' },
+        ]);
+    });
+    it('can flush a complete JSON event without a trailing newline', () => {
+        const extractor = new PeekMessageExtractor('codex');
+        expect(extractor.push('{"type":"item.completed","item":{"type":"agent_message","text":"pending"}}', ts)).toEqual([]);
+        expect(extractor.flush(ts)).toEqual([{ ts, text: 'pending' }]);
+    });
+});
+describe('parseGeminiOutput', () => {
+    it('should parse legacy final JSON output', () => {
+        const output = JSON.stringify({
+            session_id: 'gemini-session-json',
+            response: 'Legacy Gemini final response',
+            stats: {
+                total_tokens: 123,
+            },
+        });
+        expect(parseGeminiOutput(output)).toEqual({
+            session_id: 'gemini-session-json',
+            response: 'Legacy Gemini final response',
+            stats: {
+                total_tokens: 123,
+            },
+        });
+    });
+    it('should normalize a single-line Gemini assistant stream event', () => {
+        const output = '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"Only answer","delta":true}';
+        const result = parseGeminiOutput(output);
+        expect(result).toMatchObject({
+            message: 'Only answer',
+            session_id: null,
+        });
+        expect(result).not.toHaveProperty('type');
+        expect(result).not.toHaveProperty('content');
+    });
+    it('should parse Gemini stream-json NDJSON output', () => {
+        const output = [
+            '{"type":"init","timestamp":"2026-04-11T14:44:42.293Z","session_id":"gemini-session-stream","model":"gemini-3.1-pro-preview"}',
+            '{"type":"message","timestamp":"2026-04-11T14:44:42.294Z","role":"user","content":"hidden user text"}',
+            '{"type":"message","timestamp":"2026-04-11T14:44:53.820Z","role":"assistant","content":"First logical assistant response.","delta":true}',
+            '{"type":"tool_use","timestamp":"2026-04-11T14:44:53.821Z","tool_name":"run_shell_command","tool_id":"tool-1","parameters":{"command":"echo hidden"}}',
+            '{"type":"tool_result","timestamp":"2026-04-11T14:45:03.011Z","tool_id":"tool-1","status":"success","output":"hidden command output"}',
+            '{"type":"message","timestamp":"2026-04-11T14:45:10.315Z","role":"assistant","content":"Final assistant ","delta":true}',
+            '{"type":"message","timestamp":"2026-04-11T14:45:10.316Z","role":"assistant","content":"response.","delta":true}',
+            '{"type":"result","timestamp":"2026-04-11T14:45:10.380Z","status":"success","response":"Result response is not the parsed message","stats":{"total_tokens":21999}}',
+        ].join('\n') + '\n';
+        expect(parseGeminiOutput(output)).toEqual({
+            message: 'Final assistant response.',
+            session_id: 'gemini-session-stream',
+            stats: {
+                total_tokens: 21999,
+            },
+            tools: [
+                {
+                    tool: 'run_shell_command',
+                    input: { command: 'echo hidden' },
+                    output: 'hidden command output',
+                    status: 'success',
+                },
+            ],
+        });
+    });
+});
 describe('parseClaudeOutput', () => {
     it('should parse legacy JSON output', () => {
         const output = JSON.stringify({
@@ -132,3 +294,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__/peek.test.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { appendPeekMessages, validatePeekPids, validatePeekTimeSec } from '../peek.js';
+describe('peek helpers', () => {
+    it('dedupes pids while preserving first occurrence order', () => {
+        expect(validatePeekPids([3, 1, 3, 2, 1])).toEqual([3, 1, 2]);
+    });
+    it('validates pid and time limits', () => {
+        expect(() => validatePeekPids([])).toThrow(/1..32/);
+        expect(() => validatePeekPids([1.5])).toThrow(/positive safe integers/);
+        expect(() => validatePeekPids([Number.MAX_SAFE_INTEGER + 1])).toThrow(/positive safe integers/);
+        expect(validatePeekTimeSec(undefined)).toBe(10);
+        expect(validatePeekTimeSec(60)).toBe(60);
+        expect(() => validatePeekTimeSec(0)).toThrow(/positive integer/);
+        expect(() => validatePeekTimeSec(1.5)).toThrow(/positive integer/);
+        expect(() => validatePeekTimeSec(61)).toThrow(/positive integer/);
+    });
+    it('keeps the first 50 messages and marks truncation when later messages are dropped', () => {
+        const process = {
+            pid: 123,
+            agent: 'codex',
+            status: 'running',
+            messages: [],
+            truncated: false,
+            error: null,
+        };
+        appendPeekMessages(process, Array.from({ length: 55 }, (_, index) => ({
+            ts: '2026-04-11T12:34:56.789Z',
+            text: `message ${index}`,
+        })));
+        expect(process.messages).toHaveLength(50);
+        expect(process.messages[0].text).toBe('message 0');
+        expect(process.messages[49].text).toBe('message 49');
+        expect(process.truncated).toBe(true);
+    });
+});