ai-cli-mcp 2.2.0 → 2.3.1

package/.claude/settings.local.json

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

package/dist/__tests__/e2e.test.js

@@ -31,13 +31,13 @@ describe('Claude Code MCP E2E Tests', () => {
         await cleanupSharedMock();
     });
     describe('Tool Registration', () => {
-        it('should register claude_code tool', async () => {
+        it('should register run tool', async () => {
             const tools = await client.listTools();
-            expect(tools).toHaveLength(4);
-            const claudeCodeTool = tools.find((t) => t.name === 'claude_code');
+            expect(tools).toHaveLength(6);
+            const claudeCodeTool = tools.find((t) => t.name === 'run');
             expect(claudeCodeTool).toEqual({
-                name: 'claude_code',
-                description: expect.stringContaining('Claude Code Agent'),
+                name: 'run',
+                description: expect.stringContaining('AI Agent Runner'),
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -55,7 +55,7 @@ describe('Claude Code MCP E2E Tests', () => {
                         },
                         model: {
                             type: 'string',
-                            description: expect.stringContaining('Claude model'),
+                            description: expect.stringContaining('sonnet'),
                         },
                         session_id: {
                             type: 'string',
@@ -66,14 +66,14 @@ describe('Claude Code MCP E2E Tests', () => {
                 },
             });
             // 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);
+            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('claude_code', {
+            const response = await client.callTool('run', {
                 prompt: 'create a file called test.txt with content "Hello World"',
                 workFolder: testDir,
             });
@@ -83,8 +83,8 @@ describe('Claude Code MCP E2E Tests', () => {
                 }]);
         });
         it('should handle process management correctly', async () => {
-            // claude_code now returns a PID immediately
-            const response = await client.callTool('claude_code', {
+            // run now returns a PID immediately
+            const response = await client.callTool('run', {
                 prompt: 'error',
                 workFolder: testDir,
             });
@@ -98,14 +98,14 @@ describe('Claude Code MCP E2E Tests', () => {
             expect(pidMatch).toBeTruthy();
         });
         it('should reject missing workFolder', async () => {
-            await expect(client.callTool('claude_code', {
+            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('claude_code', {
+            const response = await client.callTool('run', {
                 prompt: 'Show current working directory',
                 workFolder: testDir,
             });
@@ -113,7 +113,7 @@ describe('Claude Code MCP E2E Tests', () => {
         });
         it('should reject non-existent working directory', async () => {
             const nonExistentDir = join(testDir, 'non-existent');
-            await expect(client.callTool('claude_code', {
+            await expect(client.callTool('run', {
                 prompt: 'Test prompt',
                 workFolder: nonExistentDir,
             })).rejects.toThrow(/does not exist/i);
@@ -127,8 +127,8 @@ describe('Claude Code MCP E2E Tests', () => {
         });
     });
     describe('Model Alias Handling', () => {
-        it('should resolve haiku alias when calling claude_code', async () => {
-            const response = await client.callTool('claude_code', {
+        it('should resolve haiku alias when calling run', async () => {
+            const response = await client.callTool('run', {
                 prompt: 'Test with haiku model',
                 workFolder: testDir,
                 model: 'haiku'
@@ -141,19 +141,16 @@ describe('Claude Code MCP E2E Tests', () => {
             const responseText = response[0].text;
             const pidMatch = responseText.match(/"pid":\s*(\d+)/);
             expect(pidMatch).toBeTruthy();
-            // Get the PID and check the process
+            // Get the PID and check the process using get_result
             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();
+            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(ourProcess.model).toBe('haiku');
+            expect(processData.model).toBe('haiku');
         });
         it('should pass non-alias model names unchanged', async () => {
-            const response = await client.callTool('claude_code', {
+            const response = await client.callTool('run', {
                 prompt: 'Test with sonnet model',
                 workFolder: testDir,
                 model: 'sonnet'
@@ -166,18 +163,15 @@ describe('Claude Code MCP E2E Tests', () => {
             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();
+            // 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(ourProcess.model).toBe('sonnet');
+            expect(processData.model).toBe('sonnet');
         });
         it('should work without specifying a model', async () => {
-            const response = await client.callTool('claude_code', {
+            const response = await client.callTool('run', {
                 prompt: 'Test without model parameter',
                 workFolder: testDir
             });
@@ -190,7 +184,7 @@ describe('Claude Code MCP E2E Tests', () => {
     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', {
+            const response = await client.callTool('run', {
                 prompt: 'Debug test prompt',
                 workFolder: testDir,
             });
@@ -217,7 +211,7 @@ describe('Integration Tests (Local Only)', () => {
     // 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', {
+        const response = await client.callTool('run', {
             prompt: 'Create a file called hello.txt with content "Hello from Claude"',
             workFolder: testDir,
         });
@@ -228,7 +222,7 @@ describe('Integration Tests (Local Only)', () => {
     it.skip('should handle git operations with real Claude CLI', async () => {
         await client.connect();
         // Initialize git repo
-        const response = await client.callTool('claude_code', {
+        const response = await client.callTool('run', {
             prompt: 'Initialize a git repository and create a README.md file',
             workFolder: testDir,
         });

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

@@ -30,24 +30,24 @@ describe('Claude Code Edge Cases', () => {
     });
     describe('Input Validation', () => {
         it('should reject missing prompt', async () => {
-            await expect(client.callTool('claude_code', {
+            await expect(client.callTool('run', {
                 workFolder: testDir,
             })).rejects.toThrow(/prompt/i);
         });
         it('should reject invalid prompt type', async () => {
-            await expect(client.callTool('claude_code', {
+            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('claude_code', {
+            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('claude_code', {
+            await expect(client.callTool('run', {
                 prompt: '',
                 workFolder: testDir,
             })).rejects.toThrow(/prompt/i);
@@ -56,21 +56,21 @@ describe('Claude Code Edge Cases', () => {
     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', {
+            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('claude_code', {
+            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('claude_code', {
+            const response = await client.callTool('run', {
                 prompt: 'Create a file named test$file.txt',
                 workFolder: testDir,
             });
@@ -85,7 +85,7 @@ describe('Claude Code Edge Cases', () => {
                 CLAUDE_CLI_NAME: 'non-existent-claude',
             });
             await errorClient.connect();
-            await expect(errorClient.callTool('claude_code', {
+            await expect(errorClient.callTool('run', {
                 prompt: 'Test prompt',
                 workFolder: testDir,
             })).rejects.toThrow();
@@ -94,7 +94,7 @@ describe('Claude Code Edge Cases', () => {
         it('should handle permission denied errors', async () => {
             const restrictedDir = '/root/restricted';
             // Non-existent directories now throw an error
-            await expect(client.callTool('claude_code', {
+            await expect(client.callTool('run', {
                 prompt: 'Test prompt',
                 workFolder: restrictedDir,
             })).rejects.toThrow(/does not exist/i);
@@ -102,7 +102,7 @@ describe('Claude Code Edge Cases', () => {
     });
     describe('Concurrent Requests', () => {
         it('should handle multiple simultaneous requests', async () => {
-            const promises = Array(5).fill(null).map((_, i) => client.callTool('claude_code', {
+            const promises = Array(5).fill(null).map((_, i) => client.callTool('run', {
                 prompt: `Create file test${i}.txt`,
                 workFolder: testDir,
             }));
@@ -114,7 +114,7 @@ describe('Claude Code Edge Cases', () => {
     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', {
+            const response = await client.callTool('run', {
                 prompt: longPrompt,
                 workFolder: testDir,
             });
@@ -126,7 +126,7 @@ describe('Claude Code Edge Cases', () => {
             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', {
+            await expect(client.callTool('run', {
                 prompt: 'Read file',
                 workFolder: maliciousPath,
             })).rejects.toThrow(/(does not exist|ENOTDIR)/i);

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

@@ -30,11 +30,13 @@ vi.mock('@modelcontextprotocol/sdk/types.js', () => ({
         MethodNotFound: 'MethodNotFound',
         InvalidParams: 'InvalidParams'
     },
-    McpError: vi.fn().mockImplementation((code, message) => {
-        const error = new Error(message);
-        error.code = code;
-        return error;
-    })
+    McpError: class extends Error {
+        code;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+        }
+    }
 }));
 const mockExistsSync = vi.mocked(existsSync);
 const mockSpawn = vi.mocked(spawn);
@@ -118,22 +120,15 @@ describe('Error Handling Tests', () => {
                 return mockProcess;
             });
             // Call handler
-            try {
-                await callToolHandler({
-                    params: {
-                        name: 'claude_code',
-                        arguments: {
-                            prompt: 'test',
-                            workFolder: '/tmp'
-                        }
+            await expect(callToolHandler({
+                params: {
+                    name: 'run',
+                    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');
-            }
+                }
+            })).rejects.toThrow('Failed to start claude CLI process');
         });
         it('should handle invalid argument types', async () => {
             mockHomedir.mockReturnValue('/home/user');
@@ -148,7 +143,7 @@ describe('Error Handling Tests', () => {
             const handler = callToolCall[1];
             await expect(handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: 'invalid-should-be-object'
                 }
             })).rejects.toThrow();
@@ -192,7 +187,7 @@ describe('Error Handling Tests', () => {
             });
             await expect(handler({
                 params: {
-                    name: 'claude_code',
+                    name: 'run',
                     arguments: {
                         prompt: 'test',
                         workFolder: '/tmp'