ai-cli-mcp 2.14.0 → 2.15.0

package/dist/process-service.js

@@ -1,7 +1,28 @@
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput, parseOpenCodeOutput } from './parsers.js';
 import { buildProcessResult } from './process-result.js';
+function parseAgentOutput(agent, stdout, stderr) {
+    if (agent === 'codex') {
+        return parseCodexOutput(`${stdout || ''}\n${stderr || ''}`);
+    }
+    if (!stdout) {
+        return null;
+    }
+    if (agent === 'claude') {
+        return parseClaudeOutput(stdout);
+    }
+    if (agent === 'gemini') {
+        return parseGeminiOutput(stdout);
+    }
+    if (agent === 'forge') {
+        return parseForgeOutput(stdout);
+    }
+    if (agent === 'opencode') {
+        return parseOpenCodeOutput(stdout);
+    }
+    return null;
+}
 export class ProcessService {
     processManager = new Map();
     cliPaths;
@@ -85,22 +106,7 @@ export class ProcessService {
         if (!process) {
             throw new Error(`Process with PID ${pid} not found`);
         }
-        let agentOutput = null;
-        if (process.toolType === 'codex') {
-            const combinedOutput = (process.stdout || '') + '\n' + (process.stderr || '');
-            agentOutput = parseCodexOutput(combinedOutput);
-        }
-        else if (process.stdout) {
-            if (process.toolType === 'claude') {
-                agentOutput = parseClaudeOutput(process.stdout);
-            }
-            else if (process.toolType === 'gemini') {
-                agentOutput = parseGeminiOutput(process.stdout);
-            }
-            else if (process.toolType === 'forge') {
-                agentOutput = parseForgeOutput(process.stdout);
-            }
-        }
+        const agentOutput = parseAgentOutput(process.toolType, process.stdout, process.stderr);
         return buildProcessResult({
             pid,
             agent: process.toolType,

package/dist/server.js

@@ -1,5 +1,4 @@
-#!/usr/bin/env node
-export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+export { debugLog, findClaudeCli, findCodexCli, findForgeCli, findGeminiCli, findOpencodeCli } from './cli-utils.js';
 export { resolveModelAlias } from './cli-builder.js';
 export { ClaudeCodeServer, runMcpServer, spawnAsync } from './app/mcp.js';
 import { runMcpServer } from './app/mcp.js';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "ai-cli-mcp",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "mcpName": "io.github.mkXultra/ai-cli-mcp",
-  "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, and Forge) with background process management",
+  "description": "MCP server for AI CLI tools (Claude, Codex, Gemini, Forge, and OpenCode) with background process management",
   "author": "mkXultra",
   "license": "MIT",
   "main": "dist/server.js",
@@ -25,21 +25,24 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.11.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^3.24.4"
   },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
   "type": "module",
   "devDependencies": {
     "@eslint/js": "^9.26.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
     "@types/node": "^22.15.17",
-    "@vitest/coverage-v8": "^2.1.8",
+    "@vitest/coverage-v8": "^4.1.3",
     "husky": "^9.1.7",
-    "semantic-release": "^25.0.2",
+    "semantic-release": "^25.0.3",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.3"
   },
   "repository": {
     "type": "git",

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

@@ -236,12 +236,22 @@ describe('ai-cli app', () => {
     const stderr = vi.fn();
 
     const exitCode = await runCli(['models'], { stdout, stderr });
+    const payload = JSON.parse(stdout.mock.calls[0][0]);
 
     expect(exitCode).toBe(0);
-    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"aliases"'));
-    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"claude-ultra"'));
-    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"gpt-5.4"'));
-    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('"forge"'));
+    expect(payload.aliases).toEqual(expect.any(Array));
+    expect(payload.claude).toContain('sonnet');
+    expect(payload.codex).toContain('gpt-5.4');
+    expect(payload.forge).toEqual(['forge']);
+    expect(payload.opencode).toEqual(['opencode']);
+    expect(payload.dynamicModelBackends).toEqual({
+      opencode: {
+        explicitPrefix: 'oc-',
+        explicitPattern: 'oc-<provider/model>',
+        discoveryCommand: 'opencode models',
+        modelsAreDynamic: true,
+      },
+    });
     expect(stderr).not.toHaveBeenCalled();
   });
 
@@ -273,6 +283,12 @@ describe('ai-cli app', () => {
         available: true,
         lookup: 'path',
       },
+      opencode: {
+        configuredCommand: 'opencode',
+        resolvedPath: '/tmp/bin/opencode',
+        available: true,
+        lookup: 'path',
+      },
     });
 
     const exitCode = await runCli(['doctor'], { stdout, stderr, getDoctorStatus });
@@ -307,6 +323,8 @@ describe('ai-cli app', () => {
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gpt-5.2-codex'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('gemini-2.5-pro'));
     expect(stdout).toHaveBeenCalledWith(expect.stringContaining('forge'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('opencode'));
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('oc-openai/gpt-5.4'));
     expect(stderr).not.toHaveBeenCalled();
   });
 
@@ -355,6 +373,7 @@ describe('ai-cli app', () => {
 
     expect(exitCode).toBe(0);
     expect(stdout).toHaveBeenCalledWith(DOCTOR_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('OpenCode'));
     expect(stderr).not.toHaveBeenCalled();
   });
 
@@ -366,6 +385,7 @@ describe('ai-cli app', () => {
 
     expect(exitCode).toBe(0);
     expect(stdout).toHaveBeenCalledWith(DOCTOR_HELP_TEXT);
+    expect(stdout).toHaveBeenCalledWith(expect.stringContaining('OpenCode'));
     expect(stderr).not.toHaveBeenCalled();
   });
 

package/src/__tests__/cli-bin-smoke.test.ts

@@ -1,5 +1,5 @@
 import { execFileSync } from 'node:child_process';
-import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, join } from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
@@ -24,6 +24,62 @@ afterEach(() => {
   }
 });
 
