ai-cli-mcp 2.14.1 → 2.16.0

package/src/__tests__/cli-utils.test.ts

@@ -20,6 +20,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';
   });
 
@@ -51,6 +52,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 () => {
@@ -73,6 +80,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 () => {
@@ -163,4 +176,25 @@ 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/src/__tests__/e2e.test.ts

@@ -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, MCPTestClient } 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: MCPTestClient;
@@ -38,46 +39,17 @@ describe('Claude Code MCP E2E Tests', () => {
     it('should register run tool', async () => {
       const tools = await client.listTools();
       
-      expect(tools).toHaveLength(6);
+      expect(tools).toHaveLength(7);
       const claudeCodeTool = tools.find((t: any) => 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: any) => t.name === 'list_processes')).toBe(true);
       expect(tools.some((t: any) => t.name === 'get_result')).toBe(true);
+      expect(tools.some((t: any) => t.name === 'peek')).toBe(true);
       expect(tools.some((t: any) => t.name === 'kill_process')).toBe(true);
     });
   });
@@ -219,6 +191,78 @@ 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
@@ -250,30 +294,18 @@ 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 () => {
+  // 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();
-    
-    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 () => {
-    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/src/__tests__/mcp-contract.test.ts

@@ -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, MCPTestClient } from './utils/mcp-client.js';
 
 function parseToolJson(content: any): any {
@@ -95,6 +96,7 @@ describe('MCP Contract Tests', () => {
       'get_result',
       'kill_process',
       'list_processes',
+      'peek',
       'run',
       'wait',
     ]);
@@ -109,6 +111,13 @@ 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: any) => tool.name === 'get_result');
     expect(getResultTool.inputSchema.required).toEqual(['pid']);
@@ -124,6 +133,14 @@ describe('MCP Contract Tests', () => {
       'timeout',
       'verbose',
     ]);
+
+    const peekTool = tools.find((tool: any) => 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 () => {
@@ -470,6 +487,177 @@ printf '%s\n' '{"type":"system","session_id":"session-verbose-1"}'
     ).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', {