ai-cli-mcp 2.10.0 → 2.12.0

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

@@ -0,0 +1,109 @@
+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;
+        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',
+        });
+    });
+    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',
+        });
+    });
+    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',
+        });
+    });
+});

package/dist/__tests__/error-cases.test.js

@@ -271,7 +271,8 @@ describe('Error Handling Tests', () => {
             // @ts-ignore
             const { ClaudeCodeServer } = module;
             const server = new ClaudeCodeServer();
-            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Claude CLI not found'));
+            expect(server).toBeDefined();
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
             consoleWarnSpy.mockRestore();
         });
         it('should handle server connection errors', async () => {

package/dist/__tests__/mcp-contract.test.js

@@ -0,0 +1,195 @@
+import { afterAll, afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { chmodSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { cleanupSharedMock, getSharedMock } from './utils/persistent-mock.js';
+import { createTestClient } from './utils/mcp-client.js';
+function parseToolJson(content) {
+    expect(content).toHaveLength(1);
+    expect(content[0].type).toBe('text');
+    return JSON.parse(content[0].text);
+}
+function expectProcessSummaryShape(processInfo) {
+    expect(processInfo).toEqual({
+        pid: expect.any(Number),
+        agent: expect.any(String),
+        status: expect.any(String),
+    });
+}
+describe('MCP Contract Tests', () => {
+    let client;
+    let testDir;
+    beforeEach(async () => {
+        await getSharedMock();
+        testDir = mkdtempSync(join(tmpdir(), 'ai-cli-mcp-contract-'));
+        client = createTestClient({ debug: false });
+        await client.connect();
+    });
+    afterEach(async () => {
+        await client.disconnect();
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    afterAll(async () => {
+        await cleanupSharedMock();
+    });
+    it('registers the current MCP tool contract', async () => {
+        const tools = await client.listTools();
+        const toolNames = tools.map((tool) => tool.name).sort();
+        expect(toolNames).toEqual([
+            'cleanup_processes',
+            'get_result',
+            'kill_process',
+            'list_processes',
+            'run',
+            'wait',
+        ]);
+        const runTool = tools.find((tool) => tool.name === 'run');
+        expect(runTool.inputSchema.required).toEqual(['workFolder']);
+        expect(Object.keys(runTool.inputSchema.properties).sort()).toEqual([
+            'model',
+            'prompt',
+            'prompt_file',
+            'reasoning_effort',
+            'session_id',
+            'workFolder',
+        ]);
+        const getResultTool = tools.find((tool) => tool.name === 'get_result');
+        expect(getResultTool.inputSchema.required).toEqual(['pid']);
+        expect(Object.keys(getResultTool.inputSchema.properties).sort()).toEqual([
+            'pid',
+            'verbose',
+        ]);
+        const waitTool = tools.find((tool) => tool.name === 'wait');
+        expect(waitTool.inputSchema.required).toEqual(['pids']);
+        expect(Object.keys(waitTool.inputSchema.properties).sort()).toEqual([
+            'pids',
+            'timeout',
+        ]);
+    });
+    it('preserves the stdio MCP smoke flow and response shapes', async () => {
+        const runResponse = await client.callTool('run', {
+            prompt: 'create a file called contract.txt with content "hello"',
+            workFolder: testDir,
+            model: 'haiku',
+        });
+        const runData = parseToolJson(runResponse);
+        expect(runData).toEqual({
+            pid: expect.any(Number),
+            status: 'started',
+            agent: 'claude',
+            message: expect.any(String),
+        });
+        const listResponse = await client.callTool('list_processes', {});
+        const listData = parseToolJson(listResponse);
+        const listedRun = listData.find((entry) => entry.pid === runData.pid);
+        expect(Array.isArray(listData)).toBe(true);
+        expect(listedRun).toBeTruthy();
+        expectProcessSummaryShape(listedRun);
+        const getResultResponse = await client.callTool('get_result', { pid: runData.pid });
+        const getResultData = parseToolJson(getResultResponse);
+        expect(getResultData).toMatchObject({
+            pid: runData.pid,
+            agent: 'claude',
+            status: expect.any(String),
+            startTime: expect.any(String),
+            workFolder: testDir,
+            prompt: 'create a file called contract.txt with content "hello"',
+            model: 'haiku',
+            stdout: expect.any(String),
+            stderr: expect.any(String),
+        });
+        const waitResponse = await client.callTool('wait', { pids: [runData.pid], timeout: 5 });
+        const waitData = parseToolJson(waitResponse);
+        expect(Array.isArray(waitData)).toBe(true);
+        expect(waitData).toHaveLength(1);
+        expect(waitData[0].pid).toBe(runData.pid);
+        expect(waitData[0].agent).toBe('claude');
+        expect(waitData[0].status).toBe('completed');
+        const cleanupResponse = await client.callTool('cleanup_processes', {});
+        const cleanupData = parseToolJson(cleanupResponse);
+        expect(cleanupData).toEqual({
+            removed: expect.any(Number),
+            removedPids: expect.any(Array),
+            message: expect.any(String),
+        });
+        expect(cleanupData.removedPids).toContain(runData.pid);
+    });
+    it('accepts prompt_file and keeps the run response shape stable', async () => {
+        const promptFile = join(testDir, 'prompt.txt');
+        writeFileSync(promptFile, 'create a file called from-file.txt');
+        const runResponse = await client.callTool('run', {
+            prompt_file: promptFile,
+            workFolder: testDir,
+        });
+        const runData = parseToolJson(runResponse);
+        expect(runData).toEqual({
+            pid: expect.any(Number),
+            status: 'started',
+            agent: 'claude',
+            message: expect.any(String),
+        });
+    });
+    it('keeps key invalid-input errors stable', async () => {
+        await expect(client.callTool('run', {
+            prompt: 'missing workFolder',
+        })).rejects.toThrow(/workFolder/i);
+        await expect(client.callTool('run', {
+            prompt: 'bad dir',
+            workFolder: join(testDir, 'missing-dir'),
+        })).rejects.toThrow(/does not exist/i);
+        const promptFile = join(testDir, 'both.txt');
+        writeFileSync(promptFile, 'test');
+        await expect(client.callTool('run', {
+            prompt: 'hello',
+            prompt_file: promptFile,
+            workFolder: testDir,
+        })).rejects.toThrow(/both prompt and prompt_file/i);
+        await expect(client.callTool('run', {
+            workFolder: testDir,
+        })).rejects.toThrow(/prompt or prompt_file/i);
+    });
+    it('keeps unknown PID errors stable for get_result, wait, and kill_process', async () => {
+        await expect(client.callTool('get_result', { pid: 999999 })).rejects.toThrow(/PID 999999 not found/i);
+        await expect(client.callTool('wait', { pids: [999999] })).rejects.toThrow(/PID 999999 not found/i);
+        await expect(client.callTool('kill_process', { pid: 999999 })).rejects.toThrow(/PID 999999 not found/i);
+    });
+    it('preserves kill_process response shape for a running process', async () => {
+        await client.disconnect();
+        const slowMockPath = join(testDir, 'slow-claude');
+        writeFileSync(slowMockPath, `#!/bin/bash
+prompt=""
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    -p|--prompt)
+      prompt="$2"
+      shift 2
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+if [[ "$prompt" == *"sleep"* ]]; then
+  sleep 5
+fi
+
+echo "Command executed successfully"
+`);
+        chmodSync(slowMockPath, 0o755);
+        client = createTestClient({ claudeCliName: slowMockPath, debug: false });
+        await client.connect();
+        const runResponse = await client.callTool('run', {
+            prompt: 'sleep for contract kill test',
+            workFolder: testDir,
+        });
+        const runData = parseToolJson(runResponse);
+        const killResponse = await client.callTool('kill_process', { pid: runData.pid });
+        const killData = parseToolJson(killResponse);
+        expect(killData).toEqual({
+            pid: runData.pid,
+            status: 'terminated',
+            message: expect.any(String),
+        });
+    });
+});

package/dist/__tests__/process-management.test.js

@@ -263,15 +263,22 @@ Unicodeテスト: 🎌 🗾 ✨
             mockProcess.stderr = new EventEmitter();
             mockSpawn.mockReturnValue(mockProcess);
             const callToolHandler = handlers.get('callTool');
-            await expect(callToolHandler({
-                params: {
-                    name: 'run',
-                    arguments: {
-                        prompt: 'test prompt',
-                        workFolder: '/tmp/test'
+            try {
+                await callToolHandler({
+                    params: {
+                        name: 'run',
+                        arguments: {
+                            prompt: 'test prompt',
+                            workFolder: '/tmp/test'
+                        }
                     }
-                }
-            })).rejects.toThrow('Failed to start claude CLI process');
+                });
+                expect.fail('Should have thrown');
+            }
+            catch (error) {
+                expect(error.message).toContain('Failed to start claude CLI process');
+                expect(error.code).toBe('InternalError');
+            }
         });
     });
     describe('list_processes tool', () => {

package/dist/__tests__/server.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { accessSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve as pathResolve } from 'node:path';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -46,6 +46,7 @@ vi.mock('../../package.json', () => ({
 }));
 // Re-import after mocks
 const mockExistsSync = vi.mocked(existsSync);
+const mockAccessSync = vi.mocked(accessSync);
 const mockSpawn = vi.mocked(spawn);
 const mockHomedir = vi.mocked(homedir);
 const mockPathResolve = vi.mocked(pathResolve);
@@ -63,6 +64,12 @@ describe('ClaudeCodeServer Unit Tests', () => {
         originalEnv = { ...process.env };
         // Reset env
         process.env = { ...originalEnv };
+        mockAccessSync.mockImplementation((filePath) => {
+            if (typeof filePath === 'string' && mockExistsSync(filePath)) {
+                return undefined;
+            }
+            throw new Error('not executable');
+        });
     });
     afterEach(() => {
         consoleErrorSpy.mockRestore();
@@ -99,6 +106,11 @@ describe('ClaudeCodeServer Unit Tests', () => {
                     return true;
                 return false;
             });
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/home/user/.claude/local/claude')
+                    return undefined;
+                throw new Error('not executable');
+            });
             const module = await import('../server.js');
             // @ts-ignore
             const findClaudeCli = module.default?.findClaudeCli || module.findClaudeCli;
@@ -108,17 +120,26 @@ describe('ClaudeCodeServer Unit Tests', () => {
         it('should fallback to PATH when local does not exist', async () => {
             mockHomedir.mockReturnValue('/home/user');
             mockExistsSync.mockReturnValue(false);
+            mockAccessSync.mockImplementation(() => {
+                throw new Error('not executable');
+            });
             const module = await import('../server.js');
             // @ts-ignore
             const findClaudeCli = module.default?.findClaudeCli || module.findClaudeCli;
             const result = findClaudeCli();
             expect(result).toBe('claude');
-            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Claude CLI not found at ~/.claude/local/claude'));
+            expect(consoleWarnSpy).not.toHaveBeenCalled();
         });
         it('should use custom name from CLAUDE_CLI_NAME', async () => {
             process.env.CLAUDE_CLI_NAME = 'my-claude';
             mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(false);
+            mockExistsSync.mockImplementation((path) => path === '/usr/bin/my-claude');
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/usr/bin/my-claude')
+                    return undefined;
+                throw new Error('not executable');
+            });
+            process.env.PATH = '/usr/bin';
             const module = await import('../server.js');
             // @ts-ignore
             const findClaudeCli = module.default?.findClaudeCli || module.findClaudeCli;
@@ -127,6 +148,11 @@ describe('ClaudeCodeServer Unit Tests', () => {
         });
         it('should use absolute path from CLAUDE_CLI_NAME', async () => {
             process.env.CLAUDE_CLI_NAME = '/absolute/path/to/claude';
+            mockAccessSync.mockImplementation((filePath) => {
+                if (filePath === '/absolute/path/to/claude')
+                    return undefined;
+                throw new Error('not executable');
+            });
             const module = await import('../server.js');
             // @ts-ignore
             const findClaudeCli = module.default?.findClaudeCli || module.findClaudeCli;

package/dist/__tests__/validation.test.js

@@ -251,7 +251,7 @@ describe('Argument Validation Tests', () => {
                 }
             })).rejects.toThrow(/reasoning_effort/i);
         });
-        it('should reject reasoning_effort for non-codex models', async () => {
+        it('should reject reasoning_effort for unsupported model families', async () => {
             await setupServer();
             const handler = handlers.get('callTool');
             await expect(handler({
@@ -260,7 +260,7 @@ describe('Argument Validation Tests', () => {
                     arguments: {
                         prompt: 'test',
                         workFolder: '/tmp',
-                        model: 'sonnet',
+                        model: 'gemini-2.5-pro',
                         reasoning_effort: 'low'
                     }
                 }

package/dist/__tests__/wait.test.js

@@ -78,6 +78,7 @@ describe('Wait Tool Tests', () => {
     });
     afterEach(() => {
         vi.clearAllMocks();
+        vi.useRealTimers();
     });
     const createMockProcess = (pid) => {
         const mockProcess = new EventEmitter();
@@ -185,6 +186,36 @@ describe('Wait Tool Tests', () => {
         expect(response.find((r) => r.pid === 101).status).toBe('completed');
         expect(response.find((r) => r.pid === 102).status).toBe('completed');
     });
+    it('should clear timeout timers after wait resolves', async () => {
+        vi.useFakeTimers();
+        const callToolHandler = handlers.get('callTool');
+        const mockProcess = createMockProcess(12348);
+        mockSpawn.mockReturnValue(mockProcess);
+        await callToolHandler({
+            params: {
+                name: 'run',
+                arguments: {
+                    prompt: 'test prompt',
+                    workFolder: '/tmp'
+                }
+            }
+        });
+        const waitPromise = callToolHandler({
+            params: {
+                name: 'wait',
+                arguments: {
+                    pids: [12348],
+                    timeout: 180
+                }
+            }
+        });
+        mockProcess.emit('close', 0);
+        await vi.runAllTicks();
+        const result = await waitPromise;
+        const response = JSON.parse(result.content[0].text);
+        expect(response[0].status).toBe('completed');
+        expect(vi.getTimerCount()).toBe(0);
+    });
     it('should throw error for non-existent PID', async () => {
         const callToolHandler = handlers.get('callTool');
         try {