ai-cli-mcp 2.6.0 → 2.7.0

package/src/cli-builder.ts

@@ -0,0 +1,190 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve as pathResolve, isAbsolute } from 'node:path';
+
+// Model alias mappings for user-friendly model names
+export const MODEL_ALIASES: Record<string, string> = {
+  'claude-ultra': 'opus',
+  'codex-ultra': 'gpt-5.3-codex',
+  'gemini-ultra': 'gemini-3-pro-preview'
+};
+
+export const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
+
+/**
+ * Resolves model aliases to their full model names
+ * @param model - The model name or alias to resolve
+ * @returns The full model name, or the original value if no alias exists
+ */
+export function resolveModelAlias(model: string): string {
+  return MODEL_ALIASES[model] || model;
+}
+
+/**
+ * Validates and normalizes reasoning effort parameter.
+ * @returns normalized reasoning effort string, or '' if not applicable
+ * @throws Error for invalid values (plain Error, not MCP-specific)
+ */
+export function getReasoningEffort(model: string, rawValue: unknown): string {
+  if (typeof rawValue !== 'string') {
+    return '';
+  }
+  const trimmed = rawValue.trim();
+  if (!trimmed) {
+    return '';
+  }
+  const normalized = trimmed.toLowerCase();
+  if (!ALLOWED_REASONING_EFFORTS.has(normalized)) {
+    throw new Error(
+      `Invalid reasoning_effort: ${rawValue}. Allowed values: low, medium, high, xhigh.`
+    );
+  }
+  if (!model.startsWith('gpt-')) {
+    throw new Error(
+      'reasoning_effort is only supported for Codex models (gpt-*).'
+    );
+  }
+  return normalized;
+}
+
+export interface CliCommand {
+  cliPath: string;
+  args: string[];
+  cwd: string;
+  agent: 'claude' | 'codex' | 'gemini';
+  prompt: string;
+  resolvedModel: string;
+}
+
+export interface BuildCliCommandOptions {
+  prompt?: string;
+  prompt_file?: string;
+  workFolder: string;
+  model?: string;
+  session_id?: string;
+  reasoning_effort?: string;
+  cliPaths: { claude: string; codex: string; gemini: string };
+}
+
+/**
+ * Build a CLI command from the given options.
+ * This is a pure function (aside from filesystem reads for prompt_file / workFolder validation).
+ * @throws Error on validation failures
+ */
+export function buildCliCommand(options: BuildCliCommandOptions): CliCommand {
+  // Validate workFolder
+  if (!options.workFolder || typeof options.workFolder !== 'string') {
+    throw new Error('Missing or invalid required parameter: workFolder');
+  }
+
+  // Validate prompt / prompt_file
+  const hasPrompt = !!options.prompt && typeof options.prompt === 'string' && options.prompt.trim() !== '';
+  const hasPromptFile = !!options.prompt_file && typeof options.prompt_file === 'string' && options.prompt_file.trim() !== '';
+
+  if (!hasPrompt && !hasPromptFile) {
+    throw new Error('Either prompt or prompt_file must be provided');
+  }
+
+  if (hasPrompt && hasPromptFile) {
+    throw new Error('Cannot specify both prompt and prompt_file. Please use only one.');
+  }
+
+  // Determine prompt
+  let prompt: string;
+  if (hasPrompt) {
+    prompt = options.prompt!;
+  } else {
+    const promptFilePath = isAbsolute(options.prompt_file!)
+      ? options.prompt_file!
+      : pathResolve(options.workFolder, options.prompt_file!);
+
+    if (!existsSync(promptFilePath)) {
+      throw new Error(`Prompt file does not exist: ${promptFilePath}`);
+    }
+
+    try {
+      prompt = readFileSync(promptFilePath, 'utf-8');
+    } catch (error: any) {
+      throw new Error(`Failed to read prompt file: ${error.message}`);
+    }
+  }
+
+  // Resolve workFolder
+  const cwd = pathResolve(options.workFolder);
+  if (!existsSync(cwd)) {
+    throw new Error(`Working folder does not exist: ${options.workFolder}`);
+  }
+
+  // Resolve model
+  const rawModel = options.model || '';
+  const resolvedModel = resolveModelAlias(rawModel);
+
+  // Special handling for codex-ultra: default to high reasoning effort if not specified
+  let reasoningEffortArg: string | undefined = options.reasoning_effort;
+  if (rawModel === 'codex-ultra' && !reasoningEffortArg) {
+    reasoningEffortArg = 'xhigh';
+  }
+
+  const reasoningEffort = getReasoningEffort(resolvedModel, reasoningEffortArg);
+
+  // Determine agent
+  let agent: 'codex' | 'claude' | 'gemini';
+  if (resolvedModel.startsWith('gpt-')) {
+    agent = 'codex';
+  } else if (resolvedModel.startsWith('gemini')) {
+    agent = 'gemini';
+  } else {
+    agent = 'claude';
+  }
+
+  // Build CLI path and args
+  let cliPath: string;
+  let args: string[];
+
+  if (agent === 'codex') {
+    cliPath = options.cliPaths.codex;
+
+    if (options.session_id && typeof options.session_id === 'string') {
+      args = ['exec', 'resume', options.session_id];
+    } else {
+      args = ['exec'];
+    }
+
+    if (reasoningEffort) {
+      args.push('-c', `model_reasoning_effort=${reasoningEffort}`);
+    }
+    if (resolvedModel) {
+      args.push('--model', resolvedModel);
+    }
+
+    args.push('--full-auto', '--json', prompt);
+
+  } else if (agent === 'gemini') {
+    cliPath = options.cliPaths.gemini;
+    args = ['-y', '--output-format', 'json'];
+
+    if (options.session_id && typeof options.session_id === 'string') {
+      args.push('-r', options.session_id);
+    }
+
+    if (resolvedModel) {
+      args.push('--model', resolvedModel);
+    }
+
+    args.push(prompt);
+
+  } else {
+    cliPath = options.cliPaths.claude;
+    args = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];
+
+    if (options.session_id && typeof options.session_id === 'string') {
+      args.push('-r', options.session_id);
+    }
+
+    args.push('-p', prompt);
+    if (resolvedModel) {
+      args.push('--model', resolvedModel);
+    }
+  }
+
+  return { cliPath, args, cwd, agent, prompt, resolvedModel };
+}

