ai-cli-mcp 2.1.0 → 2.3.0

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

@@ -1,80 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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 || [];
-    }
-}

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

@@ -1,25 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,212 +0,0 @@
-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: vi.fn().mockImplementation((code, message) => {
-        const error = new Error(message);
-        error.code = code;
-        return error;
-    })
-}));
-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', () => {
-        it('should validate workFolder is a string when provided', 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];
-            // Test with non-string workFolder
-            await expect(handler({
-                params: {
-                    name: 'claude_code',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: 123 // Invalid type
-                    }
-                }
-            })).rejects.toThrow();
-        });
-        it('should reject empty string prompt', 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];
-            // Empty string prompt should be rejected
-            await expect(handler({
-                params: {
-                    name: 'claude_code',
-                    arguments: {
-                        prompt: '', // Empty prompt
-                        workFolder: '/tmp'
-                    }
-                }
-            })).rejects.toThrow('Missing or invalid required parameter: prompt');
-        });
-    });
-});

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

@@ -1,69 +0,0 @@
-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 { MCPTestClient } from './utils/mcp-client.js';
-import { getSharedMock } from './utils/persistent-mock.js';
-describe('Version Print on First Use', () => {
-    let client;
-    let testDir;
-    let consoleErrorSpy;
-    const serverPath = 'dist/server.js';
-    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(() => { });
-        // Initialize MCP client with custom binary name using absolute path
-        client = new MCPTestClient(serverPath, {
-            CLAUDE_CLI_NAME: '/tmp/claude-code-test-mock/claudeMocked',
-        });
-        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('claude_code', {
-            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('claude_code 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(/claude_code 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('claude_code', {
-            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('claude_code', {
-            prompt: 'echo "test 3"',
-            workFolder: testDir,
-        });
-        // Should still not have been called with version print
-        const thirdVersionCall = findVersionCall(consoleErrorSpy.mock.calls);
-        expect(thirdVersionCall).toBeUndefined();
-    });
-});

package/dist/parsers.js

@@ -1,68 +0,0 @@
-import { debugLog } from './server.js';
-/**
- * Parse Codex NDJSON output to extract the last agent message and token count
- */
-export function parseCodexOutput(stdout) {
-    if (!stdout)
-        return null;
-    try {
-        const lines = stdout.trim().split('\n');
-        let lastMessage = null;
-        let tokenCount = null;
-        for (const line of lines) {
-            if (line.trim()) {
-                try {
-                    const parsed = JSON.parse(line);
-                    if (parsed.msg?.type === 'agent_message') {
-                        lastMessage = parsed.msg.message;
-                    }
-                    else if (parsed.msg?.type === 'token_count') {
-                        tokenCount = parsed.msg;
-                    }
-                }
-                catch (e) {
-                    // Skip invalid JSON lines
-                    debugLog(`[Debug] Skipping invalid JSON line: ${line}`);
-                }
-            }
-        }
-        if (lastMessage || tokenCount) {
-            return {
-                message: lastMessage,
-                token_count: tokenCount
-            };
-        }
-    }
-    catch (e) {
-        debugLog(`[Debug] Failed to parse Codex NDJSON output: ${e}`);
-    }
-    return null;
-}
-/**
- * Parse Claude JSON output
- */
-export function parseClaudeOutput(stdout) {
-    if (!stdout)
-        return null;
-    try {
-        return JSON.parse(stdout);
-    }
-    catch (e) {
-        debugLog(`[Debug] Failed to parse Claude JSON output: ${e}`);
-        return null;
-    }
-}
-/**
- * Parse Gemini JSON output
- */
-export function parseGeminiOutput(stdout) {
-    if (!stdout)
-        return null;
-    try {
-        return JSON.parse(stdout);
-    }
-    catch (e) {
-        debugLog(`[Debug] Failed to parse Gemini JSON output: ${e}`);
-        return null;
-    }
-}