ai-cli-mcp 2.1.0 → 2.3.0

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');
-        });
-    });
-});

package/dist/__tests__/mocks.js

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

package/dist/__tests__/model-alias.test.js

@@ -1,36 +0,0 @@
-import { describe, it, expect } from 'vitest';
-// Test the model alias resolution logic directly
-describe('Model Alias Resolution', () => {
-    // Define the same MODEL_ALIASES as in server.ts
-    const MODEL_ALIASES = {
-        'haiku': 'claude-3-5-haiku-20241022'
-    };
-    // Replicate the resolveModelAlias function
-    function resolveModelAlias(model) {
-        return MODEL_ALIASES[model] || model;
-    }
-    it('should resolve haiku alias to full model name', () => {
-        expect(resolveModelAlias('haiku')).toBe('claude-3-5-haiku-20241022');
-    });
-    it('should pass through non-alias model names unchanged', () => {
-        expect(resolveModelAlias('sonnet')).toBe('sonnet');
-        expect(resolveModelAlias('opus')).toBe('opus');
-        expect(resolveModelAlias('claude-3-opus-20240229')).toBe('claude-3-opus-20240229');
-    });
-    it('should pass through empty strings', () => {
-        expect(resolveModelAlias('')).toBe('');
-    });
-    it('should be case-sensitive', () => {
-        // Should not resolve uppercase version
-        expect(resolveModelAlias('Haiku')).toBe('Haiku');
-        expect(resolveModelAlias('HAIKU')).toBe('HAIKU');
-    });
-    it('should handle undefined input gracefully', () => {
-        // TypeScript would normally prevent this, but testing for runtime safety
-        expect(resolveModelAlias(undefined)).toBe(undefined);
-    });
-    it('should handle null input gracefully', () => {
-        // TypeScript would normally prevent this, but testing for runtime safety
-        expect(resolveModelAlias(null)).toBe(null);
-    });
-});