package/src/cli-parse.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+
+const AGENTS = ['claude', 'codex', 'gemini'] as const;
+type Agent = typeof AGENTS[number];
+
+const USAGE = `Usage: npm run -s cli.run.parse -- --agent <claude|codex|gemini>
+
+Reads raw CLI output from stdin and outputs parsed JSON to stdout.
+
+Options:
+  --agent   Agent type: claude, codex, or gemini (required)
+  --help    Show this help message
+
+Examples:
+  npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" > raw.txt
+  npm run -s cli.run.parse -- --agent claude < raw.txt
+
+  # Or pipe directly
+  npm run -s cli.run -- --model sonnet --workFolder /tmp --prompt "hi" | npm run -s cli.run.parse -- --agent claude
+`;
+
+function parseArgs(argv: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+
+    const eqIdx = arg.indexOf('=');
+    if (eqIdx !== -1) {
+      result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+    } else {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = '';
+      }
+    }
+  }
+  return result;
+}
+
+function readStdin(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    process.stdin.on('data', (chunk) => chunks.push(chunk));
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    process.stdin.on('error', reject);
+  });
+}
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if ('help' in args) {
+    process.stdout.write(USAGE);
+    process.exit(0);
+  }
+
+  const agent = args.agent as Agent;
+  if (!agent || !AGENTS.includes(agent)) {
+    process.stderr.write(`Error: --agent is required (claude, codex, or gemini)\n\n`);
+    process.stderr.write(USAGE);
+    process.exit(1);
+  }
+
+  const input = await readStdin();
+
+  if (!input.trim()) {
+    process.stderr.write('Error: no input received from stdin\n');
+    process.exit(1);
+  }
+
+  let parsed: any = null;
+  switch (agent) {
+    case 'claude':
+      parsed = parseClaudeOutput(input);
+      break;
+    case 'codex':
+      parsed = parseCodexOutput(input);
+      break;
+    case 'gemini':
+      parsed = parseGeminiOutput(input);
+      break;
+  }
+
+  process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/cli.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { buildCliCommand } from './cli-builder.js';
+import { findClaudeCli, findCodexCli, findGeminiCli } from './server.js';
+
+/**
+ * Minimal argv parser. No external dependencies.
+ * Supports: --key value, --key=value
+ */
+function parseArgs(argv: string[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+
+    const eqIdx = arg.indexOf('=');
+    if (eqIdx !== -1) {
+      // --key=value
+      result[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+    } else {
+      // --key value
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('--')) {
+        result[key] = next;
+        i++;
+      } else {
+        result[key] = '';
+      }
+    }
+  }
+  return result;
+}
+
+const USAGE = `Usage: npm run -s cli.run -- --model <model> --workFolder <path> --prompt "..." [options]
+
+Options:
+  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro)
+  --workFolder         Working directory (absolute path)
+  --prompt             Prompt string (mutually exclusive with --prompt_file)
+  --prompt_file        Path to a file containing the prompt
+  --session_id         Session ID to resume
+  --reasoning_effort   Codex only: low, medium, high, xhigh
+  --help               Show this help message
+
+Raw CLI output goes to stdout. Use cli.run.parse to parse the output:
+  npm run -s cli.run -- ... > raw.txt
+  npm run -s cli.run.parse -- --agent claude < raw.txt
+`;
+
+async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if ('help' in args) {
+    process.stdout.write(USAGE);
+    process.exit(0);
+  }
+
+  if (!args.workFolder) {
+    process.stderr.write('Error: --workFolder is required\n\n');
+    process.stderr.write(USAGE);
+    process.exit(1);
+  }
+
+  if (!args.prompt && !args.prompt_file) {
+    process.stderr.write('Error: --prompt or --prompt_file is required\n\n');
+    process.stderr.write(USAGE);
+    process.exit(1);
+  }
+
+  // Resolve CLI paths
+  const cliPaths = {
+    claude: findClaudeCli(),
+    codex: findCodexCli(),
+    gemini: findGeminiCli(),
+  };
+
+  // Build command
+  let cmd;
+  try {
+    cmd = buildCliCommand({
+      prompt: args.prompt || undefined,
+      prompt_file: args.prompt_file || undefined,
+      workFolder: args.workFolder,
+      model: args.model || undefined,
+      session_id: args.session_id || undefined,
+      reasoning_effort: args.reasoning_effort || undefined,
+      cliPaths,
+    });
+  } catch (error: any) {
+    process.stderr.write(`Error: ${error.message}\n`);
+    process.exit(1);
+  }
+
+  // Log agent info to stderr (does not pollute stdout)
+  process.stderr.write(`[cli.run] agent=${cmd.agent} model=${cmd.resolvedModel || '(default)'}\n`);
+
+  // Spawn foreground process — raw output passthrough
+  const child = spawn(cmd.cliPath, cmd.args, {
+    cwd: cmd.cwd,
+    stdio: 'inherit',
+    detached: false,
+  });
+
+  const exitCode = await new Promise<number>((resolve) => {
+    child.on('close', (code) => {
+      resolve(code ?? 1);
+    });
+    child.on('error', (err) => {
+      process.stderr.write(`Process error: ${err.message}\n`);
+      resolve(1);
+    });
+  });
+
+  process.exit(exitCode);
+}
+
+main().catch((err) => {
+  process.stderr.write(`Fatal error: ${err.message}\n`);
+  process.exit(1);
+});

