ai-cli-mcp 2.11.0 → 2.12.0

package/dist/__tests__/cli-process-service.test.js

@@ -0,0 +1,233 @@
+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, name, options = {}) {
+    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) {
+    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 = [];
+    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,
+            },
+        });
+        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,
+            },
+        });
+        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',
+            },
+        });
+        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, signal) => {
+            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',
+            },
+        });
+        const killSpy = vi.spyOn(globalThis.process, 'kill').mockImplementation((target, signal) => {
+            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();
+    });
+});

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;