ai-cli-mcp 2.2.0 → 2.3.0

package/dist/__tests__/e2e.test.js

@@ -1,238 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, afterAll } from 'vitest';
-import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { MCPTestClient } from './utils/mcp-client.js';
-import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
-describe('Claude Code MCP E2E Tests', () => {
-    let client;
-    let testDir;
-    const serverPath = 'dist/server.js';
-    beforeEach(async () => {
-        // Ensure mock exists
-        await getSharedMock();
-        // Create a temporary directory for test files
-        testDir = mkdtempSync(join(tmpdir(), 'claude-code-test-'));
-        // Initialize MCP client with debug mode and custom binary name using absolute path
-        client = new MCPTestClient(serverPath, {
-            MCP_CLAUDE_DEBUG: 'true',
-            CLAUDE_CLI_NAME: '/tmp/claude-code-test-mock/claudeMocked',
-        });
-        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 claude_code tool', async () => {
-            const tools = await client.listTools();
-            expect(tools).toHaveLength(4);
-            const claudeCodeTool = tools.find((t) => t.name === 'claude_code');
-            expect(claudeCodeTool).toEqual({
-                name: 'claude_code',
-                description: expect.stringContaining('Claude Code Agent'),
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        prompt: {
-                            type: 'string',
-                            description: expect.stringContaining('Either this or prompt_file is required'),
-                        },
-                        prompt_file: {
-                            type: 'string',
-                            description: expect.stringContaining('Path to a file containing the prompt'),
-                        },
-                        workFolder: {
-                            type: 'string',
-                            description: expect.stringContaining('working directory'),
-                        },
-                        model: {
-                            type: 'string',
-                            description: expect.stringContaining('Claude model'),
-                        },
-                        session_id: {
-                            type: 'string',
-                            description: expect.stringContaining('session ID'),
-                        },
-                    },
-                    required: ['workFolder'],
-                },
-            });
-            // Verify other tools exist
-            expect(tools.some((t) => t.name === 'list_claude_processes')).toBe(true);
-            expect(tools.some((t) => t.name === 'get_claude_result')).toBe(true);
-            expect(tools.some((t) => t.name === 'kill_claude_process')).toBe(true);
-        });
-    });
-    describe('Basic Operations', () => {
-        it('should execute a simple prompt', async () => {
-            const response = await client.callTool('claude_code', {
-                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 () => {
-            // claude_code now returns a PID immediately
-            const response = await client.callTool('claude_code', {
-                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('claude_code', {
-                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('claude_code', {
-                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('claude_code', {
-                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 claude_code', async () => {
-            const response = await client.callTool('claude_code', {
-                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
-            const pid = parseInt(pidMatch[1]);
-            const processes = await client.callTool('list_claude_processes', {});
-            const processesText = processes[0].text;
-            const processData = JSON.parse(processesText);
-            // Find our process
-            const ourProcess = processData.find((p) => p.pid === pid);
-            expect(ourProcess).toBeTruthy();
-            // Verify that the model was set correctly
-            expect(ourProcess.model).toBe('haiku');
-        });
-        it('should pass non-alias model names unchanged', async () => {
-            const response = await client.callTool('claude_code', {
-                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
-            const processes = await client.callTool('list_claude_processes', {});
-            const processesText = processes[0].text;
-            const processData = JSON.parse(processesText);
-            // Find our process
-            const ourProcess = processData.find((p) => p.pid === pid);
-            expect(ourProcess).toBeTruthy();
-            // The model should be unchanged
-            expect(ourProcess.model).toBe('sonnet');
-        });
-        it('should work without specifying a model', async () => {
-            const response = await client.callTool('claude_code', {
-                prompt: 'Test without model parameter',
-                workFolder: testDir
-            });
-            expect(response).toEqual([{
-                    type: 'text',
-                    text: expect.stringContaining('pid'),
-                }]);
-        });
-    });
-    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('claude_code', {
-                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 = new MCPTestClient('dist/server.js', {
-            MCP_CLAUDE_DEBUG: 'true',
-        });
-    });
-    afterEach(async () => {
-        if (client) {
-            await client.disconnect();
-        }
-        rmSync(testDir, { recursive: true, force: true });
-    });
-    // These tests will only run locally when Claude is available
-    it.skip('should create a file with real Claude CLI', async () => {
-        await client.connect();
-        const response = await client.callTool('claude_code', {
-            prompt: 'Create a file called hello.txt with content "Hello from Claude"',
-            workFolder: testDir,
-        });
-        const filePath = join(testDir, 'hello.txt');
-        expect(existsSync(filePath)).toBe(true);
-        expect(readFileSync(filePath, 'utf-8')).toContain('Hello from Claude');
-    });
-    it.skip('should handle git operations with real Claude CLI', async () => {
-        await client.connect();
-        // Initialize git repo
-        const response = await client.callTool('claude_code', {
-            prompt: 'Initialize a git repository and create a README.md file',
-            workFolder: testDir,
-        });
-        expect(existsSync(join(testDir, '.git'))).toBe(true);
-        expect(existsSync(join(testDir, 'README.md'))).toBe(true);
-    });
-});

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

@@ -1,135 +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 { MCPTestClient } from './utils/mcp-client.js';
-import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
-describe('Claude Code Edge Cases', () => {
-    let client;
-    let testDir;
-    const serverPath = 'dist/server.js';
-    beforeEach(async () => {
-        // Ensure mock exists
-        await getSharedMock();
-        // Create test directory
-        testDir = mkdtempSync(join(tmpdir(), 'claude-code-edge-'));
-        // Initialize client with custom binary name using absolute path
-        client = new MCPTestClient(serverPath, {
-            MCP_CLAUDE_DEBUG: 'true',
-            CLAUDE_CLI_NAME: '/tmp/claude-code-test-mock/claudeMocked',
-        });
-        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('claude_code', {
-                workFolder: testDir,
-            })).rejects.toThrow(/prompt/i);
-        });
-        it('should reject invalid prompt type', async () => {
-            await expect(client.callTool('claude_code', {
-                prompt: 123, // Should be string
-                workFolder: testDir,
-            })).rejects.toThrow();
-        });
-        it('should reject invalid workFolder type', async () => {
-            await expect(client.callTool('claude_code', {
-                prompt: 'Test prompt',
-                workFolder: 123, // Should be string
-            })).rejects.toThrow(/workFolder/i);
-        });
-        it('should reject empty prompt', async () => {
-            await expect(client.callTool('claude_code', {
-                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('claude_code', {
-                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('claude_code', {
-                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('claude_code', {
-                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 = new MCPTestClient(serverPath, {
-                MCP_CLAUDE_DEBUG: 'true',
-                CLAUDE_CLI_NAME: 'non-existent-claude',
-            });
-            await errorClient.connect();
-            await expect(errorClient.callTool('claude_code', {
-                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('claude_code', {
-                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('claude_code', {
-                prompt: `Create file test${i}.txt`,
-                workFolder: testDir,
-            }));
-            const results = await Promise.allSettled(promises);
-            const successful = results.filter(r => r.status === 'fulfilled');
-            expect(successful.length).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('claude_code', {
-                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('claude_code', {
-                prompt: 'Read file',
-                workFolder: maliciousPath,
-            })).rejects.toThrow(/(does not exist|ENOTDIR)/i);
-        });
-    });
-});

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

@@ -1,296 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { EventEmitter } from 'node:events';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-// Mock dependencies
-vi.mock('node:child_process');
-vi.mock('node:fs');
-vi.mock('node:os');
-vi.mock('node:path', () => ({
-    resolve: vi.fn((path) => path),
-    join: vi.fn((...args) => args.join('/')),
-    isAbsolute: vi.fn((path) => path.startsWith('/'))
-}));
-vi.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
-    Server: vi.fn().mockImplementation(function () {
-        this.setRequestHandler = vi.fn();
-        this.connect = vi.fn();
-        this.close = vi.fn();
-        this.onerror = undefined;
-        return this;
-    }),
-}));
-vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
-    ListToolsRequestSchema: { name: 'listTools' },
-    CallToolRequestSchema: { name: 'callTool' },
-    ErrorCode: {
-        InternalError: 'InternalError',
-        MethodNotFound: 'MethodNotFound',
-        InvalidParams: 'InvalidParams'
-    },
-    McpError: vi.fn().mockImplementation((code, message) => {
-        const error = new Error(message);
-        error.code = code;
-        return error;
-    })
-}));
-const mockExistsSync = vi.mocked(existsSync);
-const mockSpawn = vi.mocked(spawn);
-const mockHomedir = vi.mocked(homedir);
-describe('Error Handling Tests', () => {
-    let consoleErrorSpy;
-    let originalEnv;
-    let errorHandler = null;
-    function setupServerMock() {
-        errorHandler = null;
-        vi.mocked(Server).mockImplementation(function () {
-            this.setRequestHandler = vi.fn();
-            this.connect = vi.fn();
-            this.close = vi.fn();
-            Object.defineProperty(this, 'onerror', {
-                get() { return errorHandler; },
-                set(handler) { errorHandler = handler; },
-                enumerable: true,
-                configurable: true
-            });
-            return this;
-        });
-    }
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-        originalEnv = { ...process.env };
-        process.env = { ...originalEnv };
-    });
-    afterEach(() => {
-        consoleErrorSpy.mockRestore();
-        process.env = originalEnv;
-    });
-    describe('CallToolRequest Error Cases', () => {
-        it('should throw error for unknown tool name', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            // Set up Server mock before importing the module
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
-            const handler = callToolCall[1];
-            await expect(handler({
-                params: {
-                    name: 'unknown_tool',
-                    arguments: {}
-                }
-            })).rejects.toThrow('Tool unknown_tool not found');
-        });
-        it('should handle timeout errors', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const { McpError } = await import('@modelcontextprotocol/sdk/types.js');
-            const server = new ClaudeCodeServer();
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            // Find the callTool handler
-            let callToolHandler;
-            for (const call of mockServerInstance.setRequestHandler.mock.calls) {
-                if (call[0].name === 'callTool') {
-                    callToolHandler = call[1];
-                    break;
-                }
-            }
-            // Mock spawn to return process without PID
-            mockSpawn.mockImplementation(() => {
-                const mockProcess = new EventEmitter();
-                mockProcess.stdout = new EventEmitter();
-                mockProcess.stderr = new EventEmitter();
-                mockProcess.stdout.on = vi.fn();
-                mockProcess.stderr.on = vi.fn();
-                mockProcess.pid = undefined; // No PID to simulate process start failure
-                return mockProcess;
-            });
-            // Call handler
-            try {
-                await callToolHandler({
-                    params: {
-                        name: 'claude_code',
-                        arguments: {
-                            prompt: 'test',
-                            workFolder: '/tmp'
-                        }
-                    }
-                });
-                expect.fail('Should have thrown');
-            }
-            catch (err) {
-                // Check if McpError was called with the process start failure message
-                expect(McpError).toHaveBeenCalledWith('InternalError', 'Failed to start Claude CLI process');
-            }
-        });
-        it('should handle invalid argument types', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
-            const handler = callToolCall[1];
-            await expect(handler({
-                params: {
-                    name: 'claude_code',
-                    arguments: 'invalid-should-be-object'
-                }
-            })).rejects.toThrow();
-        });
-        it('should include CLI error details in error message', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            const callToolCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'callTool');
-            const handler = callToolCall[1];
-            // Create a simple mock process
-            mockSpawn.mockImplementation(() => {
-                const mockProcess = Object.create(EventEmitter.prototype);
-                EventEmitter.call(mockProcess);
-                mockProcess.stdout = Object.create(EventEmitter.prototype);
-                EventEmitter.call(mockProcess.stdout);
-                mockProcess.stderr = Object.create(EventEmitter.prototype);
-                EventEmitter.call(mockProcess.stderr);
-                mockProcess.stdout.on = vi.fn((event, callback) => {
-                    if (event === 'data') {
-                        // Send some stdout data
-                        process.nextTick(() => callback('stdout content'));
-                    }
-                });
-                mockProcess.stderr.on = vi.fn((event, callback) => {
-                    if (event === 'data') {
-                        // Send some stderr data
-                        process.nextTick(() => callback('stderr content'));
-                    }
-                });
-                // Emit error/close event after data is sent
-                setTimeout(() => {
-                    mockProcess.emit('close', 1);
-                }, 1);
-                return mockProcess;
-            });
-            await expect(handler({
-                params: {
-                    name: 'claude_code',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: '/tmp'
-                    }
-                }
-            })).rejects.toThrow();
-        });
-    });
-    describe('Process Spawn Error Cases', () => {
-        it('should handle spawn ENOENT error', async () => {
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { spawnAsync } = module;
-            const mockProcess = new EventEmitter();
-            mockProcess.stdout = new EventEmitter();
-            mockProcess.stderr = new EventEmitter();
-            mockProcess.stdout.on = vi.fn();
-            mockProcess.stderr.on = vi.fn();
-            mockSpawn.mockReturnValue(mockProcess);
-            const promise = spawnAsync('nonexistent-command', []);
-            // Simulate ENOENT error
-            setTimeout(() => {
-                const error = new Error('spawn ENOENT');
-                error.code = 'ENOENT';
-                error.path = 'nonexistent-command';
-                error.syscall = 'spawn';
-                mockProcess.emit('error', error);
-            }, 10);
-            await expect(promise).rejects.toThrow('Spawn error');
-            await expect(promise).rejects.toThrow('nonexistent-command');
-        });
-        it('should handle generic spawn errors', async () => {
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { spawnAsync } = module;
-            const mockProcess = new EventEmitter();
-            mockProcess.stdout = new EventEmitter();
-            mockProcess.stderr = new EventEmitter();
-            mockProcess.stdout.on = vi.fn();
-            mockProcess.stderr.on = vi.fn();
-            mockSpawn.mockReturnValue(mockProcess);
-            const promise = spawnAsync('test', []);
-            // Simulate generic error
-            setTimeout(() => {
-                mockProcess.emit('error', new Error('Generic spawn error'));
-            }, 10);
-            await expect(promise).rejects.toThrow('Generic spawn error');
-        });
-        it('should accumulate stderr output before error', async () => {
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { spawnAsync } = module;
-            const mockProcess = new EventEmitter();
-            mockProcess.stdout = new EventEmitter();
-            mockProcess.stderr = new EventEmitter();
-            let stderrHandler;
-            mockProcess.stdout.on = vi.fn();
-            mockProcess.stderr.on = vi.fn((event, handler) => {
-                if (event === 'data')
-                    stderrHandler = handler;
-            });
-            mockSpawn.mockReturnValue(mockProcess);
-            const promise = spawnAsync('test', []);
-            // Simulate stderr data then error
-            setTimeout(() => {
-                stderrHandler('error line 1\n');
-                stderrHandler('error line 2\n');
-                mockProcess.emit('error', new Error('Command failed'));
-            }, 10);
-            await expect(promise).rejects.toThrow('error line 1\nerror line 2');
-        });
-    });
-    describe('Server Initialization Errors', () => {
-        it('should handle CLI path not found gracefully', async () => {
-            // Mock no CLI found anywhere
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(false);
-            const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining('Claude CLI not found'));
-            consoleWarnSpy.mockRestore();
-        });
-        it('should handle server connection errors', async () => {
-            mockHomedir.mockReturnValue('/home/user');
-            mockExistsSync.mockReturnValue(true);
-            setupServerMock();
-            const module = await import('../server.js');
-            // @ts-ignore
-            const { ClaudeCodeServer } = module;
-            const server = new ClaudeCodeServer();
-            // Mock connection failure  
-            const mockServerInstance = vi.mocked(Server).mock.results[0].value;
-            mockServerInstance.connect.mockRejectedValue(new Error('Connection failed'));
-            await expect(server.run()).rejects.toThrow('Connection failed');
-        });
-    });
-});