package/src/server.ts

@@ -9,48 +9,16 @@ import {
   type ServerResult,
 } from '@modelcontextprotocol/sdk/types.js';
 import { spawn, ChildProcess } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join, resolve as pathResolve } from 'node:path';
+import { join } from 'node:path';
 import * as path from 'path';
 import { parseCodexOutput, parseClaudeOutput, parseGeminiOutput } from './parsers.js';
+import { buildCliCommand } from './cli-builder.js';
 
 // Server version - update this when releasing new versions
 const SERVER_VERSION = "2.2.0";
 
-// Model alias mappings for user-friendly model names
-const MODEL_ALIASES: Record<string, string> = {
-  'claude-ultra': 'opus',
-  'codex-ultra': 'gpt-5.3-codex',
-  'gemini-ultra': 'gemini-3-pro-preview'
-};
-
-const ALLOWED_REASONING_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh']);
-
-function getReasoningEffort(model: string, rawValue: unknown): string {
-  if (typeof rawValue !== 'string') {
-    return '';
-  }
-  const trimmed = rawValue.trim();
-  if (!trimmed) {
-    return '';
-  }
-  const normalized = trimmed.toLowerCase();
-  if (!ALLOWED_REASONING_EFFORTS.has(normalized)) {
-    throw new McpError(
-      ErrorCode.InvalidParams,
-      `Invalid reasoning_effort: ${rawValue}. Allowed values: low, medium, high, xhigh.`
-    );
-  }
-  if (!model.startsWith('gpt-')) {
-    throw new McpError(
-      ErrorCode.InvalidParams,
-      'reasoning_effort is only supported for Codex models (gpt-*).'
-    );
-  }
-  return normalized;
-}
-
 // Define debugMode globally using const
 const debugMode = process.env.MCP_CLAUDE_DEBUG === 'true';
 
