ai-cli-mcp 2.19.0 → 2.20.1

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

@@ -1,200 +0,0 @@
-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;
-    delete process.env.OPENCODE_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',
-    });
-    expect(status.opencode).toEqual({
-      configuredCommand: 'opencode',
-      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',
-    });
-    expect(status.opencode).toEqual({
-      configuredCommand: 'opencode',
-      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');
-  });
-
-  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,311 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-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;
-  let testDir: string;
-
-  beforeEach(async () => {
-    // Ensure mock exists
-    await getSharedMock();
-    
-    // Create a temporary directory for test files
-    testDir = mkdtempSync(join(tmpdir(), 'claude-code-test-'));
-    
-    client = createTestClient();
-    
-    await client.connect();
-  });
-
-  afterEach(async () => {
-    // Disconnect client
-    await client.disconnect();
-    
-    // Clean up test directory
-    rmSync(testDir, { recursive: true, force: true });
-  });
-  
-  afterAll(async () => {
-    // Only cleanup mock at the very end
-    await cleanupSharedMock();
-  });
-
-  describe('Tool Registration', () => {
-    it('should register run tool', async () => {
-      const tools = await client.listTools();
-      
-      expect(tools).toHaveLength(7);
-      const claudeCodeTool = tools.find((t: any) => t.name === 'run');
-      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);
-    });
-  });
-
-  describe('Basic Operations', () => {
-    it('should execute a simple prompt', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'create a file called test.txt with content "Hello World"',
-        workFolder: testDir,
-      });
-
-      expect(response).toEqual([{
-        type: 'text',
-        text: expect.stringContaining('successfully'),
-      }]);
-    });
-
-    it('should handle process management correctly', async () => {
-      // run now returns a PID immediately
-      const response = await client.callTool('run', {
-        prompt: 'error',
-        workFolder: testDir,
-      });
-      
-      expect(response).toEqual([{
-        type: 'text',
-        text: expect.stringContaining('pid'),
-      }]);
-      
-      // Extract PID from response
-      const responseText = response[0].text;
-      const pidMatch = responseText.match(/"pid":\s*(\d+)/); 
-      expect(pidMatch).toBeTruthy();
-    });
-
-    it('should reject missing workFolder', async () => {
-      await expect(
-        client.callTool('run', {
-          prompt: 'List files in current directory',
-        })
-      ).rejects.toThrow(/workFolder/i);
-    });
-  });
-
-  describe('Working Directory Handling', () => {
-    it('should respect custom working directory', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'Show current working directory',
-        workFolder: testDir,
-      });
-
-      expect(response).toBeTruthy();
-    });
-
-    it('should reject non-existent working directory', async () => {
-      const nonExistentDir = join(testDir, 'non-existent');
-      
-      await expect(
-        client.callTool('run', {
-          prompt: 'Test prompt',
-          workFolder: nonExistentDir,
-        })
-      ).rejects.toThrow(/does not exist/i);
-    });
-  });
-
-  describe('Timeout Handling', () => {
-    it('should respect timeout settings', async () => {
-      // This would require modifying the mock to simulate a long-running command
-      // Since we're testing locally, we'll skip the actual timeout test
-      expect(true).toBe(true);
-    });
-  });
-
-  describe('Model Alias Handling', () => {
-    it('should resolve haiku alias when calling run', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'Test with haiku model',
-        workFolder: testDir,
-        model: 'haiku'
-      });
-      
-      expect(response).toEqual([{
-        type: 'text',
-        text: expect.stringContaining('pid'),
-      }]);
-      
-      // Extract PID from response
-      const responseText = response[0].text;
-      const pidMatch = responseText.match(/"pid":\s*(\d+)/);
-      expect(pidMatch).toBeTruthy();
-      
-      // Get the PID and check the process using get_result
-      const pid = parseInt(pidMatch![1]);
-      const result = await client.callTool('get_result', { pid });
-      const resultText = result[0].text;
-      const processData = JSON.parse(resultText);
-
-      // Verify that the model was set correctly
-      expect(processData.model).toBe('haiku');
-    });
-
-    it('should pass non-alias model names unchanged', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'Test with sonnet model',
-        workFolder: testDir,
-        model: 'sonnet'
-      });
-      
-      expect(response).toEqual([{
-        type: 'text',
-        text: expect.stringContaining('pid'),
-      }]);
-      
-      // Extract PID
-      const responseText = response[0].text;
-      const pidMatch = responseText.match(/"pid":\s*(\d+)/);
-      const pid = parseInt(pidMatch![1]);
-
-      // Check the process using get_result
-      const result = await client.callTool('get_result', { pid });
-      const resultText = result[0].text;
-      const processData = JSON.parse(resultText);
-
-      // The model should be unchanged
-      expect(processData.model).toBe('sonnet');
-    });
-    
-    it('should work without specifying a model', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'Test without model parameter',
-        workFolder: testDir
-      });
-      
-      expect(response).toEqual([{
-        type: 'text',
-        text: expect.stringContaining('pid'),
-      }]);
-    });
-  });
-
-  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
-      const response = await client.callTool('run', {
-        prompt: 'Debug test prompt',
-        workFolder: testDir,
-      });
-
-      expect(response).toBeTruthy();
-    });
-  });
-});
-
-describe('Integration Tests (Local Only)', () => {
-  let client: MCPTestClient;
-  let testDir: string;
-
-  beforeEach(async () => {
-    testDir = mkdtempSync(join(tmpdir(), 'claude-code-integration-'));
-    
-    // Initialize client without mocks for real Claude testing
-    client = createTestClient({ claudeCliName: '' });
-  });
-
-  afterEach(async () => {
-    if (client) {
-      await client.disconnect();
-    }
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  // 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: 'Reply with hi',
-      workFolder: testDir,
-    });
-
-    expect(response).toEqual([{
-      type: 'text',
-      text: expect.stringContaining('pid'),
-    }]);
-  });
-});

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

