ai-cli-mcp 2.19.0 → 2.20.1

package/dist/__tests__/setup.js

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

@@ -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,121 +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 || [];
-    }
-}
-/**
- * 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 = process.env.TEST_CLAUDE_CLI_NAME || '/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/opencode-mock.js

@@ -1,91 +0,0 @@
-import { chmodSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-export function createOpenCodeMock(dir, options = {}) {
-    const scriptPath = join(dir, 'mock-opencode');
-    const defaultSessionId = options.defaultSessionId || 'ses-opencode-default';
-    const argsLogPath = options.argsLogPath;
-    const argsLogSection = argsLogPath
-        ? `printf '%s\n' "$*" >> "${argsLogPath}"\n`
-        : '';
-    writeFileSync(scriptPath, `#!/bin/bash
-set -euo pipefail
-
-prompt=""
-session_id=""
-session_provided=0
-model=""
-work_dir=""
-
-${argsLogSection}if [[ "\${1:-}" == "run" ]]; then
-  shift
-fi
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --format)
-      shift 2
-      ;;
-    --dir)
-      work_dir="$2"
-      shift 2
-      ;;
-    --session)
-      session_id="$2"
-      session_provided=1
-      shift 2
-      ;;
-    --model)
-      model="$2"
-      shift 2
-      ;;
-    *)
-      prompt="$1"
-      shift
-      ;;
-  esac
-done
-
-if [[ -z "$session_id" ]]; then
-  session_id="${defaultSessionId}"
-fi
-
-if [[ "$prompt" == *"sleep"* ]]; then
-  sleep 5
-fi
-
-if [[ "$prompt" == *"fail"* ]]; then
-  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
-  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"Partial failure output"}}\n' "$session_id"
-  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":42},"cost":0}}\n' "$session_id"
-  printf 'OpenCode failed for %s in %s\n' "$model" "$work_dir" >&2
-  exit 7
-fi
-
-if [[ "$prompt" == *"multi-step"* ]]; then
-  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
-  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"First step"}}\n' "$session_id"
-  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":11},"cost":0}}\n' "$session_id"
-  printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
-  printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"Second step"}}\n' "$session_id"
-  printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":22},"cost":1}}\n' "$session_id"
-  exit 0
-fi
-
-message_prefix="Initial"
-if [[ $session_provided -eq 1 ]]; then
-  message_prefix="Resumed"
-fi
-if [[ -n "$model" ]]; then
-  message_prefix="Model $model"
-  if [[ $session_provided -eq 1 ]]; then
-    message_prefix="Resumed model $model"
-  fi
-fi
-
-printf '{"type":"step_start","sessionID":"%s"}\n' "$session_id"
-printf '{"type":"text","sessionID":"%s","part":{"type":"text","text":"%s: %s"}}\n' "$session_id" "$message_prefix" "$prompt"
-printf '{"type":"step_finish","sessionID":"%s","part":{"type":"step-finish","tokens":{"total":11833},"cost":0}}\n' "$session_id"
-`, 'utf8');
-    chmodSync(scriptPath, 0o755);
-    return { scriptPath, argsLogPath };
-}

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

@@ -1,28 +0,0 @@
-import { ClaudeMock } from './claude-mock.js';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-let sharedMock = null;
-const workerId = process.env.VITEST_WORKER_ID || process.env.VITEST_POOL_ID || process.pid.toString();
-const mockName = `claudeMocked-${workerId}`;
-const mockPath = join('/tmp', 'claude-code-test-mock', mockName);
-export async function getSharedMock() {
-    if (!sharedMock) {
-        sharedMock = new ClaudeMock(mockName);
-    }
-    // Always ensure mock exists
-    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}`);
-    }
-    process.env.TEST_CLAUDE_CLI_NAME = 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,308 +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: 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();
-        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();
-            vi.doUnmock('../server.js');
-            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(),
-                reasoning_effort: 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();
-            vi.doUnmock('../server.js');
-            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(),
-                reasoning_effort: 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(),
-                reasoning_effort: 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(),
-                reasoning_effort: 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(),
-                reasoning_effort: 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(function () {
-                mockServerInstance = {
-                    setRequestHandler: vi.fn((schema, handler) => {
-                        handlers.set(schema.name, handler);
-                    }),
-                    connect: vi.fn(),
-                    close: vi.fn(),
-                    onerror: undefined
-                };
-                return mockServerInstance;
-            });
-            vi.doUnmock('../server.js');
-            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');
-        });
-        it('should reject invalid reasoning_effort values', async () => {
-            await setupServer();
-            const handler = handlers.get('callTool');
-            await expect(handler({
-                params: {
-                    name: 'run',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: '/tmp',
-                        model: 'gpt-5.2-codex',
-                        reasoning_effort: 'fast'
-                    }
-                }
-            })).rejects.toThrow(/reasoning_effort/i);
-        });
-        it('should reject reasoning_effort for unsupported model families', async () => {
-            await setupServer();
-            const handler = handlers.get('callTool');
-            await expect(handler({
-                params: {
-                    name: 'run',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: '/tmp',
-                        model: 'gemini-2.5-pro',
-                        reasoning_effort: 'low'
-                    }
-                }
-            })).rejects.toThrow(/reasoning_effort/i);
-        });
-        it.each([
-            'oc-',
-            'oc-openai',
-            'oc-/gpt-5.4',
-            'oc-openai/',
-            ' oc-openai/gpt-5.4',
-            'oc-openai/gpt-5.4 ',
-        ])('should reject malformed OpenCode model syntax at runtime: %s', async (model) => {
-            await setupServer();
-            const handler = handlers.get('callTool');
-            await expect(handler({
-                params: {
-                    name: 'run',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: '/tmp',
-                        model,
-                    }
-                }
-            })).rejects.toThrow('Invalid OpenCode model. Expected exact syntax oc-<provider/model>.');
-        });
-        it('should reject reasoning_effort for OpenCode runtime requests', async () => {
-            await setupServer();
-            const handler = handlers.get('callTool');
-            await expect(handler({
-                params: {
-                    name: 'run',
-                    arguments: {
-                        prompt: 'test',
-                        workFolder: '/tmp',
-                        model: 'opencode',
-                        reasoning_effort: 'high',
-                    }
-                }
-            })).rejects.toThrow('reasoning_effort is not supported for opencode.');
-        });
-    });
-});