ai-cli-mcp 2.11.0 → 2.13.0

package/dist/cli-process-service.js

@@ -0,0 +1,332 @@
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { buildCliCommand } from './cli-builder.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
+import { parseClaudeOutput, parseCodexOutput, parseForgeOutput, parseGeminiOutput } from './parsers.js';
+function resolveDefaultStateDir() {
+    return process.env.AI_CLI_STATE_DIR || join(homedir(), '.local', 'state', 'ai-cli');
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+function normalizeCwdForStorage(cwd) {
+    return cwd
+        .split('')
+        .map((char) => (/^[A-Za-z0-9.-]$/.test(char) ? char : `_${char.charCodeAt(0).toString(16).padStart(2, '0')}`))
+        .join('');
+}
+export class CliProcessService {
+    stateDir;
+    cliPaths;
+    constructor(options = {}) {
+        this.stateDir = options.stateDir || resolveDefaultStateDir();
+        this.cliPaths = options.cliPaths || {
+            claude: findClaudeCli(),
+            codex: findCodexCli(),
+            gemini: findGeminiCli(),
+            forge: findForgeCli(),
+        };
+        mkdirSync(this.stateDir, { recursive: true });
+    }
+    async startProcess(options) {
+        const cmd = buildCliCommand({
+            prompt: options.prompt,
+            prompt_file: options.prompt_file,
+            workFolder: options.cwd,
+            model: options.model,
+            session_id: options.session_id,
+            reasoning_effort: options.reasoning_effort,
+            cliPaths: this.cliPaths,
+        });
+        const stdoutPath = this.resolveStdoutPathForPidPlaceholder();
+        const stderrPath = this.resolveStderrPathForPidPlaceholder();
+        let stdoutFd;
+        let stderrFd;
+        try {
+            stdoutFd = openSync(stdoutPath, 'w');
+            stderrFd = openSync(stderrPath, 'w');
+            const childProcess = spawn(cmd.cliPath, cmd.args, {
+                cwd: cmd.cwd,
+                detached: true,
+                stdio: ['ignore', stdoutFd, stderrFd],
+            });
+            const pid = childProcess.pid;
+            childProcess.unref();
+            if (!pid) {
+                throw new Error(`Failed to start ${cmd.agent} CLI process`);
+            }
+            const processDir = this.resolveProcessDir(cmd.cwd, pid);
+            mkdirSync(processDir, { recursive: true });
+            const finalStdoutPath = this.resolveStdoutPath(processDir);
+            const finalStderrPath = this.resolveStderrPath(processDir);
+            this.renamePlaceholderFile(stdoutPath, finalStdoutPath);
+            this.renamePlaceholderFile(stderrPath, finalStderrPath);
+            const storedProcess = {
+                pid,
+                prompt: cmd.prompt,
+                workFolder: cmd.cwd,
+                model: options.model,
+                toolType: cmd.agent,
+                startTime: new Date().toISOString(),
+                stdoutPath: finalStdoutPath,
+                stderrPath: finalStderrPath,
+                status: 'running',
+            };
+            this.writeProcess(storedProcess);
+            return {
+                pid,
+                status: 'started',
+                agent: cmd.agent,
+                message: `${cmd.agent} process started successfully`,
+            };
+        }
+        catch (error) {
+            this.removeFileIfExists(stdoutPath);
+            this.removeFileIfExists(stderrPath);
+            throw error;
+        }
+        finally {
+            if (stdoutFd !== undefined) {
+                closeSync(stdoutFd);
+            }
+            if (stderrFd !== undefined) {
+                closeSync(stderrFd);
+            }
+        }
+    }
+    async listProcesses() {
+        return this.readAllProcesses().map((process) => ({
+            pid: process.pid,
+            agent: process.toolType,
+            status: this.refreshStatus(process).status,
+        }));
+    }
+    async getProcessResult(pid, verbose = false) {
+        const storedProcess = this.readProcess(pid);
+        const refreshed = this.refreshStatus(storedProcess);
+        const stdout = this.readTextFileSafe(refreshed.stdoutPath);
+        const stderr = this.readTextFileSafe(refreshed.stderrPath);
+        let agentOutput = null;
+        if (refreshed.toolType === 'codex') {
+            agentOutput = parseCodexOutput(`${stdout}\n${stderr}`);
+        }
+        else if (stdout) {
+            if (refreshed.toolType === 'claude') {
+                agentOutput = parseClaudeOutput(stdout);
+            }
+            else if (refreshed.toolType === 'gemini') {
+                agentOutput = parseGeminiOutput(stdout);
+            }
+            else if (refreshed.toolType === 'forge') {
+                agentOutput = parseForgeOutput(stdout);
+            }
+        }
+        const response = {
+            pid,
+            agent: refreshed.toolType,
+            status: refreshed.status,
+            exitCode: undefined,
+            startTime: refreshed.startTime,
+            workFolder: refreshed.workFolder,
+            prompt: refreshed.prompt,
+            model: refreshed.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 = stdout;
+            response.stderr = stderr;
+        }
+        return response;
+    }
+    async waitForProcesses(pids, timeoutSeconds = 180) {
+        const start = Date.now();
+        for (const pid of pids) {
+            this.readProcess(pid);
+        }
+        while (true) {
+            const statuses = pids.map((pid) => this.refreshStatus(this.readProcess(pid)).status);
+            if (statuses.every((status) => status !== 'running')) {
+                return Promise.all(pids.map((pid) => this.getProcessResult(pid, false)));
+            }
+            if (Date.now() - start >= timeoutSeconds * 1000) {
+                throw new Error(`Timed out after ${timeoutSeconds} seconds waiting for processes`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    async killProcess(pid) {
+        const process = this.readProcess(pid);
+        const refreshed = this.refreshStatus(process);
+        if (refreshed.status !== 'running') {
+            return {
+                pid,
+                status: refreshed.status,
+                message: 'Process already terminated',
+            };
+        }
+        this.killPidOrGroup(pid, 'SIGTERM');
+        await this.waitForProcessExit(pid, 250);
+        if (isProcessRunning(pid)) {
+            return {
+                pid,
+                status: 'running',
+                message: 'Signal sent but process is still running',
+            };
+        }
+        refreshed.status = 'failed';
+        this.writeProcess(refreshed);
+        return {
+            pid,
+            status: 'terminated',
+            message: 'Process terminated successfully',
+        };
+    }
+    async cleanupProcesses() {
+        let removed = 0;
+        for (const process of this.readAllProcesses()) {
+            const refreshed = this.refreshStatus(process);
+            if (refreshed.status === 'running') {
+                continue;
+            }
+            const processDir = this.resolveProcessDir(refreshed.workFolder, refreshed.pid);
+            if (existsSync(processDir)) {
+                rmSync(processDir, { recursive: true, force: true });
+                removed++;
+            }
+        }
+        this.removeEmptyCwdDirs();
+        return {
+            removed,
+            message: `Removed ${removed} processes`,
+        };
+    }
+    readAllProcesses() {
+        const cwdsDir = this.resolveCwdsDir();
+        if (!existsSync(cwdsDir)) {
+            return [];
+        }
+        const processes = [];
+        for (const cwdEntry of readdirSync(cwdsDir)) {
+            const cwdDir = join(cwdsDir, cwdEntry);
+            for (const pidEntry of readdirSync(cwdDir)) {
+                const metaPath = join(cwdDir, pidEntry, 'meta.json');
+                if (existsSync(metaPath)) {
+                    processes.push(this.parseProcessFile(metaPath));
+                }
+            }
+        }
+        return processes;
+    }
+    readProcess(pid) {
+        const process = this.readAllProcesses().find((entry) => entry.pid === pid);
+        if (!process) {
+            throw new Error(`Process with PID ${pid} not found`);
+        }
+        return process;
+    }
+    parseProcessFile(metaPath) {
+        return JSON.parse(readFileSync(metaPath, 'utf-8'));
+    }
+    writeProcess(process) {
+        const processDir = this.resolveProcessDir(process.workFolder, process.pid);
+        mkdirSync(processDir, { recursive: true });
+        writeFileSync(this.resolveMetaPath(processDir), JSON.stringify(process, null, 2));
+    }
+    refreshStatus(process) {
+        if (process.status === 'running' && !isProcessRunning(process.pid)) {
+            process.status = 'completed';
+            this.writeProcess(process);
+        }
+        return process;
+    }
+    readTextFileSafe(filePath) {
+        if (!existsSync(filePath)) {
+            return '';
+        }
+        return readFileSync(filePath, 'utf-8');
+    }
+    resolveCwdsDir() {
+        return join(this.stateDir, 'cwds');
+    }
+    resolveProcessDir(cwd, pid) {
+        return join(this.resolveCwdsDir(), normalizeCwdForStorage(realpathSync(cwd)), String(pid));
+    }
+    resolveMetaPath(processDir) {
+        return join(processDir, 'meta.json');
+    }
+    resolveStdoutPath(processDir) {
+        return join(processDir, 'stdout.log');
+    }
+    resolveStderrPath(processDir) {
+        return join(processDir, 'stderr.log');
+    }
+    resolveStdoutPathForPidPlaceholder() {
+        return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stdout.log`);
+    }
+    resolveStderrPathForPidPlaceholder() {
+        return join(this.stateDir, `pending-${Date.now()}-${Math.random().toString(36).slice(2)}.stderr.log`);
+    }
+    renamePlaceholderFile(fromPath, toPath) {
+        renameSync(fromPath, toPath);
+    }
+    removeFileIfExists(filePath) {
+        if (existsSync(filePath)) {
+            unlinkSync(filePath);
+        }
+    }
+    killPidOrGroup(pid, signal) {
+        try {
+            globalThis.process.kill(-pid, signal);
+        }
+        catch (error) {
+            if (error.code === 'ESRCH' || error.code === 'EINVAL') {
+                globalThis.process.kill(pid, signal);
+                return;
+            }
+            if (error.code === 'EPERM') {
+                throw error;
+            }
+            globalThis.process.kill(pid, signal);
+        }
+    }
+    async waitForProcessExit(pid, timeoutMs) {
+        const startedAt = Date.now();
+        while (isProcessRunning(pid) && Date.now() - startedAt < timeoutMs) {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+    removeEmptyCwdDirs() {
+        const cwdsDir = this.resolveCwdsDir();
+        if (!existsSync(cwdsDir)) {
+            return;
+        }
+        for (const cwdEntry of readdirSync(cwdsDir)) {
+            const cwdDir = join(cwdsDir, cwdEntry);
+            if (readdirSync(cwdDir).length === 0) {
+                rmSync(cwdDir, { recursive: true, force: true });
+            }
+        }
+    }
+}

package/dist/cli-utils.js

@@ -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';
@@ -10,41 +10,158 @@ export function debugLog(message, ...optionalParams) {
         console.error(message, ...optionalParams);
     }
 }
+function getPathDelimiter() {
+    return process.platform === 'win32' ? ';' : ':';
+}
+function getPathExtensions() {
+    if (process.platform !== 'win32') {
+        return [''];
+    }
+    const rawPathext = process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM';
+    return ['', ...rawPathext.split(';').filter(Boolean)];
+}
+function findExecutableOnPath(commandName) {
+    const rawPath = process.env.PATH || '';
+    if (!rawPath) {
+        return null;
+    }
+    const pathEntries = rawPath.split(getPathDelimiter()).filter(Boolean);
+    const extensions = getPathExtensions();
+    for (const entry of pathEntries) {
+        for (const extension of extensions) {
+            const candidate = join(entry, `${commandName}${extension}`);
+            if (isExecutableFile(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+function validateCustomCliName(envVarName, customCliName) {
+    if (path.isAbsolute(customCliName)) {
+        return null;
+    }
+    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')`;
+    }
+    return null;
+}
+function inspectCliBinary(options) {
+    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 (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',
+        };
+    }
+    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) {
+    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) {
+    try {
+        accessSync(filePath, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getCliBinaryConfig(name) {
+    if (name === 'claude') {
+        return {
+            envVarName: 'CLAUDE_CLI_NAME',
+            customCliName: process.env.CLAUDE_CLI_NAME,
+            defaultCliName: 'claude',
+            localInstallPath: join(homedir(), '.claude', 'local', 'claude'),
+        };
+    }
+    if (name === 'codex') {
+        return {
+            envVarName: 'CODEX_CLI_NAME',
+            customCliName: process.env.CODEX_CLI_NAME,
+            defaultCliName: 'codex',
+            localInstallPath: join(homedir(), '.codex', 'local', 'codex'),
+        };
+    }
+    if (name === 'forge') {
+        return {
+            envVarName: 'FORGE_CLI_NAME',
+            customCliName: process.env.FORGE_CLI_NAME,
+            defaultCliName: 'forge',
+            localInstallPath: join(homedir(), '.forge', 'local', 'forge'),
+        };
+    }
+    return {
+        envVarName: 'GEMINI_CLI_NAME',
+        customCliName: process.env.GEMINI_CLI_NAME,
+        defaultCliName: 'gemini',
+        localInstallPath: join(homedir(), '.gemini', 'local', 'gemini'),
+    };
+}
+function getCliBinaryStatus(name) {
+    return inspectCliBinary(getCliBinaryConfig(name));
+}
+export function getCliDoctorStatus() {
+    return {
+        claude: getCliBinaryStatus('claude'),
+        codex: getCliBinaryStatus('codex'),
+        gemini: getCliBinaryStatus('gemini'),
+        forge: getCliBinaryStatus('forge'),
+    };
+}
 /**
  * Determine the Gemini CLI command/path.
  * Similar to findClaudeCli but for Gemini
  */
 export function findGeminiCli() {
     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}`);
-        // 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;
-        }
-        // 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')`);
-        }
-    }
-    const cliName = customCliName || 'gemini';
-    // 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}`);
-    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}.`);
-    }
-    // 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;
+    const status = getCliBinaryStatus('gemini');
+    return getCliCommandOrThrow(status);
 }
 /**
  * Determine the Codex CLI command/path.
@@ -52,35 +169,16 @@ export function findGeminiCli() {
  */
 export function findCodexCli() {
     debugLog('[Debug] Attempting to find Codex CLI...');
-    // 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 it's an absolute path, use it directly
-        if (path.isAbsolute(customCliName)) {
-            debugLog(`[Debug] CODEX_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 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')`);
-        }
-    }
-    const cliName = customCliName || 'codex';
-    // 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}`);
-    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}.`);
-    }
-    // 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;
+    const status = getCliBinaryStatus('codex');
+    return getCliCommandOrThrow(status);
+}
+/**
+ * Determine the Forge CLI command/path.
+ */
+export function findForgeCli() {
+    debugLog('[Debug] Attempting to find Forge CLI...');
+    const status = getCliBinaryStatus('forge');
+    return getCliCommandOrThrow(status);
 }
 /**
  * Determine the Claude CLI command/path.
@@ -93,33 +191,6 @@ export function findCodexCli() {
  */
 export function findClaudeCli() {
     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/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
 import { buildCliCommand } from './cli-builder.js';
-import { findClaudeCli, findCodexCli, findGeminiCli } from './cli-utils.js';
+import { findClaudeCli, findCodexCli, findForgeCli, findGeminiCli } from './cli-utils.js';
 /**
  * Minimal argv parser. No external dependencies.
  * Supports: --key value, --key=value
@@ -35,12 +35,12 @@ function parseArgs(argv) {
 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)
+  --model              Model name or alias (e.g. sonnet, opus, gpt-5.2-codex, gemini-2.5-pro, forge)
   --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   Claude/Codex: Claude=low|medium|high, Codex=low|medium|high|xhigh
+  --reasoning_effort   Claude/Codex only: 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:
@@ -68,6 +68,7 @@ async function main() {
         claude: findClaudeCli(),
         codex: findCodexCli(),
         gemini: findGeminiCli(),
+        forge: findForgeCli(),
     };
     // Build command
     let cmd;

package/dist/model-catalog.js

@@ -0,0 +1,53 @@
+export const CLAUDE_MODELS = ['sonnet', 'sonnet[1m]', 'opus', 'opusplan', 'haiku'];
+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',
+];
+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',
+];
+export const FORGE_MODELS = ['forge'];
+export const MODEL_ALIASES = {
+    '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' },
+];
+export function getSupportedModelsDescription() {
+    return [
+        '"claude-ultra", "codex-ultra", "gemini-ultra"',
+        ...CLAUDE_MODELS.map((model) => `"${model}"`),
+        ...CODEX_MODELS.map((model) => `"${model}"`),
+        ...GEMINI_MODELS.map((model) => `"${model}"`),
+        ...FORGE_MODELS.map((model) => `"${model}"`),
+    ].join(', ');
+}
+export function getModelParameterDescription() {
+    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, ...FORGE_MODELS].map((model) => `"${model}"`).join(', ')}. "forge" is a provider key, not a Forge model family selector.`;
+}
+export function getModelsPayload() {
+    return {
+        aliases: MODEL_ALIAS_DETAILS,
+        claude: CLAUDE_MODELS,
+        codex: CODEX_MODELS,
+        gemini: GEMINI_MODELS,
+        forge: FORGE_MODELS,
+    };
+}