@@ -1,176 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync } 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';
-
-describe('Claude Code Edge Cases', () => {
-  let client: MCPTestClient;
-  let testDir: string;
-
-  beforeEach(async () => {
-    // Ensure mock exists
-    await getSharedMock();
-
-    // Create test directory
-    testDir = mkdtempSync(join(tmpdir(), 'claude-code-edge-'));
-
-    client = createTestClient();
-    await client.connect();
-  });
-
-  afterEach(async () => {
-    await client.disconnect();
-    rmSync(testDir, { recursive: true, force: true });
-  });
-  
-  afterAll(async () => {
-    // Cleanup mock only at the end
-    await cleanupSharedMock();
-  });
-
-  describe('Input Validation', () => {
-    it('should reject missing prompt', async () => {
-      await expect(
-        client.callTool('run', {
-          workFolder: testDir,
-        })
-      ).rejects.toThrow(/prompt/i);
-    });
-
-    it('should reject invalid prompt type', async () => {
-      await expect(
-        client.callTool('run', {
-          prompt: 123, // Should be string
-          workFolder: testDir,
-        })
-      ).rejects.toThrow();
-    });
-
-    it('should reject invalid workFolder type', async () => {
-      await expect(
-        client.callTool('run', {
-          prompt: 'Test prompt',
-          workFolder: 123, // Should be string
-        })
-      ).rejects.toThrow(/workFolder/i);
-    });
-
-    it('should reject empty prompt', async () => {
-      await expect(
-        client.callTool('run', {
-          prompt: '',
-          workFolder: testDir,
-        })
-      ).rejects.toThrow(/prompt/i);
-    });
-  });
-
-  describe('Special Characters', () => {
-    it.skip('should handle prompts with quotes', async () => {
-      // Skipping: This test fails in CI when mock is not found at expected path
-      const response = await client.callTool('run', {
-        prompt: 'Create a file with content "Hello \\"World\\""',
-        workFolder: testDir,
-      });
-
-      expect(response).toBeTruthy();
-    });
-
-    it('should handle prompts with newlines', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'Create a file with content:\\nLine 1\\nLine 2',
-        workFolder: testDir,
-      });
-
-      expect(response).toBeTruthy();
-    });
-
-    it('should handle prompts with shell special characters', async () => {
-      const response = await client.callTool('run', {
-        prompt: 'Create a file named test$file.txt',
-        workFolder: testDir,
-      });
-
-      expect(response).toBeTruthy();
-    });
-  });
-
-  describe('Error Recovery', () => {
-    it('should handle Claude CLI not found gracefully', async () => {
-      // Create a client with a different binary name that doesn't exist
-      const errorClient = createTestClient({ claudeCliName: 'non-existent-claude' });
-      await errorClient.connect();
-      
-      await expect(
-        errorClient.callTool('run', {
-          prompt: 'Test prompt',
-          workFolder: testDir,
-        })
-      ).rejects.toThrow();
-      
-      await errorClient.disconnect();
-    });
-
-    it('should handle permission denied errors', async () => {
-      const restrictedDir = '/root/restricted';
-      
-      // Non-existent directories now throw an error
-      await expect(
-        client.callTool('run', {
-          prompt: 'Test prompt',
-          workFolder: restrictedDir,
-        })
-      ).rejects.toThrow(/does not exist/i);
-    });
-  });
-
-  describe('Concurrent Requests', () => {
-    it('should handle multiple simultaneous requests', async () => {
-      const promises = Array(5).fill(null).map((_, i) => 
-        client.callTool('run', {
-          prompt: `Create file test${i}.txt`,
-          workFolder: testDir,
-        })
-      );
-
-      const results = await Promise.allSettled(promises);
-      const successful = results.filter(r => r.status === 'fulfilled');
-
-      const failures = results
-        .filter((r): r is PromiseRejectedResult => r.status === 'rejected')
-        .map((r) => r.reason?.message ?? String(r.reason));
-
-      expect(successful.length, `Concurrent run failures: ${failures.join(' | ')}`).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Large Prompts', () => {
-    it('should handle very long prompts', async () => {
-      const longPrompt = 'Create a file with content: ' + 'x'.repeat(10000);
-      
-      const response = await client.callTool('run', {
-        prompt: longPrompt,
-        workFolder: testDir,
-      });
-
-      expect(response).toBeTruthy();
-    });
-  });
-
-  describe('Path Traversal', () => {
-    it('should prevent path traversal attacks', async () => {
-      const maliciousPath = join(testDir, '..', '..', 'etc', 'passwd');
-      
-      // Server resolves paths and checks existence
-      // The path /etc/passwd may exist but be a file, not a directory
-      await expect(
-        client.callTool('run', {
-          prompt: 'Read file',
-          workFolder: maliciousPath,
-        })
-      ).rejects.toThrow(/(does not exist|ENOTDIR)/i);
-    });
-  });
-});