ai-cli-mcp 2.10.0 → 2.12.0

package/src/cli-utils.ts

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs';
+import { accessSync, constants } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import * as path from 'path';
@@ -13,90 +13,209 @@ export function debugLog(message?: any, ...optionalParams: any[]): void {
   }
 }
 
-/**
- * Determine the Gemini CLI command/path.
- * Similar to findClaudeCli but for Gemini
- */
-export function findGeminiCli(): string {
-  debugLog('[Debug] Attempting to find Gemini CLI...');
-
-  // Check for custom CLI name from environment variable
-  const customCliName = process.env.GEMINI_CLI_NAME;
-  if (customCliName) {
-    debugLog(`[Debug] Using custom Gemini CLI name from GEMINI_CLI_NAME: ${customCliName}`);
+export interface CliBinaryStatus {
+  configuredCommand: string;
+  resolvedPath: string | null;
+  available: boolean;
+  lookup: 'env' | 'local' | 'path';
+  error?: string;
+}
 
-    // If it's an absolute path, use it directly
-    if (path.isAbsolute(customCliName)) {
-      debugLog(`[Debug] GEMINI_CLI_NAME is an absolute path: ${customCliName}`);
-      return customCliName;
-    }
+function getPathDelimiter(): string {
+  return process.platform === 'win32' ? ';' : ':';
+}
 
-    // If it starts with ~ or ./, reject as relative paths are not allowed
-    if (customCliName.startsWith('./') || customCliName.startsWith('../') || customCliName.includes('/')) {
-      throw new Error(`Invalid GEMINI_CLI_NAME: Relative paths are not allowed. Use either a simple name (e.g., 'gemini') or an absolute path (e.g., '/tmp/gemini-test')`);
-    }
+function getPathExtensions(): string[] {
+  if (process.platform !== 'win32') {
+    return [''];
   }
 
-  const cliName = customCliName || 'gemini';
+  const rawPathext = process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM';
+  return ['', ...rawPathext.split(';').filter(Boolean)];
+}
+
+function findExecutableOnPath(commandName: string): string | null {
+  const rawPath = process.env.PATH || '';
+  if (!rawPath) {
+    return null;
+  }
 
-  // Try local install path: ~/.gemini/local/gemini
-  const userPath = join(homedir(), '.gemini', 'local', 'gemini');
-  debugLog(`[Debug] Checking for Gemini CLI at local user path: ${userPath}`);
+  const pathEntries = rawPath.split(getPathDelimiter()).filter(Boolean);
+  const extensions = getPathExtensions();
 
-  if (existsSync(userPath)) {
-    debugLog(`[Debug] Found Gemini CLI at local user path: ${userPath}. Using this path.`);
-    return userPath;
-  } else {
-    debugLog(`[Debug] Gemini CLI not found at local user path: ${userPath}.`);
+  for (const entry of pathEntries) {
+    for (const extension of extensions) {
+      const candidate = join(entry, `${commandName}${extension}`);
+      if (isExecutableFile(candidate)) {
+        return candidate;
+      }
+    }
   }
 
-  // Fallback to CLI name (PATH lookup)
-  debugLog(`[Debug] Falling back to "${cliName}" command name, relying on spawn/PATH lookup.`);
-  console.warn(`[Warning] Gemini CLI not found at ~/.gemini/local/gemini. Falling back to "${cliName}" in PATH. Ensure it is installed and accessible.`);
-  return cliName;
+  return null;
 }
 
-/**
- * Determine the Codex CLI command/path.
- * Similar to findClaudeCli but for Codex
- */
-export function findCodexCli(): string {
-  debugLog('[Debug] Attempting to find Codex CLI...');
+function validateCustomCliName(envVarName: string, customCliName: string): string | null {
+  if (path.isAbsolute(customCliName)) {
+    return null;
+  }
 
-  // Check for custom CLI name from environment variable
-  const customCliName = process.env.CODEX_CLI_NAME;
-  if (customCliName) {
-    debugLog(`[Debug] Using custom Codex CLI name from CODEX_CLI_NAME: ${customCliName}`);
+  if (
+    customCliName.startsWith('./') ||
+    customCliName.startsWith('../') ||
+    customCliName.includes('/')
+  ) {
+    return `Invalid ${envVarName}: Relative paths are not allowed. Use either a simple name (e.g., '${customCliName.split('/').pop() || 'cli'}') or an absolute path (e.g., '/tmp/${customCliName.split('/').pop() || 'cli'}-test')`;
+  }
 
-    // If it's an absolute path, use it directly
-    if (path.isAbsolute(customCliName)) {
-      debugLog(`[Debug] CODEX_CLI_NAME is an absolute path: ${customCliName}`);
-      return customCliName;
+  return null;
+}
+
+function inspectCliBinary(options: {
+  envVarName: string;
+  customCliName: string | undefined;
+  defaultCliName: string;
+  localInstallPath: string;
+}): CliBinaryStatus {
+  const configuredCommand = options.customCliName || options.defaultCliName;
+
+  if (options.customCliName) {
+    const validationError = validateCustomCliName(options.envVarName, options.customCliName);
+    if (validationError) {
+      return {
+        configuredCommand,
+        resolvedPath: null,
+        available: false,
+        lookup: 'env',
+        error: validationError,
+      };
     }
 
-    // If it starts with ~ or ./, reject as relative paths are not allowed
-    if (customCliName.startsWith('./') || customCliName.startsWith('../') || customCliName.includes('/')) {
-      throw new Error(`Invalid CODEX_CLI_NAME: Relative paths are not allowed. Use either a simple name (e.g., 'codex') or an absolute path (e.g., '/tmp/codex-test')`);
+    if (path.isAbsolute(options.customCliName)) {
+      return {
+        configuredCommand,
+        resolvedPath: options.customCliName,
+        available: isExecutableFile(options.customCliName),
+        lookup: 'env',
+      };
     }
+
+    const resolvedPath = findExecutableOnPath(configuredCommand);
+    return {
+      configuredCommand,
+      resolvedPath,
+      available: resolvedPath !== null,
+      lookup: 'env',
+    };
   }
 
-  const cliName = customCliName || 'codex';
+  if (isExecutableFile(options.localInstallPath)) {
+    return {
+      configuredCommand,
+      resolvedPath: options.localInstallPath,
+      available: true,
+      lookup: 'local',
+    };
+  }
+
+  const resolvedPath = findExecutableOnPath(configuredCommand);
+  return {
+    configuredCommand,
+    resolvedPath,
+    available: resolvedPath !== null,
+    lookup: 'path',
+  };
+}
+
+function getCliCommandOrThrow(status: CliBinaryStatus): string {
+  if (status.error) {
+    throw new Error(status.error);
+  }
+
+  if (status.lookup === 'env' && !path.isAbsolute(status.configuredCommand)) {
+    return status.configuredCommand;
+  }
+
+  return status.resolvedPath || status.configuredCommand;
+}
+
+function isExecutableFile(filePath: string): boolean {
+  try {
+    accessSync(filePath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-  // Try local install path: ~/.codex/local/codex
-  const userPath = join(homedir(), '.codex', 'local', 'codex');
-  debugLog(`[Debug] Checking for Codex CLI at local user path: ${userPath}`);
+type CliBinaryName = 'claude' | 'codex' | 'gemini';
+
+function getCliBinaryConfig(name: CliBinaryName): {
+  envVarName: string;
+  customCliName: string | undefined;
+  defaultCliName: string;
+  localInstallPath: string;
+} {
+  if (name === 'claude') {
+    return {
+      envVarName: 'CLAUDE_CLI_NAME',
+      customCliName: process.env.CLAUDE_CLI_NAME,
+      defaultCliName: 'claude',
+      localInstallPath: join(homedir(), '.claude', 'local', 'claude'),
+    };
+  }
 
-  if (existsSync(userPath)) {
-    debugLog(`[Debug] Found Codex CLI at local user path: ${userPath}. Using this path.`);
-    return userPath;
-  } else {
-    debugLog(`[Debug] Codex CLI not found at local user path: ${userPath}.`);
+  if (name === 'codex') {
+    return {
+      envVarName: 'CODEX_CLI_NAME',
+      customCliName: process.env.CODEX_CLI_NAME,
+      defaultCliName: 'codex',
+      localInstallPath: join(homedir(), '.codex', 'local', 'codex'),
+    };
   }
 
-  // Fallback to CLI name (PATH lookup)
-  debugLog(`[Debug] Falling back to "${cliName}" command name, relying on spawn/PATH lookup.`);
-  console.warn(`[Warning] Codex CLI not found at ~/.codex/local/codex. Falling back to "${cliName}" in PATH. Ensure it is installed and accessible.`);
-  return cliName;
+  return {
+    envVarName: 'GEMINI_CLI_NAME',
+    customCliName: process.env.GEMINI_CLI_NAME,
+    defaultCliName: 'gemini',
+    localInstallPath: join(homedir(), '.gemini', 'local', 'gemini'),
+  };
+}
+
+function getCliBinaryStatus(name: CliBinaryName): CliBinaryStatus {
+  return inspectCliBinary(getCliBinaryConfig(name));
+}
+
+export function getCliDoctorStatus(): {
+  claude: CliBinaryStatus;
+  codex: CliBinaryStatus;
+  gemini: CliBinaryStatus;
+} {
+  return {
+    claude: getCliBinaryStatus('claude'),
+    codex: getCliBinaryStatus('codex'),
+    gemini: getCliBinaryStatus('gemini'),
+  };
+}
+
+/**
+ * Determine the Gemini CLI command/path.
+ * Similar to findClaudeCli but for Gemini
+ */
+export function findGeminiCli(): string {
+  debugLog('[Debug] Attempting to find Gemini CLI...');
+  const status = getCliBinaryStatus('gemini');
+  return getCliCommandOrThrow(status);
+}
+
+/**
+ * Determine the Codex CLI command/path.
+ * Similar to findClaudeCli but for Codex
+ */
+export function findCodexCli(): string {
+  debugLog('[Debug] Attempting to find Codex CLI...');
+  const status = getCliBinaryStatus('codex');
+  return getCliCommandOrThrow(status);
 }
 
 /**
@@ -110,39 +229,6 @@ export function findCodexCli(): string {
  */
 export function findClaudeCli(): string {
   debugLog('[Debug] Attempting to find Claude CLI...');
-
-  // Check for custom CLI name from environment variable
-  const customCliName = process.env.CLAUDE_CLI_NAME;
-  if (customCliName) {
-    debugLog(`[Debug] Using custom Claude CLI name from CLAUDE_CLI_NAME: ${customCliName}`);
-
-    // If it's an absolute path, use it directly
-    if (path.isAbsolute(customCliName)) {
-      debugLog(`[Debug] CLAUDE_CLI_NAME is an absolute path: ${customCliName}`);
-      return customCliName;
-    }
-
-    // If it starts with ~ or ./, reject as relative paths are not allowed
-    if (customCliName.startsWith('./') || customCliName.startsWith('../') || customCliName.includes('/')) {
-      throw new Error(`Invalid CLAUDE_CLI_NAME: Relative paths are not allowed. Use either a simple name (e.g., 'claude') or an absolute path (e.g., '/tmp/claude-test')`);
-    }
-  }
-
-  const cliName = customCliName || 'claude';
-
-  // Try local install path: ~/.claude/local/claude (using the original name for local installs)
-  const userPath = join(homedir(), '.claude', 'local', 'claude');
-  debugLog(`[Debug] Checking for Claude CLI at local user path: ${userPath}`);
-
-  if (existsSync(userPath)) {
-    debugLog(`[Debug] Found Claude CLI at local user path: ${userPath}. Using this path.`);
-    return userPath;
-  } else {
-    debugLog(`[Debug] Claude CLI not found at local user path: ${userPath}.`);
-  }
-
-  // 3. Fallback to CLI name (PATH lookup)
-  debugLog(`[Debug] Falling back to "${cliName}" command name, relying on spawn/PATH lookup.`);
-  console.warn(`[Warning] Claude CLI not found at ~/.claude/local/claude. Falling back to "${cliName}" in PATH. Ensure it is installed and accessible.`);
-  return cliName;
+  const status = getCliBinaryStatus('claude');
+  return getCliCommandOrThrow(status);
 }

package/src/cli.ts

@@ -40,7 +40,7 @@ Options:
   --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
+  --reasoning_effort   Claude/Codex: Claude=low|medium|high, Codex=low|medium|high|xhigh
   --help               Show this help message
 
 Raw CLI output goes to stdout. Use cli.run.parse to parse the output:

package/src/model-catalog.ts

@@ -0,0 +1,60 @@
+export const CLAUDE_MODELS = ['sonnet', 'sonnet[1m]', 'opus', 'opusplan', 'haiku'] as const;
+export const CODEX_MODELS = [
+  'gpt-5.4',
+  'gpt-5.3-codex',
+  'gpt-5.2-codex',
+  'gpt-5.1-codex-mini',
+  'gpt-5.1-codex-max',
+  'gpt-5.2',
+  'gpt-5.1',
+  'gpt-5.1-codex',
+  'gpt-5-codex',
+  'gpt-5-codex-mini',
+  'gpt-5',
+] as const;
+export const GEMINI_MODELS = [
+  'gemini-2.5-pro',
+  'gemini-2.5-flash',
+  'gemini-3.1-pro-preview',
+  'gemini-3-pro-preview',
+  'gemini-3-flash-preview',
+] as const;
+
+export const MODEL_ALIASES: Record<string, string> = {
+  'claude-ultra': 'opus',
+  'codex-ultra': 'gpt-5.4',
+  'gemini-ultra': 'gemini-3.1-pro-preview',
+};
+
+export const MODEL_ALIAS_DETAILS = [
+  { name: 'claude-ultra', resolvesTo: 'opus', agent: 'claude', defaultReasoningEffort: 'high' },
+  { name: 'codex-ultra', resolvesTo: 'gpt-5.4', agent: 'codex', defaultReasoningEffort: 'xhigh' },
+  { name: 'gemini-ultra', resolvesTo: 'gemini-3.1-pro-preview', agent: 'gemini' },
+] as const;
+
+export function getSupportedModelsDescription(): string {
+  return [
+    '"claude-ultra", "codex-ultra", "gemini-ultra"',
+    ...CLAUDE_MODELS.map((model) => `"${model}"`),
+    ...CODEX_MODELS.map((model) => `"${model}"`),
+    ...GEMINI_MODELS.map((model) => `"${model}"`),
+  ].join(', ');
+}
+
+export function getModelParameterDescription(): string {
+  return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS].map((model) => `"${model}"`).join(', ')}.`;
+}
+
+export function getModelsPayload(): {
+  aliases: ReadonlyArray<(typeof MODEL_ALIAS_DETAILS)[number]>;
+  claude: ReadonlyArray<string>;
+  codex: ReadonlyArray<string>;
+  gemini: ReadonlyArray<string>;
+} {
+  return {
+    aliases: MODEL_ALIAS_DETAILS,
+    claude: CLAUDE_MODELS,
+    codex: CODEX_MODELS,
+    gemini: GEMINI_MODELS,
+  };
+}

package/src/process-service.ts

@@ -0,0 +1,261 @@
+import { spawn, type ChildProcess } from 'node:child_process';
+import { buildCliCommand, type BuildCliCommandOptions } from './cli-builder.js';
+import { parseClaudeOutput, parseCodexOutput, parseGeminiOutput } from './parsers.js';
+
+export type AgentType = 'claude' | 'codex' | 'gemini';
+export type ProcessStatus = 'running' | 'completed' | 'failed';
+
+interface TrackedProcess {
+  pid: number;
+  process: ChildProcess;
+  prompt: string;
+  workFolder: string;
+  model?: string;
+  toolType: AgentType;
+  startTime: string;
+  stdout: string;
+  stderr: string;
+  status: ProcessStatus;
+  exitCode?: number;
+}
+
+export interface ProcessListItem {
+  pid: number;
+  agent: AgentType;
+  status: ProcessStatus;
+}
+
+export interface StartProcessResult {
+  pid: number;
+  status: 'started';
+  agent: AgentType;
+  message: string;
+}
+
+interface ProcessServiceOptions {
+  cliPaths: BuildCliCommandOptions['cliPaths'];
+}
+
+export class ProcessService {
+  private readonly processManager = new Map<number, TrackedProcess>();
+  private readonly cliPaths: BuildCliCommandOptions['cliPaths'];
+
+  constructor(options: ProcessServiceOptions) {
+    this.cliPaths = options.cliPaths;
+  }
+
+  startProcess(options: Omit<BuildCliCommandOptions, 'cliPaths'>): StartProcessResult {
+    const cmd = buildCliCommand({
+      ...options,
+      cliPaths: this.cliPaths,
+    });
+
+    const { cliPath, args: processArgs, cwd: effectiveCwd, agent, prompt } = cmd;
+    const childProcess = spawn(cliPath, processArgs, {
+      cwd: effectiveCwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false,
+    });
+
+    const pid = childProcess.pid;
+    if (!pid) {
+      throw new Error(`Failed to start ${agent} CLI process`);
+    }
+
+    const processEntry: TrackedProcess = {
+      pid,
+      process: childProcess,
+      prompt,
+      workFolder: effectiveCwd,
+      model: options.model,
+      toolType: agent,
+      startTime: new Date().toISOString(),
+      stdout: '',
+      stderr: '',
+      status: 'running',
+    };
+
+    this.processManager.set(pid, processEntry);
+
+    childProcess.stdout.on('data', (data) => {
+      const entry = this.processManager.get(pid);
+      if (entry) {
+        entry.stdout += data.toString();
+      }
+    });
+
+    childProcess.stderr.on('data', (data) => {
+      const entry = this.processManager.get(pid);
+      if (entry) {
+        entry.stderr += data.toString();
+      }
+    });
+
+    childProcess.on('close', (code) => {
+      const entry = this.processManager.get(pid);
+      if (entry) {
+        entry.status = code === 0 ? 'completed' : 'failed';
+        entry.exitCode = code !== null ? code : undefined;
+      }
+    });
+
+    childProcess.on('error', (error) => {
+      const entry = this.processManager.get(pid);
+      if (entry) {
+        entry.status = 'failed';
+        entry.stderr += `\nProcess error: ${error.message}`;
+      }
+    });
+
+    return {
+      pid,
+      status: 'started',
+      agent,
+      message: `${agent} process started successfully`,
+    };
+  }
+
+  listProcesses(): ProcessListItem[] {
+    const processes: ProcessListItem[] = [];
+
+    for (const [pid, process] of this.processManager.entries()) {
+      processes.push({
+        pid,
+        agent: process.toolType,
+        status: process.status,
+      });
+    }
+
+    return processes;
+  }
+
+  getProcessResult(pid: number, verbose = false): any {
+    const process = this.processManager.get(pid);
+    if (!process) {
+      throw new Error(`Process with PID ${pid} not found`);
+    }
+
+    let agentOutput: any = null;
+    if (process.toolType === 'codex') {
+      const combinedOutput = (process.stdout || '') + '\n' + (process.stderr || '');
+      agentOutput = parseCodexOutput(combinedOutput);
+    } else if (process.stdout) {
+      if (process.toolType === 'claude') {
+        agentOutput = parseClaudeOutput(process.stdout);
+      } else if (process.toolType === 'gemini') {
+        agentOutput = parseGeminiOutput(process.stdout);
+      }
+    }
+
+    const response: any = {
+      pid,
+      agent: process.toolType,
+      status: process.status,
+      exitCode: process.exitCode,
+      startTime: process.startTime,
+      workFolder: process.workFolder,
+      prompt: process.prompt,
+      model: process.model,
+    };
+
+    if (agentOutput) {
+      if (!verbose && agentOutput.tools) {
+        const { tools, ...rest } = agentOutput;
+        response.agentOutput = rest;
+      } else {
+        response.agentOutput = agentOutput;
+      }
+
+      if (agentOutput.session_id) {
+        response.session_id = agentOutput.session_id;
+      }
+    } else {
+      response.stdout = process.stdout;
+      response.stderr = process.stderr;
+    }
+
+    return response;
+  }
+
+  async waitForProcesses(pids: number[], timeoutSeconds = 180): Promise<any[]> {
+    for (const pid of pids) {
+      if (!this.processManager.has(pid)) {
+        throw new Error(`Process with PID ${pid} not found`);
+      }
+    }
+
+    const waitPromises = pids.map((pid) => {
+      const processEntry = this.processManager.get(pid)!;
+
+      if (processEntry.status !== 'running') {
+        return Promise.resolve();
+      }
+
+      return new Promise<void>((resolve) => {
+        processEntry.process.once('close', () => {
+          resolve();
+        });
+      });
+    });
+
+    const timeoutMs = timeoutSeconds * 1000;
+    let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        reject(new Error(`Timed out after ${timeoutSeconds} seconds waiting for processes`));
+      }, timeoutMs);
+      timeoutHandle.unref?.();
+    });
+
+    try {
+      await Promise.race([Promise.all(waitPromises), timeoutPromise]);
+      return pids.map((pid) => this.getProcessResult(pid, false));
+    } finally {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+    }
+  }
+
+  killProcess(pid: number): { pid: number; status: string; message: string } {
+    const processEntry = this.processManager.get(pid);
+    if (!processEntry) {
+      throw new Error(`Process with PID ${pid} not found`);
+    }
+
+    if (processEntry.status !== 'running') {
+      return {
+        pid,
+        status: processEntry.status,
+        message: 'Process already terminated',
+      };
+    }
+
+    processEntry.process.kill('SIGTERM');
+    processEntry.status = 'failed';
+    processEntry.stderr += '\nProcess terminated by user';
+
+    return {
+      pid,
+      status: 'terminated',
+      message: 'Process terminated successfully',
+    };
+  }
+
+  cleanupProcesses(): { removed: number; removedPids: number[]; message: string } {
+    const removedPids: number[] = [];
+
+    for (const [pid, process] of this.processManager.entries()) {
+      if (process.status === 'completed' || process.status === 'failed') {
+        removedPids.push(pid);
+        this.processManager.delete(pid);
+      }
+    }
+
+    return {
+      removed: removedPids.length,
+      removedPids,
+      message: `Cleaned up ${removedPids.length} finished process(es)`,
+    };
+  }
+}