@@ -226,36 +194,8 @@ export function findClaudeCli(): string {
   return cliName;
 }
 
-/**
- * Interface for Claude Code tool arguments
- */
-interface ClaudeCodeArgs {
-  prompt?: string;
-  prompt_file?: string;
-  workFolder: string;
-  model?: string;
-  session_id?: string;
-}
-
-/**
- * Interface for Codex tool arguments
- */
-interface CodexArgs {
-  prompt?: string;
-  prompt_file?: string;
-  workFolder: string;
-  model?: string;  // Codex model id (e.g., gpt-5.2-codex)
-  reasoning_effort?: string;
-}
-
-/**
- * Resolves model aliases to their full model names
- * @param model - The model name or alias to resolve
- * @returns The full model name, or the original value if no alias exists
- */
-export function resolveModelAlias(model: string): string {
-  return MODEL_ALIASES[model] || model;
-}
+// Re-export resolveModelAlias for backward compatibility
+export { resolveModelAlias } from './cli-builder.js';
 
 // Ensure spawnAsync is defined correctly *before* the class
 export async function spawnAsync(command: string, args: string[], options?: { timeout?: number, cwd?: string }): Promise<{ stdout: string; stderr: string }> {
@@ -512,135 +452,33 @@ export class ClaudeCodeServer {
    * Handle run tool - starts Claude or Codex process and returns PID immediately
    */
   private async handleRun(toolArguments: any): Promise<ServerResult> {
-    // Validate workFolder is required
-    if (!toolArguments.workFolder || typeof toolArguments.workFolder !== 'string') {
-      throw new McpError(ErrorCode.InvalidParams, 'Missing or invalid required parameter: workFolder');
-    }
-
-    // Validate that either prompt or prompt_file is provided
-    const hasPrompt = toolArguments.prompt && typeof toolArguments.prompt === 'string' && toolArguments.prompt.trim() !== '';
-    const hasPromptFile = toolArguments.prompt_file && typeof toolArguments.prompt_file === 'string' && toolArguments.prompt_file.trim() !== '';
-
-    if (!hasPrompt && !hasPromptFile) {
-      throw new McpError(ErrorCode.InvalidParams, 'Either prompt or prompt_file must be provided');
-    }
-
-    if (hasPrompt && hasPromptFile) {
-      throw new McpError(ErrorCode.InvalidParams, 'Cannot specify both prompt and prompt_file. Please use only one.');
-    }
-
-    // Determine the prompt to use
-    let prompt: string;
-    if (hasPrompt) {
-      prompt = toolArguments.prompt;
-    } else {
-      // Read prompt from file
-      const promptFilePath = path.isAbsolute(toolArguments.prompt_file) 
-        ? toolArguments.prompt_file 
-        : pathResolve(toolArguments.workFolder, toolArguments.prompt_file);
-      
-      if (!existsSync(promptFilePath)) {
-        throw new McpError(ErrorCode.InvalidParams, `Prompt file does not exist: ${promptFilePath}`);
-      }
-      
-      try {
-        prompt = readFileSync(promptFilePath, 'utf-8');
-      } catch (error: any) {
-        throw new McpError(ErrorCode.InvalidParams, `Failed to read prompt file: ${error.message}`);
-      }
-    }
-    
-    // Determine working directory
-    const resolvedCwd = pathResolve(toolArguments.workFolder);
-    if (!existsSync(resolvedCwd)) {
-      throw new McpError(ErrorCode.InvalidParams, `Working folder does not exist: ${toolArguments.workFolder}`);
-    }
-    const effectiveCwd = resolvedCwd;
-
     // Print version on first use
     if (isFirstToolUse) {
       console.error(`ai_cli_mcp v${SERVER_VERSION} started at ${serverStartupTime}`);
       isFirstToolUse = false;
     }
 
-    // Determine which agent to use based on model name
-    const rawModel = toolArguments.model || '';
-    const resolvedModel = resolveModelAlias(rawModel);
-
-    // Special handling for codex-ultra: default to high reasoning effort if not specified
-    let reasoningEffortArg = toolArguments.reasoning_effort;
-    if (rawModel === 'codex-ultra' && !reasoningEffortArg) {
-      reasoningEffortArg = 'xhigh';
-    }
-
-    const reasoningEffort = getReasoningEffort(resolvedModel, reasoningEffortArg);
-    let agent: 'codex' | 'claude' | 'gemini';
-
-    if (resolvedModel.startsWith('gpt-')) {
-      agent = 'codex';
-    } else if (resolvedModel.startsWith('gemini')) {
-      agent = 'gemini';
-    } else {
-      agent = 'claude';
+    // Build CLI command (validation + args assembly)
+    let cmd;
+    try {
+      cmd = buildCliCommand({
+        prompt: toolArguments.prompt,
+        prompt_file: toolArguments.prompt_file,
+        workFolder: toolArguments.workFolder,
+        model: toolArguments.model,
+        session_id: toolArguments.session_id,
+        reasoning_effort: toolArguments.reasoning_effort,
+        cliPaths: {
+          claude: this.claudeCliPath,
+          codex: this.codexCliPath,
+          gemini: this.geminiCliPath,
+        },
+      });
+    } catch (error: any) {
+      throw new McpError(ErrorCode.InvalidParams, error.message);
     }
 
-    let cliPath: string;
-    let processArgs: string[];
-
-    if (agent === 'codex') {
-      // Handle Codex
-      cliPath = this.codexCliPath;
-
-      // Use 'exec resume' if session_id is provided, otherwise use 'exec'
-      if (toolArguments.session_id && typeof toolArguments.session_id === 'string') {
-        processArgs = ['exec', 'resume', toolArguments.session_id];
-      } else {
-        processArgs = ['exec'];
-      }
-
-      // Handle Codex models.
-      if (reasoningEffort) {
-        processArgs.push('-c', `model_reasoning_effort=${reasoningEffort}`);
-      }
-      if (resolvedModel) {
-        processArgs.push('--model', resolvedModel);
-      }
-
-      processArgs.push('--full-auto', '--json', prompt);
-
-    } else if (agent === 'gemini') {
-      // Handle Gemini
-      cliPath = this.geminiCliPath;
-      processArgs = ['-y', '--output-format', 'json'];
-
-      // Add session_id if provided
-      if (toolArguments.session_id && typeof toolArguments.session_id === 'string') {
-        processArgs.push('-r', toolArguments.session_id);
-      }
-
-      // Add model if specified
-      if (resolvedModel) {
-        processArgs.push('--model', resolvedModel);
-      }
-
-      // Add prompt as positional argument
-      processArgs.push(prompt);
-
-    } else {
-      // Handle Claude (default)
-      cliPath = this.claudeCliPath;
-      processArgs = ['--dangerously-skip-permissions', '--output-format', 'stream-json', '--verbose'];
-
-      // Add session_id if provided (Claude only)
-      if (toolArguments.session_id && typeof toolArguments.session_id === 'string') {
-        processArgs.push('-r', toolArguments.session_id);
-      }
-
-      processArgs.push('-p', prompt);
-      if (resolvedModel) {
-        processArgs.push('--model', resolvedModel);
-      }
-    }
+    const { cliPath, args: processArgs, cwd: effectiveCwd, agent, prompt } = cmd;
 
     // Spawn process without waiting
     const childProcess = spawn(cliPath, processArgs, {