ai-cli-mcp 2.14.0 → 2.15.0

package/src/__tests__/cli-process-service.test.ts

@@ -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: string, name: string, options: { ignoreSigterm?: boolean } = {}): string {
   const scriptPath = join(dir, name);
@@ -66,6 +67,7 @@ describe('CliProcessService', () => {
         codex: scriptPath,
         gemini: scriptPath,
         forge: scriptPath,
+        opencode: scriptPath,
       },
     });
 
@@ -145,6 +147,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
         codex: scriptPath,
         gemini: scriptPath,
         forge: scriptPath,
+        opencode: scriptPath,
       },
     });
 
@@ -255,6 +258,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
         codex: scriptPath,
         gemini: scriptPath,
         forge: scriptPath,
+        opencode: scriptPath,
       },
     });
 
@@ -294,6 +298,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
         codex: '/bin/sh',
         gemini: '/bin/sh',
         forge: '/bin/sh',
+        opencode: '/bin/sh',
       },
     });
 
@@ -334,6 +339,113 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
     killSpy.mockRestore();
   });
 
+  it('lists processes without crashing when a tracked work folder has been deleted', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'deleted-project');
+    mkdirSync(workFolder, { recursive: true });
+
+    const pid = 45678;
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'deleted cwd',
+        workFolder,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'running',
+      })
+    );
+
+    rmSync(workFolder, { recursive: true, force: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+        opencode: '/bin/sh',
+      },
+    });
+
+    const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target: number, signal?: string | number) => {
+      if (signal === 0 && target === pid) {
+        throw Object.assign(new Error('not running'), { code: 'ESRCH' });
+      }
+      return true;
+    });
+
+    const listed = await service.listProcesses();
+
+    expect(listed).toEqual([
+      {
+        pid,
+        agent: 'claude',
+        status: 'completed',
+      },
+    ]);
+    expect(JSON.parse(readFileSync(join(processDir, 'meta.json'), 'utf-8')).status).toBe('completed');
+    killSpy.mockRestore();
+  });
+
+  it('cleans up finished process directories even when their work folder has been deleted', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'deleted-finished-project');
+    mkdirSync(workFolder, { recursive: true });
+
+    const pid = 56789;
+    const cwdDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)));
+    const processDir = join(cwdDir, String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'done',
+        workFolder,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'completed',
+      })
+    );
+
+    rmSync(workFolder, { recursive: true, force: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+        opencode: '/bin/sh',
+      },
+    });
+
+    const result = await service.cleanupProcesses();
+
+    expect(result).toEqual({
+      removed: 1,
+      message: 'Removed 1 processes',
+    });
+    expect(existsSync(processDir)).toBe(false);
+    expect(existsSync(cwdDir)).toBe(false);
+  });
+
   it('cleans up completed and failed process directories but preserves running ones', async () => {
     const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
     tempDirs.push(root);
@@ -397,6 +509,7 @@ printf '%s\n' '{"type":"system","session_id":"session-cli-1"}'
         codex: '/bin/sh',
         gemini: '/bin/sh',
         forge: '/bin/sh',
+        opencode: '/bin/sh',
       },
     });
 
@@ -459,6 +572,7 @@ Forge assistant reply
         codex: '/bin/sh',
         gemini: '/bin/sh',
         forge: '/bin/sh',
+        opencode: '/bin/sh',
       },
     });
 
@@ -470,4 +584,107 @@ 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/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;
@@ -40,40 +41,10 @@ describe('Claude Code MCP E2E Tests', () => {
       
       expect(tools).toHaveLength(6);
       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);
@@ -219,6 +190,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 +293,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'),
+    }]);
   });
 });