ai-cli-mcp 2.3.0 → 2.3.1

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

@@ -0,0 +1,630 @@
+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';
+// Mock dependencies
+vi.mock('node:child_process');
+vi.mock('node:fs');
+vi.mock('node:os');
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js');
+vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
+    ListToolsRequestSchema: { name: 'listTools' },
+    CallToolRequestSchema: { name: 'callTool' },
+    ErrorCode: {
+        InternalError: 'InternalError',
+        MethodNotFound: 'MethodNotFound',
+        InvalidParams: 'InvalidParams'
+    },
+    McpError: class McpError extends Error {
+        code;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+            this.name = 'McpError';
+        }
+    }
+}));
+vi.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+    Server: vi.fn().mockImplementation(function () {
+        return {
+            setRequestHandler: vi.fn(),
+            connect: vi.fn(),
+            close: vi.fn(),
+            onerror: undefined,
+        };
+    }),
+}));
+const mockExistsSync = vi.mocked(existsSync);
+const mockSpawn = vi.mocked(spawn);
+const mockHomedir = vi.mocked(homedir);
+describe('Process Management Tests', () => {
+    let consoleErrorSpy;
+    let originalEnv;
+    let mockServerInstance;
+    let handlers;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        originalEnv = { ...process.env };
+        process.env = { ...originalEnv };
+        handlers = new Map();
+        // Set up default mocks
+        mockHomedir.mockReturnValue('/home/user');
+        mockExistsSync.mockReturnValue(true);
+    });
+    afterEach(() => {
+        consoleErrorSpy.mockRestore();
+        process.env = originalEnv;
+    });
+    async function setupServer() {
+        const { Server } = await import('@modelcontextprotocol/sdk/server/index.js');
+        vi.mocked(Server).mockImplementation(() => {
+            mockServerInstance = {
+                setRequestHandler: vi.fn((schema, handler) => {
+                    handlers.set(schema.name, handler);
+                }),
+                connect: vi.fn(),
+                close: vi.fn(),
+                onerror: undefined
+            };
+            return mockServerInstance;
+        });
+        const module = await import('../server.js');
+        const { ClaudeCodeServer } = module;
+        const server = new ClaudeCodeServer();
+        return { server, module, handlers };
+    }
+    describe('run tool with PID return', () => {
+        it('should return PID immediately when starting a process', async () => {
+            const { handlers } = await setupServer();
+            // Create a mock process
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12345;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            const result = await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            const response = JSON.parse(result.content[0].text);
+            expect(response.pid).toBe(12345);
+            expect(response.status).toBe('started');
+            expect(response.message).toBe('claude process started successfully');
+        });
+        it('should handle process with model parameter', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12346;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp',
+                        model: 'opus'
+                    }
+                }
+            });
+            expect(mockSpawn).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['--model', 'opus']), expect.any(Object));
+        });
+        it('should handle Japanese prompts with newlines', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12360;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const japanesePrompt = `日本語のテストプロンプトです。
+これは改行を含んでいます。
+さらに、特殊文字も含みます：「こんにちは」、『世界』
+最後の行です。`;
+            const callToolHandler = handlers.get('callTool');
+            const result = await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: japanesePrompt,
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Verify PID is returned
+            const response = JSON.parse(result.content[0].text);
+            expect(response.pid).toBe(12360);
+            // Verify spawn was called with the correct prompt including newlines
+            expect(mockSpawn).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['-p', japanesePrompt]), expect.any(Object));
+            // Verify the prompt is stored correctly in process manager
+            const getResult = await callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 12360
+                    }
+                }
+            });
+            const processInfo = JSON.parse(getResult.content[0].text);
+            expect(processInfo.prompt).toBe(japanesePrompt);
+        });
+        it('should handle very long Japanese prompts with multiple paragraphs', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12361;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const longJapanesePrompt = `# タスク：ファイル管理システムの作成
+
+以下の要件に従って、ファイル管理システムを作成してください：
+
+1. **基本機能**
+   - ファイルの作成、読み取り、更新、削除（CRUD）
+   - ディレクトリの作成と管理
+   - ファイルの検索機能
+
+2. **追加機能**
+   - ファイルのバージョン管理
+   - アクセス権限の設定
+   - ログ記録機能
+
+3. **技術要件**
+   - TypeScriptを使用
+   - テストコードを含める
+   - ドキュメントを日本語で作成
+
+注意事項：
+- エラーハンドリングを適切に行う
+- パフォーマンスを考慮した実装
+- セキュリティに配慮すること
+
+よろしくお願いします。`;
+            const callToolHandler = handlers.get('callTool');
+            const result = await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: longJapanesePrompt,
+                        workFolder: '/tmp',
+                        model: 'sonnet'
+                    }
+                }
+            });
+            // Verify PID is returned
+            const response = JSON.parse(result.content[0].text);
+            expect(response.pid).toBe(12361);
+            // Verify spawn was called with the complete long prompt
+            expect(mockSpawn).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['-p', longJapanesePrompt]), expect.any(Object));
+            // Verify list_processes returns basic info
+            const listResult = await callToolHandler({
+                params: {
+                    name: 'list_processes',
+                    arguments: {}
+                }
+            });
+            const processes = JSON.parse(listResult.content[0].text);
+            const process = processes.find((p) => p.pid === 12361);
+            expect(process.pid).toBe(12361);
+            expect(process.agent).toBe('claude');
+            expect(process.status).toBe('running');
+        });
+        it('should handle prompts with special characters and escape sequences', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12362;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            // Test with various special characters
+            const specialPrompt = `特殊文字のテスト:
+\t- タブ文字
+\n- 明示的な改行
+"ダブルクォート" と 'シングルクォート'
+バックスラッシュ: \\
+Unicodeテスト: 🎌 🗾 ✨
+環境変数風: $HOME と \${USER}`;
+            const callToolHandler = handlers.get('callTool');
+            const result = await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: specialPrompt,
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Verify PID is returned
+            const response = JSON.parse(result.content[0].text);
+            expect(response.pid).toBe(12362);
+            // Verify spawn was called with the special characters intact
+            expect(mockSpawn).toHaveBeenCalledWith(expect.any(String), expect.arrayContaining(['-p', specialPrompt]), expect.any(Object));
+        });
+        it('should throw error if process fails to start', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = undefined; // No PID means process failed to start
+            mockProcess.stdout = new EventEmitter();
+            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'
+                    }
+                }
+            })).rejects.toThrow('Failed to start claude CLI process');
+        });
+    });
+    describe('list_processes tool', () => {
+        it('should list all processes', async () => {
+            const { handlers } = await setupServer();
+            // Start a process first
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12347;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt for listing',
+                        workFolder: '/tmp',
+                        model: 'sonnet'
+                    }
+                }
+            });
+            // Simulate JSON output with session_id
+            const jsonOutput = {
+                session_id: 'list-test-session-789',
+                status: 'running'
+            };
+            mockProcess.stdout.emit('data', JSON.stringify(jsonOutput));
+            // List processes
+            const listResult = await callToolHandler({
+                params: {
+                    name: 'list_processes',
+                    arguments: {}
+                }
+            });
+            const processes = JSON.parse(listResult.content[0].text);
+            expect(processes).toHaveLength(1);
+            expect(processes[0].pid).toBe(12347);
+            expect(processes[0].status).toBe('running');
+            expect(processes[0].agent).toBe('claude');
+        });
+        it('should list process with correct agent type', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12348;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // List processes
+            const listResult = await callToolHandler({
+                params: {
+                    name: 'list_processes',
+                    arguments: {}
+                }
+            });
+            const processes = JSON.parse(listResult.content[0].text);
+            expect(processes[0].pid).toBe(12348);
+            expect(processes[0].agent).toBe('claude');
+            expect(processes[0].status).toBe('running');
+        });
+    });
+    describe('get_result tool', () => {
+        it('should get process output', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12349;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Simulate JSON output from Claude CLI
+            const claudeJsonOutput = {
+                session_id: 'test-session-123',
+                status: 'success',
+                message: 'Task completed'
+            };
+            mockProcess.stdout.emit('data', JSON.stringify(claudeJsonOutput));
+            mockProcess.stderr.emit('data', 'Warning from stderr\n');
+            // Get result
+            const result = await callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 12349
+                    }
+                }
+            });
+            const processInfo = JSON.parse(result.content[0].text);
+            expect(processInfo.pid).toBe(12349);
+            expect(processInfo.status).toBe('running');
+            expect(processInfo.agentOutput).toEqual(claudeJsonOutput);
+            expect(processInfo.session_id).toBe('test-session-123');
+        });
+        it('should show completed status when process exits', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12350;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Simulate process completion with JSON output
+            const completedJsonOutput = {
+                session_id: 'completed-session-456',
+                status: 'completed',
+                files_created: ['test.txt'],
+                summary: 'Created test file successfully'
+            };
+            mockProcess.stdout.emit('data', JSON.stringify(completedJsonOutput));
+            mockProcess.emit('close', 0);
+            // Get result
+            const result = await callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 12350
+                    }
+                }
+            });
+            const processInfo = JSON.parse(result.content[0].text);
+            expect(processInfo.status).toBe('completed');
+            expect(processInfo.exitCode).toBe(0);
+            expect(processInfo.agentOutput).toEqual(completedJsonOutput);
+            expect(processInfo.session_id).toBe('completed-session-456');
+        });
+        it('should throw error for non-existent PID', async () => {
+            const { handlers } = await setupServer();
+            const callToolHandler = handlers.get('callTool');
+            await expect(callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 99999
+                    }
+                }
+            })).rejects.toThrow('Process with PID 99999 not found');
+        });
+        it('should throw error for invalid PID parameter', async () => {
+            const { handlers } = await setupServer();
+            const callToolHandler = handlers.get('callTool');
+            await expect(callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 'not-a-number'
+                    }
+                }
+            })).rejects.toThrow('Missing or invalid required parameter: pid');
+        });
+        it('should handle non-JSON output gracefully', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12355;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Simulate non-JSON output
+            mockProcess.stdout.emit('data', 'This is plain text output, not JSON');
+            mockProcess.stderr.emit('data', 'Some error occurred');
+            // Get result
+            const result = await callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 12355
+                    }
+                }
+            });
+            const processInfo = JSON.parse(result.content[0].text);
+            expect(processInfo.pid).toBe(12355);
+            expect(processInfo.status).toBe('running');
+            expect(processInfo.stdout).toBe('This is plain text output, not JSON');
+            expect(processInfo.stderr).toBe('Some error occurred');
+            expect(processInfo.claudeOutput).toBeUndefined();
+            expect(processInfo.session_id).toBeUndefined();
+        });
+    });
+    describe('kill_process tool', () => {
+        it('should kill a running process', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12351;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Kill the process
+            const killResult = await callToolHandler({
+                params: {
+                    name: 'kill_process',
+                    arguments: {
+                        pid: 12351
+                    }
+                }
+            });
+            const response = JSON.parse(killResult.content[0].text);
+            expect(response.status).toBe('terminated');
+            expect(response.message).toBe('Process terminated successfully');
+            expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
+        });
+        it('should handle already terminated process', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12352;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start and complete a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Simulate process completion
+            mockProcess.emit('close', 0);
+            // Try to kill the already completed process
+            const killResult = await callToolHandler({
+                params: {
+                    name: 'kill_process',
+                    arguments: {
+                        pid: 12352
+                    }
+                }
+            });
+            const response = JSON.parse(killResult.content[0].text);
+            expect(response.status).toBe('completed');
+            expect(response.message).toBe('Process already terminated');
+            expect(mockProcess.kill).not.toHaveBeenCalled();
+        });
+        it('should throw error for non-existent PID', async () => {
+            const { handlers } = await setupServer();
+            const callToolHandler = handlers.get('callTool');
+            await expect(callToolHandler({
+                params: {
+                    name: 'kill_process',
+                    arguments: {
+                        pid: 99999
+                    }
+                }
+            })).rejects.toThrow('Process with PID 99999 not found');
+        });
+    });
+    describe('Tool routing', () => {
+        it('should throw error for unknown tool', async () => {
+            const { handlers } = await setupServer();
+            const callToolHandler = handlers.get('callTool');
+            await expect(callToolHandler({
+                params: {
+                    name: 'unknown_tool',
+                    arguments: {}
+                }
+            })).rejects.toThrow('Tool unknown_tool not found');
+        });
+    });
+    describe('Process error handling', () => {
+        it('should handle process errors', async () => {
+            const { handlers } = await setupServer();
+            const mockProcess = new EventEmitter();
+            mockProcess.pid = 12353;
+            mockProcess.stdout = new EventEmitter();
+            mockProcess.stderr = new EventEmitter();
+            mockProcess.kill = vi.fn();
+            mockSpawn.mockReturnValue(mockProcess);
+            const callToolHandler = handlers.get('callTool');
+            // Start a process
+            await callToolHandler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test prompt',
+                        workFolder: '/tmp'
+                    }
+                }
+            });
+            // Simulate process error
+            mockProcess.emit('error', new Error('spawn error'));
+            // Get result to check error was recorded
+            const result = await callToolHandler({
+                params: {
+                    name: 'get_result',
+                    arguments: {
+                        pid: 12353
+                    }
+                }
+            });
+            const processInfo = JSON.parse(result.content[0].text);
+            expect(processInfo.status).toBe('failed');
+            expect(processInfo.stderr).toContain('Process error: spawn error');
+        });
+    });
+});