ai-cli-mcp 2.18.0 → 2.20.0

package/dist/__tests__/cli-utils.test.js

@@ -1,171 +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/dist/__tests__/e2e.test.js

@@ -1,256 +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 } 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;
-    let testDir;
-    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) => 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) => t.name === 'list_processes')).toBe(true);
-            expect(tools.some((t) => t.name === 'get_result')).toBe(true);
-            expect(tools.some((t) => t.name === 'peek')).toBe(true);
-            expect(tools.some((t) => 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;
-    let testDir;
-    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/dist/__tests__/edge-cases.test.js

@@ -1,130 +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 } from './utils/mcp-client.js';
-import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
-describe('Claude Code Edge Cases', () => {
-    let client;
-    let testDir;
-    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.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);
-        });
-    });
-});