ai-cli-mcp 2.11.0 → 2.13.0

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

@@ -0,0 +1,75 @@
+import { execFileSync } from 'node:child_process';
+import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { delimiter, join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+const tempDirs: string[] = [];
+
+function makeTempDir(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), prefix));
+  tempDirs.push(dir);
+  return dir;
+}
+
+function writeExecutable(dir: string, name: string): void {
+  const filePath = join(dir, name);
+  writeFileSync(filePath, '#!/bin/sh\nexit 0\n', 'utf8');
+  chmodSync(filePath, 0o755);
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('ai-cli entrypoint smoke', () => {
+  it('prints doctor output for the ai-cli entrypoint', () => {
+    const fakeBinDir = makeTempDir('ai-cli-bin-');
+    writeExecutable(fakeBinDir, 'claude');
+    writeExecutable(fakeBinDir, 'codex');
+    writeExecutable(fakeBinDir, 'gemini');
+    writeExecutable(fakeBinDir, 'forge');
+
+    const output = execFileSync(
+      'node',
+      ['--import', 'tsx', 'src/bin/ai-cli.ts', 'doctor'],
+      {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          PATH: `${fakeBinDir}${delimiter}${process.env.PATH || ''}`,
+          CLAUDE_CLI_NAME: 'claude',
+          CODEX_CLI_NAME: 'codex',
+          GEMINI_CLI_NAME: 'gemini',
+          FORGE_CLI_NAME: 'forge',
+        },
+      }
+    );
+
+    expect(output).toContain('"claude"');
+    expect(output).toContain('"codex"');
+    expect(output).toContain('"gemini"');
+    expect(output).toContain('"forge"');
+    expect(output).toContain('"available": true');
+  });
+
+  it('prints run help for the ai-cli entrypoint', () => {
+    const output = execFileSync(
+      'node',
+      ['--import', 'tsx', 'src/bin/ai-cli.ts', 'run', '--help'],
+      {
+        cwd: process.cwd(),
+        encoding: 'utf8',
+        env: process.env,
+      }
+    );
+
+    expect(output).toContain('Usage: ai-cli run --cwd <path> [options]');
+    expect(output).toContain('--model <model>');
+    expect(output).toContain('claude-ultra');
+    expect(output).toContain('forge');
+  });
+});

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

@@ -22,6 +22,7 @@ const DEFAULT_CLI_PATHS = {
   claude: '/usr/bin/claude',
   codex: '/usr/bin/codex',
   gemini: '/usr/bin/gemini',
+  forge: '/usr/bin/forge',
 };
 
 describe('cli-builder', () => {
@@ -97,6 +98,12 @@ describe('cli-builder', () => {
         'reasoning_effort is only supported for Claude and Codex models.'
       );
     });
+
+    it('should reject reasoning_effort for forge explicitly', () => {
+      expect(() => getReasoningEffort('forge', 'high')).toThrow(
+        'reasoning_effort is not supported for forge.'
+      );
+    });
   });
 
   describe('buildCliCommand', () => {
@@ -401,5 +408,45 @@ describe('cli-builder', () => {
         expect(cmd.resolvedModel).toBe('gemini-3.1-pro-preview');
       });
     });
+
+    describe('forge agent', () => {
+      it('should build forge command without model flags', () => {
+        const cmd = buildCliCommand({
+          prompt: 'test',
+          workFolder: '/tmp',
+          model: 'forge',
+          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']);
+      });
+
+      it('should map session_id to --conversation-id for forge', () => {
+        const cmd = buildCliCommand({
+          prompt: 'test',
+          workFolder: '/tmp',
+          model: 'forge',
+          session_id: 'forge-conv-123',
+          cliPaths: DEFAULT_CLI_PATHS,
+        });
+
+        expect(cmd.args).toEqual(['-C', '/tmp', '--conversation-id', 'forge-conv-123', '-p', 'test']);
+      });
+
+      it('should reject reasoning_effort for forge in command building', () => {
+        expect(() =>
+          buildCliCommand({
+            prompt: 'test',
+            workFolder: '/tmp',
+            model: 'forge',
+            reasoning_effort: 'high',
+            cliPaths: DEFAULT_CLI_PATHS,
+          })
+        ).toThrow('reasoning_effort is not supported for forge.');
+      });
+    });
   });
 });

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

