ai-cli-mcp 2.3.0 → 2.3.2

package/dist/__tests__/setup.js

@@ -0,0 +1,11 @@
+// Global test setup
+import { beforeAll, afterAll } from 'vitest';
+import { getSharedMock, cleanupSharedMock } from './utils/persistent-mock.js';
+beforeAll(async () => {
+    console.error('[TEST SETUP] Creating shared mock for all tests...');
+    await getSharedMock();
+});
+afterAll(async () => {
+    console.error('[TEST SETUP] Cleaning up shared mock...');
+    await cleanupSharedMock();
+});

package/dist/__tests__/utils/claude-mock.js

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+/**
+ * Mock Claude CLI for testing
+ * This creates a fake Claude CLI that can be used during testing
+ */
+export class ClaudeMock {
+    mockPath;
+    responses = new Map();
+    constructor(binaryName = 'claude') {
+        // Always use /tmp directory for mocks in tests
+        this.mockPath = join('/tmp', 'claude-code-test-mock', binaryName);
+    }
+    /**
+     * Setup the mock Claude CLI
+     */
+    async setup() {
+        const dir = dirname(this.mockPath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Create a simple bash script that echoes responses
+        const mockScript = `#!/bin/bash
+# Mock Claude CLI for testing
+
+# Extract the prompt from arguments
+prompt=""
+verbose=false
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    -p|--prompt)
+      prompt="$2"
+      shift 2
+      ;;
+    --verbose)
+      verbose=true
+      shift
+      ;;
+    --yes|-y|--dangerously-skip-permissions)
+      shift
+      ;;
+    *)
+      shift
+      ;;
+  esac
+done
+
+# Mock responses based on prompt
+if [[ "$prompt" == *"create"* ]]; then
+  echo "Created file successfully"
+elif [[ "$prompt" == *"Create"* ]]; then
+  echo "Created file successfully"  
+elif [[ "$prompt" == *"git"* ]] && [[ "$prompt" == *"commit"* ]]; then
+  echo "Committed changes successfully"
+elif [[ "$prompt" == *"error"* ]]; then
+  echo "Error: Mock error response" >&2
+  exit 1
+else
+  echo "Command executed successfully"
+fi
+`;
+        writeFileSync(this.mockPath, mockScript);
+        // Make executable
+        const { chmod } = await import('node:fs/promises');
+        await chmod(this.mockPath, 0o755);
+    }
+    /**
+     * Cleanup the mock Claude CLI
+     */
+    async cleanup() {
+        const { rm } = await import('node:fs/promises');
+        await rm(this.mockPath, { force: true });
+    }
+    /**
+     * Add a mock response for a specific prompt pattern
+     */
+    addResponse(pattern, response) {
+        this.responses.set(pattern, response);
+    }
+}

package/dist/__tests__/utils/mcp-client.js

@@ -0,0 +1,121 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+/**
+ * Mock MCP client for testing the server
+ */
+export class MCPTestClient extends EventEmitter {
+    serverPath;
+    env;
+    server = null;
+    requestId = 0;
+    pendingRequests = new Map();
+    buffer = '';
+    constructor(serverPath, env = {}) {
+        super();
+        this.serverPath = serverPath;
+        this.env = env;
+    }
+    async connect() {
+        return new Promise((resolve, reject) => {
+            this.server = spawn('node', [this.serverPath], {
+                env: { ...process.env, ...this.env },
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            this.server.stdout?.on('data', (data) => {
+                this.handleData(data.toString());
+            });
+            this.server.stderr?.on('data', (data) => {
+                console.error('Server stderr:', data.toString());
+            });
+            this.server.on('error', (error) => {
+                reject(error);
+            });
+            this.server.on('spawn', () => {
+                resolve();
+            });
+        });
+    }
+    async disconnect() {
+        if (this.server) {
+            this.server.kill();
+            await new Promise((resolve) => {
+                this.server.on('exit', resolve);
+            });
+            this.server = null;
+        }
+    }
+    handleData(data) {
+        this.buffer += data;
+        const lines = this.buffer.split('\n');
+        this.buffer = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const response = JSON.parse(line);
+                if (response.id && this.pendingRequests.has(response.id)) {
+                    const pending = this.pendingRequests.get(response.id);
+                    this.pendingRequests.delete(response.id);
+                    pending.resolve(response);
+                }
+                else {
+                    this.emit('notification', response);
+                }
+            }
+            catch (error) {
+                console.error('Failed to parse response:', line, error);
+            }
+        }
+    }
+    async sendRequest(method, params) {
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: '2.0',
+            method,
+            params,
+            id,
+        };
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            this.server?.stdin?.write(JSON.stringify(request) + '\n');
+            // Timeout after 30 seconds
+            setTimeout(() => {
+                if (this.pendingRequests.has(id)) {
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request ${id} timed out`));
+                }
+            }, 30000);
+        });
+    }
+    async callTool(name, args) {
+        const response = await this.sendRequest('tools/call', {
+            name,
+            arguments: args,
+        });
+        if (response.error) {
+            throw new Error(`Tool call failed: ${response.error.message}`);
+        }
+        return response.result?.content;
+    }
+    async listTools() {
+        const response = await this.sendRequest('tools/list');
+        return response.result?.tools || [];
+    }
+}
+/**
+ * Default server path
+ */
+const DEFAULT_SERVER_PATH = 'dist/server.js';
+/**
+ * Create a test client with standard configuration
+ * Automatically unsets VITEST env so the server actually starts
+ */
+export function createTestClient(options = {}) {
+    const { serverPath = DEFAULT_SERVER_PATH, claudeCliName = '/tmp/claude-code-test-mock/claudeMocked', debug = true, env = {}, } = options;
+    return new MCPTestClient(serverPath, {
+        VITEST: '', // Unset so server starts
+        MCP_CLAUDE_DEBUG: debug ? 'true' : '',
+        CLAUDE_CLI_NAME: claudeCliName,
+        ...env,
+    });
+}

package/dist/__tests__/utils/persistent-mock.js

@@ -0,0 +1,25 @@
+import { ClaudeMock } from './claude-mock.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+let sharedMock = null;
+export async function getSharedMock() {
+    if (!sharedMock) {
+        sharedMock = new ClaudeMock('claudeMocked');
+    }
+    // Always ensure mock exists
+    const mockPath = join('/tmp', 'claude-code-test-mock', 'claudeMocked');
+    if (!existsSync(mockPath)) {
+        console.error(`[DEBUG] Mock not found at ${mockPath}, creating it...`);
+        await sharedMock.setup();
+    }
+    else {
+        console.error(`[DEBUG] Mock already exists at ${mockPath}`);
+    }
+    return sharedMock;
+}
+export async function cleanupSharedMock() {
+    if (sharedMock) {
+        await sharedMock.cleanup();
+        sharedMock = null;
+    }
+}

package/dist/__tests__/utils/test-helpers.js

@@ -0,0 +1,11 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export function verifyMockExists(binaryName) {
+    const mockPath = join('/tmp', 'claude-code-test-mock', binaryName);
+    return existsSync(mockPath);
+}
+export async function ensureMockExists(mock) {
+    if (!verifyMockExists('claudeMocked')) {
+        await mock.setup();
+    }
+}

package/dist/__tests__/validation.test.js

@@ -0,0 +1,235 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { z } from 'zod';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+// Mock dependencies
+vi.mock('node:child_process', () => ({
+    spawn: vi.fn()
+}));
+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 McpError extends Error {
+        code;
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+            this.name = 'McpError';
+        }
+    }
+}));
+const mockExistsSync = vi.mocked(existsSync);
+const mockHomedir = vi.mocked(homedir);
+describe('Argument Validation Tests', () => {
+    let consoleErrorSpy;
+    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();
+        vi.unmock('../server.js');
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        // Set up process.env
+        process.env = { ...process.env };
+    });
+    describe('Tool Arguments Schema', () => {
+        it('should validate valid arguments', 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;
+            // Find tool definition  
+            const listToolsCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'listTools');
+            const listHandler = listToolsCall[1];
+            const tools = await listHandler();
+            const claudeCodeTool = tools.tools[0];
+            // Extract schema from tool definition
+            const schema = z.object({
+                prompt: z.string(),
+                workFolder: z.string(),
+                model: z.string().optional(),
+                session_id: z.string().optional()
+            });
+            // Test valid cases
+            expect(() => schema.parse({ prompt: 'test', workFolder: '/tmp' })).not.toThrow();
+            expect(() => schema.parse({ prompt: 'test', workFolder: '/tmp', model: 'sonnet' })).not.toThrow();
+        });
+        it('should reject invalid arguments', 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;
+            // Find tool definition  
+            const listToolsCall = mockServerInstance.setRequestHandler.mock.calls.find((call) => call[0].name === 'listTools');
+            const listHandler = listToolsCall[1];
+            const tools = await listHandler();
+            const claudeCodeTool = tools.tools[0];
+            // Extract schema from tool definition
+            const schema = z.object({
+                prompt: z.string(),
+                workFolder: z.string(),
+                model: z.string().optional(),
+                session_id: z.string().optional()
+            });
+            // Test invalid cases
+            expect(() => schema.parse({})).toThrow(); // Missing prompt and workFolder
+            expect(() => schema.parse({ prompt: 'test' })).toThrow(); // Missing workFolder
+            expect(() => schema.parse({ prompt: 123, workFolder: '/tmp' })).toThrow(); // Wrong prompt type
+            expect(() => schema.parse({ prompt: 'test', workFolder: 123 })).toThrow(); // Wrong workFolder type
+        });
+        it('should handle missing required fields', async () => {
+            const schema = z.object({
+                prompt: z.string(),
+                workFolder: z.string(),
+                model: z.string().optional(),
+                session_id: z.string().optional()
+            });
+            try {
+                schema.parse({});
+            }
+            catch (error) {
+                // Both prompt and workFolder are required
+                expect(error.errors.length).toBe(2);
+                expect(error.errors.some((e) => e.path[0] === 'prompt')).toBe(true);
+                expect(error.errors.some((e) => e.path[0] === 'workFolder')).toBe(true);
+            }
+        });
+        it('should allow optional fields to be undefined', async () => {
+            const schema = z.object({
+                prompt: z.string(),
+                workFolder: z.string(),
+                model: z.string().optional(),
+                session_id: z.string().optional()
+            });
+            const result = schema.parse({ prompt: 'test', workFolder: '/tmp' });
+            expect(result.model).toBeUndefined();
+            expect(result.session_id).toBeUndefined();
+        });
+        it('should handle extra fields gracefully', async () => {
+            const schema = z.object({
+                prompt: z.string(),
+                workFolder: z.string(),
+                model: z.string().optional(),
+                session_id: z.string().optional()
+            });
+            // By default, Zod strips unknown keys
+            const result = schema.parse({
+                prompt: 'test',
+                workFolder: '/tmp',
+                extraField: 'ignored'
+            });
+            expect(result).toEqual({ prompt: 'test', workFolder: '/tmp' });
+            expect(result).not.toHaveProperty('extraField');
+        });
+    });
+    describe('Runtime Argument Validation', () => {
+        let handlers;
+        let mockServerInstance;
+        async function setupServer() {
+            // Reset modules to ensure fresh import
+            vi.resetModules();
+            // Re-setup mocks after reset
+            const { existsSync } = await import('node:fs');
+            const { homedir } = await import('node:os');
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(homedir).mockReturnValue('/home/user');
+            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');
+            // @ts-ignore
+            const { ClaudeCodeServer } = module;
+            const server = new ClaudeCodeServer();
+            return { server, handlers };
+        }
+        beforeEach(() => {
+            handlers = new Map();
+            // Re-setup mocks after vi.resetModules() in outer beforeEach
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockReturnValue(true);
+        });
+        it('should validate workFolder is a string when provided', async () => {
+            mockHomedir.mockReturnValue('/home/user');
+            mockExistsSync.mockReturnValue(true);
+            await setupServer();
+            const handler = handlers.get('callTool');
+            // Test with non-string workFolder
+            await expect(handler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: 'test',
+                        workFolder: 123 // Invalid type
+                    }
+                }
+            })).rejects.toThrow();
+        });
+        it('should reject empty string prompt', async () => {
+            await setupServer();
+            const handler = handlers.get('callTool');
+            // Empty string prompt should be rejected
+            await expect(handler({
+                params: {
+                    name: 'run',
+                    arguments: {
+                        prompt: '', // Empty prompt
+                        workFolder: '/tmp'
+                    }
+                }
+            })).rejects.toThrow('Either prompt or prompt_file must be provided');
+        });
+    });
+});

package/dist/__tests__/version-print.test.js

@@ -0,0 +1,65 @@
+import { describe, it, expect, beforeEach, afterEach, vi } 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 } from './utils/persistent-mock.js';
+describe('Version Print on First Use', () => {
+    let client;
+    let testDir;
+    let consoleErrorSpy;
+    beforeEach(async () => {
+        // Ensure mock exists
+        await getSharedMock();
+        // Create a temporary directory for test files
+        testDir = mkdtempSync(join(tmpdir(), 'claude-code-test-'));
+        // Spy on console.error
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        client = createTestClient({ debug: false });
+        await client.connect();
+    });
+    afterEach(async () => {
+        // Disconnect client
+        await client.disconnect();
+        // Clean up test directory
+        rmSync(testDir, { recursive: true, force: true });
+        // Restore console.error spy
+        consoleErrorSpy.mockRestore();
+    });
+    it('should print version and startup time only on first use', async () => {
+        // First tool call
+        await client.callTool('run', {
+            prompt: 'echo "test 1"',
+            workFolder: testDir,
+        });
+        // Find the version print in the console.error calls
+        const findVersionCall = (calls) => {
+            return calls.find(call => {
+                const str = call[1] || call[0]; // message might be first or second param
+                return typeof str === 'string' && str.includes('ai_cli_mcp v') && str.includes('started at');
+            });
+        };
+        // Check that version was printed on first use
+        const versionCall = findVersionCall(consoleErrorSpy.mock.calls);
+        expect(versionCall).toBeDefined();
+        expect(versionCall[1]).toMatch(/ai_cli_mcp v[0-9]+\.[0-9]+\.[0-9]+ started at \d{4}-\d{2}-\d{2}T/);
+        // Clear the spy but keep the spy active
+        consoleErrorSpy.mockClear();
+        // Second tool call
+        await client.callTool('run', {
+            prompt: 'echo "test 2"',
+            workFolder: testDir,
+        });
+        // Check that version was NOT printed on second use
+        const secondVersionCall = findVersionCall(consoleErrorSpy.mock.calls);
+        expect(secondVersionCall).toBeUndefined();
+        // Third tool call
+        await client.callTool('run', {
+            prompt: 'echo "test 3"',
+            workFolder: testDir,
+        });
+        // Should still not have been called with version print
+        const thirdVersionCall = findVersionCall(consoleErrorSpy.mock.calls);
+        expect(thirdVersionCall).toBeUndefined();
+    });
+});