+describe('cli helper entrypoint smoke', () => {
+  it('prints help for cli.run with OpenCode examples', () => {
+    const output = execFileSync(
+      'node',
+      ['--import', 'tsx', 'src/cli.ts', '--help'],
+      {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        env: process.env,
+      }
+    );
+
+    expect(output).toContain('Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]');
+    expect(output).toContain('opencode');
+    expect(output).toContain('oc-openai/gpt-5.4');
+    expect(output).toContain('OpenCode');
+    expect(output).toContain('npm run -s cli.run.parse -- --agent opencode < raw.txt');
+  });
+
+  it('prints help for cli.run.parse with OpenCode agent support', () => {
+    const output = execFileSync(
+      'node',
+      ['--import', 'tsx', 'src/cli-parse.ts', '--help'],
+      {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        env: process.env,
+      }
+    );
+
+    expect(output).toContain('Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini|forge|opencode>');
+    expect(output).toContain('Agent type: claude, codex, gemini, forge, or opencode');
+    expect(output).toContain('npm run -s cli.run.parse -- --agent opencode < raw.txt');
+  });
+
+  it('parses OpenCode NDJSON through cli.run.parse', () => {
+    const output = execFileSync(
+      'node',
+      ['--import', 'tsx', 'src/cli-parse.ts', '--agent', 'opencode'],
+      {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        env: process.env,
+        input: '{"type":"step_start","sessionID":"ses_cli_parse"}\n{"type":"text","sessionID":"ses_cli_parse","part":{"type":"text","text":"Hello from cli.parse"}}\n{"type":"step_finish","sessionID":"ses_cli_parse","part":{"type":"step-finish","tokens":{"total":9},"cost":1}}\n',
+      }
+    );
+
+    expect(JSON.parse(output)).toEqual({
+      message: 'Hello from cli.parse',
+      session_id: 'ses_cli_parse',
+      tokens: { total: 9 },
+      cost: 1,
+    });
+  });
+});
+
 describe('ai-cli entrypoint smoke', () => {
   it('prints doctor output for the ai-cli entrypoint', () => {
     const fakeBinDir = makeTempDir('ai-cli-bin-');
@@ -31,6 +87,7 @@ describe('ai-cli entrypoint smoke', () => {
     writeExecutable(fakeBinDir, 'codex');
     writeExecutable(fakeBinDir, 'gemini');
     writeExecutable(fakeBinDir, 'forge');
+    writeExecutable(fakeBinDir, 'opencode');
 
     const output = execFileSync(
       'node',
@@ -45,6 +102,7 @@ describe('ai-cli entrypoint smoke', () => {
           CODEX_CLI_NAME: 'codex',
           GEMINI_CLI_NAME: 'gemini',
           FORGE_CLI_NAME: 'forge',
+          OPENCODE_CLI_NAME: 'opencode',
         },
       }
     );
@@ -53,6 +111,7 @@ describe('ai-cli entrypoint smoke', () => {
     expect(output).toContain('"codex"');
     expect(output).toContain('"gemini"');
     expect(output).toContain('"forge"');
+    expect(output).toContain('"opencode"');
     expect(output).toContain('"available": true');
   });
 
@@ -71,5 +130,7 @@ describe('ai-cli entrypoint smoke', () => {
     expect(output).toContain('--model <model>');
     expect(output).toContain('claude-ultra');
     expect(output).toContain('forge');
+    expect(output).toContain('opencode');
+    expect(output).toContain('oc-openai/gpt-5.4');
   });
 });

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

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