@@ -0,0 +1,334 @@
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+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';
+
+function createMockCliScript(dir: string, name: string, options: { ignoreSigterm?: boolean } = {}): string {
+  const scriptPath = join(dir, name);
+  writeFileSync(
+    scriptPath,
+    `#!/bin/bash
+prompt=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -p|--prompt)
+      prompt="$2"
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+${options.ignoreSigterm ? "trap '' TERM\n" : ''}
+
+if [[ "$prompt" == *"sleep"* ]]; then
+${options.ignoreSigterm ? '  while true; do sleep 1; done\n' : '  sleep 5\n'}
+fi
+
+echo "Command executed successfully"
+`
+  );
+  chmodSync(scriptPath, 0o755);
+  return scriptPath;
+}
+
+function encodeCwd(cwd: string): string {
+  return cwd
+    .split('')
+    .map((char) => (/^[A-Za-z0-9.-]$/.test(char) ? char : `_${char.charCodeAt(0).toString(16).padStart(2, '0')}`))
+    .join('');
+}
+
+describe('CliProcessService', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    for (const dir of tempDirs.splice(0)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('starts a detached process and persists state under a normalized cwd directory', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const scriptPath = createMockCliScript(root, 'mock-claude');
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'work');
+    mkdirSync(workFolder, { recursive: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: scriptPath,
+        codex: scriptPath,
+        gemini: scriptPath,
+        forge: scriptPath,
+      },
+    });
+
+    const runResult = await service.startProcess({
+      prompt: 'hello',
+      cwd: workFolder,
+      model: 'sonnet',
+    });
+
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(runResult.pid));
+    expect(runResult.pid).toBeGreaterThan(0);
+    expect(runResult.status).toBe('started');
+    expect(existsSync(join(processDir, 'meta.json'))).toBe(true);
+    expect(existsSync(join(processDir, 'stdout.log'))).toBe(true);
+    expect(existsSync(join(processDir, 'stderr.log'))).toBe(true);
+
+    const waitResult = await service.waitForProcesses([runResult.pid], 5);
+    expect(waitResult).toHaveLength(1);
+    expect(waitResult[0].pid).toBe(runResult.pid);
+    expect(waitResult[0].status).toBe('completed');
+
+    const listed = await service.listProcesses();
+    expect(listed).toContainEqual({
+      pid: runResult.pid,
+      agent: 'claude',
+      status: 'completed',
+    });
+
+    const result = await service.getProcessResult(runResult.pid, false);
+    expect(result.pid).toBe(runResult.pid);
+    expect(result.status).toBe('completed');
+    expect(result.stdout).toContain('Command executed successfully');
+    expect(readFileSync(join(processDir, 'meta.json'), 'utf-8')).toContain('"status": "completed"');
+  });
+
+  it('can terminate a tracked process', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const scriptPath = createMockCliScript(root, 'mock-claude');
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'work');
+    mkdirSync(workFolder, { recursive: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: scriptPath,
+        codex: scriptPath,
+        gemini: scriptPath,
+        forge: scriptPath,
+      },
+    });
+
+    const runResult = await service.startProcess({
+      prompt: 'sleep please',
+      cwd: workFolder,
+      model: 'sonnet',
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    const killResult = await service.killProcess(runResult.pid);
+    expect(killResult).toEqual({
+      pid: runResult.pid,
+      status: 'terminated',
+      message: 'Process terminated successfully',
+    });
+
+    const result = await service.getProcessResult(runResult.pid, false);
+    expect(result.status).toBe('failed');
+  });
+
+  it('does not report termination until the process actually exits', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'project');
+    mkdirSync(workFolder, { recursive: true });
+    const pid = 12345;
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'sleep please',
+        workFolder,
+        model: 'sonnet',
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'running',
+      })
+    );
+
+    const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target: number, signal?: string | number) => {
+      if (signal === 0) {
+        return true;
+      }
+      if (target === -pid && signal === 'SIGTERM') {
+        return true;
+      }
+      return true;
+    });
+
+    const killResult = await service.killProcess(pid);
+    expect(killResult).toEqual({
+      pid,
+      status: 'running',
+      message: 'Signal sent but process is still running',
+    });
+
+    const stored = JSON.parse(readFileSync(join(processDir, 'meta.json'), 'utf-8'));
+    expect(stored.status).toBe('running');
+    killSpy.mockRestore();
+  });
+
+  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);
+    const stateDir = join(root, 'state');
+    const runningCwd = join(root, 'running-project');
+    const finishedCwd = join(root, 'finished-project');
+    mkdirSync(runningCwd, { recursive: true });
+    mkdirSync(finishedCwd, { recursive: true });
+
+    const runningDir = join(stateDir, 'cwds', encodeCwd(realpathSync(runningCwd)), '111');
+    const completedDir = join(stateDir, 'cwds', encodeCwd(realpathSync(finishedCwd)), '222');
+    const failedDir = join(stateDir, 'cwds', encodeCwd(realpathSync(finishedCwd)), '333');
+    mkdirSync(runningDir, { recursive: true });
+    mkdirSync(completedDir, { recursive: true });
+    mkdirSync(failedDir, { recursive: true });
+
+    writeFileSync(
+      join(runningDir, 'meta.json'),
+      JSON.stringify({
+        pid: 111,
+        prompt: 'keep',
+        workFolder: runningCwd,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(runningDir, 'stdout.log'),
+        stderrPath: join(runningDir, 'stderr.log'),
+        status: 'running',
+      })
+    );
+    writeFileSync(
+      join(completedDir, 'meta.json'),
+      JSON.stringify({
+        pid: 222,
+        prompt: 'done',
+        workFolder: finishedCwd,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(completedDir, 'stdout.log'),
+        stderrPath: join(completedDir, 'stderr.log'),
+        status: 'completed',
+      })
+    );
+    writeFileSync(
+      join(failedDir, 'meta.json'),
+      JSON.stringify({
+        pid: 333,
+        prompt: 'failed',
+        workFolder: finishedCwd,
+        toolType: 'claude',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(failedDir, 'stdout.log'),
+        stderrPath: join(failedDir, 'stderr.log'),
+        status: 'failed',
+      })
+    );
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target: number, signal?: string | number) => {
+      if (signal === 0 && target === 111) {
+        return true;
+      }
+      throw Object.assign(new Error('not running'), { code: 'ESRCH' });
+    });
+
+    const result = await service.cleanupProcesses();
+
+    expect(result).toEqual({
+      removed: 2,
+      message: 'Removed 2 processes',
+    });
+    expect(existsSync(runningDir)).toBe(true);
+    expect(existsSync(completedDir)).toBe(false);
+    expect(existsSync(failedDir)).toBe(false);
+    killSpy.mockRestore();
+  });
+
+  it('parses forge output from detached process logs', async () => {
+    const root = mkdtempSync(join(tmpdir(), 'ai-cli-cli-service-'));
+    tempDirs.push(root);
+    const stateDir = join(root, 'state');
+    const workFolder = join(root, 'forge-project');
+    mkdirSync(workFolder, { recursive: true });
+    const pid = 54321;
+    const processDir = join(stateDir, 'cwds', encodeCwd(realpathSync(workFolder)), String(pid));
+    mkdirSync(processDir, { recursive: true });
+
+    writeFileSync(
+      join(processDir, 'stdout.log'),
+      `● [21:09:01] Initialize forge-conv-1
+Forge assistant reply
+● [21:09:08] Finished forge-conv-1
+`
+    );
+    writeFileSync(join(processDir, 'stderr.log'), '');
+    writeFileSync(
+      join(processDir, 'meta.json'),
+      JSON.stringify({
+        pid,
+        prompt: 'hello forge',
+        workFolder,
+        model: 'forge',
+        toolType: 'forge',
+        startTime: new Date().toISOString(),
+        stdoutPath: join(processDir, 'stdout.log'),
+        stderrPath: join(processDir, 'stderr.log'),
+        status: 'completed',
+      })
+    );
+
+    const service = new CliProcessService({
+      stateDir,
+      cliPaths: {
+        claude: '/bin/sh',
+        codex: '/bin/sh',
+        gemini: '/bin/sh',
+        forge: '/bin/sh',
+      },
+    });
+
+    const result = await service.getProcessResult(pid, false);
+    expect(result.agent).toBe('forge');
+    expect(result.session_id).toBe('forge-conv-1');
+    expect(result.agentOutput).toEqual({
+      message: 'Forge assistant reply',
+      session_id: 'forge-conv-1',
+    });
+  });
+});

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

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { accessSync } from 'node:fs';
+
+vi.mock('node:fs', () => ({
+  accessSync: vi.fn(),
+  constants: { X_OK: 1 },
+}));
+
+const mockAccessSync = vi.mocked(accessSync);
+
+describe('cli-utils doctor status', () => {
+  const originalEnv = process.env;
+  const originalPlatform = process.platform;
+
+  beforeEach(() => {
+    vi.resetModules();
+    mockAccessSync.mockReset();
+    process.env = { ...originalEnv };
+    delete process.env.CLAUDE_CLI_NAME;
+    delete process.env.CODEX_CLI_NAME;
+    delete process.env.GEMINI_CLI_NAME;
+    delete process.env.FORGE_CLI_NAME;
+    process.env.PATH = '/mock/bin:/usr/bin';
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+  });
+
+  it('marks PATH binaries available when they are executable', async () => {
+    mockAccessSync.mockImplementation((filePath) => {
+      if (filePath === '/mock/bin/claude') {
+        return undefined;
+      }
+      throw new Error('not executable');
+    });
+
+    const { getCliDoctorStatus } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.claude).toEqual({
+      configuredCommand: 'claude',
+      resolvedPath: '/mock/bin/claude',
+      available: true,
+      lookup: 'path',
+    });
+    expect(status.forge).toEqual({
+      configuredCommand: 'forge',
+      resolvedPath: null,
+      available: false,
+      lookup: 'path',
+    });
+  });
+
+  it('does not mark non-executable PATH entries as available', async () => {
+    mockAccessSync.mockImplementation(() => {
+      throw new Error('not executable');
+    });
+
+    const { getCliDoctorStatus } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.claude).toEqual({
+      configuredCommand: 'claude',
+      resolvedPath: null,
+      available: false,
+      lookup: 'path',
+    });
+    expect(status.forge).toEqual({
+      configuredCommand: 'forge',
+      resolvedPath: null,
+      available: false,
+      lookup: 'path',
+    });
+  });
+
+  it('reports invalid relative env paths as doctor errors', async () => {
+    process.env.CLAUDE_CLI_NAME = './relative/claude';
+
+    const { getCliDoctorStatus } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.claude.available).toBe(false);
+    expect(status.claude.lookup).toBe('env');
+    expect(status.claude.error).toContain('Invalid CLAUDE_CLI_NAME');
+  });
+
+  it('reports missing absolute env paths as unavailable', async () => {
+    process.env.CLAUDE_CLI_NAME = '/missing/claude';
+    mockAccessSync.mockImplementation(() => {
+      throw new Error('missing');
+    });
+
+    const { getCliDoctorStatus } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.claude).toEqual({
+      configuredCommand: '/missing/claude',
+      resolvedPath: '/missing/claude',
+      available: false,
+      lookup: 'env',
+    });
+  });
+
+  it('falls back cleanly when PATH is empty', async () => {
+    process.env.PATH = '';
+    mockAccessSync.mockImplementation(() => {
+      throw new Error('missing');
+    });
+
+    const { getCliDoctorStatus } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.codex).toEqual({
+      configuredCommand: 'codex',
+      resolvedPath: null,
+      available: false,
+      lookup: 'path',
+    });
+  });
+
+  it('supports Windows commands that already include an executable suffix', async () => {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    process.env.PATHEXT = '.EXE;.CMD';
+    process.env.CLAUDE_CLI_NAME = 'claude.cmd';
+    process.env.PATH = '/mock/bin';
+    mockAccessSync.mockImplementation((filePath) => {
+      if (filePath === '/mock/bin/claude.cmd') {
+        return undefined;
+      }
+      throw new Error('not executable');
+    });
+
+    const { getCliDoctorStatus } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.claude).toEqual({
+      configuredCommand: 'claude.cmd',
+      resolvedPath: '/mock/bin/claude.cmd',
+      available: true,
+      lookup: 'env',
+    });
+  });
+
+  it('supports forge lookup via FORGE_CLI_NAME', async () => {
+    process.env.FORGE_CLI_NAME = 'forge-custom';
+    mockAccessSync.mockImplementation((filePath) => {
+      if (filePath === '/mock/bin/forge-custom') {
+        return undefined;
+      }
+      throw new Error('not executable');
+    });
+
+    const { getCliDoctorStatus, findForgeCli } = await import('../cli-utils.js');
+    const status = getCliDoctorStatus();
+
+    expect(status.forge).toEqual({
+      configuredCommand: 'forge-custom',
+      resolvedPath: '/mock/bin/forge-custom',
+      available: true,
+      lookup: 'env',
+    });
+    expect(findForgeCli()).toBe('forge-custom');
+  });
+});

package/src/__tests__/error-cases.test.ts

@@ -344,9 +344,8 @@ describe('Error Handling Tests', () => {
       
       const server = new ClaudeCodeServer();
       
-      expect(consoleWarnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Claude CLI not found')
-      );
+      expect(server).toBeDefined();
+      expect(consoleWarnSpy).not.toHaveBeenCalled();
       
       consoleWarnSpy.mockRestore();
     });
@@ -368,4 +367,4 @@ describe('Error Handling Tests', () => {
       await expect(server.run()).rejects.toThrow('Connection failed');
     });
   });
-});
+});