ai-cli-mcp 2.0.0

package/src/__tests__/setup.ts

@@ -0,0 +1,13 @@
+// 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/src/__tests__/utils/claude-mock.ts

@@ -0,0 +1,87 @@
+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 {
+  private mockPath: string;
+  private responses = new Map<string, string>();
+
+  constructor(binaryName: string = '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(): Promise<void> {
+    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(): Promise<void> {
+    const { rm } = await import('node:fs/promises');
+    await rm(this.mockPath, { force: true });
+  }
+
+  /**
+   * Add a mock response for a specific prompt pattern
+   */
+  addResponse(pattern: string, response: string): void {
+    this.responses.set(pattern, response);
+  }
+}

package/src/__tests__/utils/mcp-client.ts

@@ -0,0 +1,129 @@
+import { spawn, ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+
+export interface MCPResponse {
+  jsonrpc: string;
+  id: number;
+  result?: any;
+  error?: {
+    code: number;
+    message: string;
+    data?: any;
+  };
+}
+
+/**
+ * Mock MCP client for testing the server
+ */
+export class MCPTestClient extends EventEmitter {
+  private server: ChildProcess | null = null;
+  private requestId = 0;
+  private pendingRequests = new Map<number, {
+    resolve: (response: MCPResponse) => void;
+    reject: (error: Error) => void;
+  }>();
+  private buffer = '';
+
+  constructor(private serverPath: string, private env: Record<string, string> = {}) {
+    super();
+  }
+
+  async connect(): Promise<void> {
+    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(): Promise<void> {
+    if (this.server) {
+      this.server.kill();
+      await new Promise((resolve) => {
+        this.server!.on('exit', resolve);
+      });
+      this.server = null;
+    }
+  }
+
+  private handleData(data: string): void {
+    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: string, params?: any): Promise<any> {
+    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: string, args: any): Promise<any> {
+    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(): Promise<any> {
+    const response = await this.sendRequest('tools/list');
+    return response.result?.tools || [];
+  }
+}

package/src/__tests__/utils/persistent-mock.ts

@@ -0,0 +1,29 @@
+import { ClaudeMock } from './claude-mock.js';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+let sharedMock: ClaudeMock | null = null;
+
+export async function getSharedMock(): Promise<ClaudeMock> {
+  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(): Promise<void> {
+  if (sharedMock) {
+    await sharedMock.cleanup();
+    sharedMock = null;
+  }
+}

package/src/__tests__/utils/test-helpers.ts

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

package/src/__tests__/validation.test.ts

@@ -0,0 +1,258 @@
+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: any) {
+    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 as any).code = code;
+    return error;
+  })
+}));
+
+const mockExistsSync = vi.mocked(existsSync);
+const mockHomedir = vi.mocked(homedir);
+
+describe('Argument Validation Tests', () => {
+  let consoleErrorSpy: any;
+  let errorHandler: any = null;
+
+  function setupServerMock() {
+    errorHandler = null;
+    vi.mocked(Server).mockImplementation(function(this: any) {
+      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: any[]) => 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: any[]) => 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: any) {
+        // Both prompt and workFolder are required
+        expect(error.errors.length).toBe(2);
+        expect(error.errors.some((e: any) => e.path[0] === 'prompt')).toBe(true);
+        expect(error.errors.some((e: any) => 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: any[]) => 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: any[]) => 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/src/__tests__/version-print.test.ts

@@ -0,0 +1,86 @@
+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: MCPTestClient;
+  let testDir: string;
+  let consoleErrorSpy: any;
+  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: any[][]) => {
+      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/src/parsers.ts

@@ -0,0 +1,55 @@
+import { debugLog } from './server.js';
+
+/**
+ * Parse Codex NDJSON output to extract the last agent message and token count
+ */
+export function parseCodexOutput(stdout: string): any {
+  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: string): any {
+  if (!stdout) return null;
+  
+  try {
+    return JSON.parse(stdout);
+  } catch (e) {
+    debugLog(`[Debug] Failed to parse Claude JSON output: ${e}`);
+    return null;
+  }
+}