ai-cli-mcp 2.3.0 → 2.3.2

package/.claude/settings.local.json

@@ -14,7 +14,8 @@
       "mcp__chat__agent_communication_get_messages",
       "mcp__ccm__list_claude_processes",
       "Bash(gemini:*)",
-      "WebSearch"
+      "WebSearch",
+      "Bash(npm pack:*)"
     ],
     "deny": []
   }

package/dist/__tests__/e2e.test.js

@@ -0,0 +1,225 @@
+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 { createTestClient } from './utils/mcp-client.js';
+import { getSharedMock, cleanupSharedMock } from './utils/persistent-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(6);
+            const claudeCodeTool = tools.find((t) => t.name === 'run');
+            expect(claudeCodeTool).toEqual({
+                name: 'run',
+                description: expect.stringContaining('AI Agent Runner'),
+                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('sonnet'),
+                        },
+                        session_id: {
+                            type: 'string',
+                            description: expect.stringContaining('session ID'),
+                        },
+                    },
+                    required: ['workFolder'],
+                },
+            });
+            // 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 === '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('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 });
+    });
+    // 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('run', {
+            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('run', {
+            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

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

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

@@ -0,0 +1,291 @@
+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: class extends Error {
+        code;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+        }
+    }
+}));
+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
+            await expect(callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test',
+                        workFolder: '/tmp'
+                    }
+                }
+            })).rejects.toThrow('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: 'run',
+                    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: 'run',
+                    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');
+        });
+    });
+});

package/dist/__tests__/mocks.js

@@ -0,0 +1,32 @@
+import { vi } from 'vitest';
+// Mock Claude CLI responses
+export const mockClaudeResponse = (stdout, stderr = '', exitCode = 0) => {
+    return {
+        stdout: { on: vi.fn((event, cb) => event === 'data' && cb(stdout)) },
+        stderr: { on: vi.fn((event, cb) => event === 'data' && cb(stderr)) },
+        on: vi.fn((event, cb) => {
+            if (event === 'exit')
+                setTimeout(() => cb(exitCode), 10);
+        }),
+    };
+};
+// Mock MCP request builder
+export const createMCPRequest = (tool, args, id = 1) => ({
+    jsonrpc: '2.0',
+    method: 'tools/call',
+    params: {
+        name: tool,
+        arguments: args,
+    },
+    id,
+});
+// Mock file system operations
+export const setupTestEnvironment = () => {
+    const testFiles = new Map();
+    return {
+        writeFile: (path, content) => testFiles.set(path, content),
+        readFile: (path) => testFiles.get(path),
+        exists: (path) => testFiles.has(path),
+        cleanup: () => testFiles.clear(),
+    };
+};