llm-cli-gateway 1.1.0 → 1.5.4

package/dist/cli-updater.js

@@ -0,0 +1,248 @@
+import { spawnSync } from "node:child_process";
+import { executeCli } from "./executor.js";
+import { getProviderRuntimeStatus } from "./provider-status.js";
+/**
+ * Detect how Vibe was installed on this machine. Vibe does not self-update, so
+ * cli_upgrade has to dispatch to the package manager that owns the binary.
+ *
+ * Probe order: pip → uv → brew. The first one that returns a positive signal
+ * wins; if none do, callers should surface an actionable error rather than
+ * blindly running `vibe update` (a command that does not exist).
+ */
+export function detectMistralInstallMethod(exec = (cmd, args) => {
+    const result = spawnSync(cmd, args, { encoding: "utf8", timeout: 5_000, windowsHide: true });
+    return {
+        exitCode: typeof result.status === "number" ? result.status : null,
+        stdout: result.stdout || "",
+    };
+}) {
+    const pip = exec("pip", ["show", "vibe-cli"]);
+    if (pip.exitCode === 0 && /Name:\s*vibe-cli/i.test(pip.stdout)) {
+        return "pip";
+    }
+    const uv = exec("uv", ["tool", "list"]);
+    if (uv.exitCode === 0 && /\bvibe(?:-cli)?\b/i.test(uv.stdout)) {
+        return "uv";
+    }
+    const brew = exec("brew", ["list", "mistral-vibe"]);
+    if (brew.exitCode === 0) {
+        return "brew";
+    }
+    return "unknown";
+}
+const VERSION_ARGS = {
+    claude: ["--version"],
+    codex: ["--version"],
+    gemini: ["--version"],
+    grok: ["--version"],
+    mistral: ["--version"],
+};
+const NPM_PACKAGES = {
+    codex: "@openai/codex",
+    gemini: "@google/gemini-cli",
+};
+export function buildCliUpgradePlan(cli, target = "latest", detectMistral = detectMistralInstallMethod) {
+    const normalizedTarget = normalizeTarget(target);
+    if (cli === "mistral") {
+        return buildMistralUpgradePlan(normalizedTarget, detectMistral);
+    }
+    if (cli === "claude") {
+        if (normalizedTarget === "latest") {
+            return {
+                cli,
+                target: normalizedTarget,
+                command: "claude",
+                args: ["update"],
+                strategy: "self-update",
+                requiresNetwork: true,
+            };
+        }
+        return {
+            cli,
+            target: normalizedTarget,
+            command: "claude",
+            args: ["install", normalizedTarget],
+            strategy: "self-update",
+            requiresNetwork: true,
+            note: "Claude Code supports explicit install targets through 'claude install <target>'.",
+        };
+    }
+    if (cli === "grok") {
+        if (normalizedTarget === "latest") {
+            return {
+                cli,
+                target: normalizedTarget,
+                command: "grok",
+                args: ["update"],
+                strategy: "self-update",
+                requiresNetwork: true,
+            };
+        }
+        return {
+            cli,
+            target: normalizedTarget,
+            command: "grok",
+            args: ["update", "--version", normalizedTarget],
+            strategy: "self-update",
+            requiresNetwork: true,
+            note: "Grok CLI supports explicit version targets via 'grok update --version <target>'.",
+        };
+    }
+    if (cli === "codex" && normalizedTarget === "latest") {
+        return {
+            cli,
+            target: normalizedTarget,
+            command: "codex",
+            args: ["update"],
+            strategy: "self-update",
+            requiresNetwork: true,
+        };
+    }
+    const packageName = cli === "codex" ? NPM_PACKAGES.codex : NPM_PACKAGES.gemini;
+    return {
+        cli,
+        target: normalizedTarget,
+        command: "npm",
+        args: ["install", "-g", `${packageName}@${normalizedTarget}`],
+        strategy: "npm-global-install",
+        requiresNetwork: true,
+        note: cli === "codex"
+            ? "Explicit Codex targets use the documented npm package path; latest can use 'codex update'."
+            : "Gemini CLI does not expose a self-update command in the gateway-supported CLI surface, so upgrades use npm.",
+    };
+}
+export async function getCliVersion(cli) {
+    const args = VERSION_ARGS[cli];
+    try {
+        const status = getProviderRuntimeStatus(cli);
+        return {
+            cli,
+            command: cli,
+            args,
+            installed: status.installed,
+            version: status.version || undefined,
+            loginStatus: status.loginStatus,
+            loginGuidance: status.guidance.login,
+            stdout: status.version || "",
+            stderr: "",
+        };
+    }
+    catch (error) {
+        const result = await fallbackCliVersion(cli, args);
+        if (result)
+            return result;
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            cli,
+            command: cli,
+            args,
+            installed: false,
+            stdout: "",
+            stderr: "",
+            error: message,
+        };
+    }
+}
+export async function getCliVersions(cli) {
+    const clis = cli ? [cli] : ["claude", "codex", "gemini", "grok", "mistral"];
+    return Promise.all(clis.map(item => getCliVersion(item)));
+}
+function buildMistralUpgradePlan(normalizedTarget, detectMistral) {
+    const method = detectMistral();
+    // Vibe ships no self-update command. cli_upgrade dispatches to the installer
+    // it detects; if none can be detected the caller gets an actionable error
+    // (we surface it as a no-op plan with `command: ""` so runCliUpgrade can
+    // throw before spawning anything).
+    if (method === "pip") {
+        const pkg = normalizedTarget === "latest" ? "vibe-cli" : `vibe-cli==${normalizedTarget}`;
+        return {
+            cli: "mistral",
+            target: normalizedTarget,
+            command: "pip",
+            args: ["install", "-U", pkg],
+            strategy: "pip-install",
+            requiresNetwork: true,
+            note: "Mistral Vibe has no self-update command; gateway detected a pip install.",
+        };
+    }
+    if (method === "uv") {
+        return {
+            cli: "mistral",
+            target: normalizedTarget,
+            command: "uv",
+            args: ["tool", "upgrade", "vibe-cli"],
+            strategy: "uv-tool-upgrade",
+            requiresNetwork: true,
+            note: normalizedTarget === "latest"
+                ? "Mistral Vibe has no self-update command; gateway detected a uv tool install."
+                : "uv tool upgrade does not honour explicit version targets; running upgrade to latest.",
+        };
+    }
+    if (method === "brew") {
+        return {
+            cli: "mistral",
+            target: normalizedTarget,
+            command: "brew",
+            args: ["upgrade", "mistral-vibe"],
+            strategy: "brew-upgrade",
+            requiresNetwork: true,
+            note: normalizedTarget === "latest"
+                ? "Mistral Vibe has no self-update command; gateway detected a Homebrew install."
+                : "brew upgrade does not honour explicit version targets; running upgrade to latest.",
+        };
+    }
+    throw new Error("Could not detect how Mistral Vibe was installed. Install it via pip (`pip install vibe-cli`), uv (`uv tool install vibe-cli`), or Homebrew (`brew install mistral-vibe`) before running cli_upgrade.");
+}
+async function fallbackCliVersion(cli, args) {
+    try {
+        const result = await executeCli(cli, args, { timeout: 15_000 });
+        return {
+            cli,
+            command: cli,
+            args,
+            installed: true,
+            version: extractVersion(result.stdout, result.stderr),
+            stdout: result.stdout,
+            stderr: result.stderr,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function runCliUpgrade(params) {
+    const plan = buildCliUpgradePlan(params.cli, params.target);
+    if (params.dryRun) {
+        return { dryRun: true, plan };
+    }
+    params.logger?.info(`Upgrading ${params.cli} CLI`, {
+        target: plan.target,
+        command: plan.command,
+        args: plan.args,
+    });
+    const result = await executeCli(plan.command, plan.args, {
+        timeout: params.timeoutMs ?? 600_000,
+        logger: params.logger,
+    });
+    return {
+        dryRun: false,
+        plan,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.code,
+    };
+}
+function normalizeTarget(target) {
+    const normalized = target.trim();
+    if (!normalized || normalized.startsWith("-") || /[\u0000-\u001f\u007f\s]/.test(normalized)) {
+        throw new Error("Upgrade target must be a non-empty package tag or version without whitespace and cannot start with '-'");
+    }
+    return normalized;
+}
+function extractVersion(stdout, stderr) {
+    const text = `${stdout}\n${stderr}`
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(line => line.length > 0);
+    return text || undefined;
+}

package/dist/codex-json-parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Parser for Codex CLI `--json` JSONL event stream.
+ *
+ * Codex emits one JSON object per line, e.g.:
+ *   {"type":"thread.started","thread_id":"t-abc"}
+ *   {"type":"turn.started","turn_id":"u-001"}
+ *   {"type":"item.started","item":{...}}
+ *   {"type":"item.completed","item":{"type":"agent_message","text":"..."}}
+ *   {"type":"turn.completed","usage":{"input_tokens":...,"output_tokens":...,...}}
+ *   {"type":"turn.failed","error":{...}}
+ *   {"type":"error","message":"..."}
+ *
+ * This parser is lenient: malformed lines are skipped, partial streams are
+ * tolerated (usage is `undefined` if no turn.completed event arrived), and
+ * error events are surfaced.
+ *
+ * Cost is intentionally NOT computed here — Codex does not price client-side
+ * and U23 only plumbs tokens. A future unit can compute cost from the model
+ * registry.
+ */
+export interface CodexUsage {
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens?: number;
+    cache_creation_tokens?: number;
+    cost_usd?: number;
+}
+export interface CodexJsonParseResult {
+    usage?: CodexUsage;
+    error?: string;
+    threadId?: string;
+    finalMessage?: string;
+}
+export declare function parseCodexJsonStream(stdout: string): CodexJsonParseResult;

package/dist/codex-json-parser.js

@@ -0,0 +1,105 @@
+/**
+ * Parser for Codex CLI `--json` JSONL event stream.
+ *
+ * Codex emits one JSON object per line, e.g.:
+ *   {"type":"thread.started","thread_id":"t-abc"}
+ *   {"type":"turn.started","turn_id":"u-001"}
+ *   {"type":"item.started","item":{...}}
+ *   {"type":"item.completed","item":{"type":"agent_message","text":"..."}}
+ *   {"type":"turn.completed","usage":{"input_tokens":...,"output_tokens":...,...}}
+ *   {"type":"turn.failed","error":{...}}
+ *   {"type":"error","message":"..."}
+ *
+ * This parser is lenient: malformed lines are skipped, partial streams are
+ * tolerated (usage is `undefined` if no turn.completed event arrived), and
+ * error events are surfaced.
+ *
+ * Cost is intentionally NOT computed here — Codex does not price client-side
+ * and U23 only plumbs tokens. A future unit can compute cost from the model
+ * registry.
+ */
+export function parseCodexJsonStream(stdout) {
+    const lines = stdout.split("\n").filter(line => line.trim().length > 0);
+    const result = {};
+    let lastAgentMessage;
+    for (const line of lines) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            // Skip preamble/garbage lines that aren't valid JSON.
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object") {
+            continue;
+        }
+        switch (parsed.type) {
+            case "thread.started":
+                if (typeof parsed.thread_id === "string") {
+                    result.threadId = parsed.thread_id;
+                }
+                break;
+            case "turn.completed": {
+                const u = parsed.usage;
+                if (u && typeof u === "object") {
+                    const usage = {
+                        input_tokens: typeof u.input_tokens === "number" ? u.input_tokens : 0,
+                        output_tokens: typeof u.output_tokens === "number" ? u.output_tokens : 0,
+                    };
+                    if (typeof u.cache_read_input_tokens === "number") {
+                        usage.cache_read_tokens = u.cache_read_input_tokens;
+                    }
+                    else if (typeof u.cache_read_tokens === "number") {
+                        usage.cache_read_tokens = u.cache_read_tokens;
+                    }
+                    if (typeof u.cache_creation_input_tokens === "number") {
+                        usage.cache_creation_tokens = u.cache_creation_input_tokens;
+                    }
+                    else if (typeof u.cache_creation_tokens === "number") {
+                        usage.cache_creation_tokens = u.cache_creation_tokens;
+                    }
+                    if (typeof u.cost_usd === "number") {
+                        usage.cost_usd = u.cost_usd;
+                    }
+                    result.usage = usage;
+                }
+                break;
+            }
+            case "turn.failed": {
+                const err = parsed.error;
+                if (typeof err === "string") {
+                    result.error = err;
+                }
+                else if (err && typeof err === "object" && typeof err.message === "string") {
+                    result.error = err.message;
+                }
+                else {
+                    result.error = "turn failed";
+                }
+                break;
+            }
+            case "error":
+                if (typeof parsed.message === "string") {
+                    result.error = parsed.message;
+                }
+                break;
+            case "item.completed": {
+                const item = parsed.item;
+                if (item &&
+                    typeof item === "object" &&
+                    item.type === "agent_message" &&
+                    typeof item.text === "string") {
+                    lastAgentMessage = item.text;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    if (lastAgentMessage !== undefined) {
+        result.finalMessage = lastAgentMessage;
+    }
+    return result;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,110 @@
+import { type EndpointExposureReport } from "./endpoint-exposure.js";
+import { type ProviderLoginStatus } from "./provider-status.js";
+export interface VibeSessionLoggingStatus {
+    config_path: string;
+    config_present: boolean;
+    session_logging_enabled: boolean;
+    note: string;
+}
+export interface GeminiConfigStatus {
+    /** Presence of a project-local `GEMINI.md` in the gateway's cwd. */
+    project_gemini_md_present: boolean;
+    project_gemini_md_path: string;
+    /** Presence of `~/.gemini/GEMINI.md`. */
+    user_gemini_md_present: boolean;
+    user_gemini_md_path: string;
+    /** Presence and contents of `~/.gemini/settings.json` `mcpServers` block. */
+    settings_json_present: boolean;
+    settings_json_path: string;
+    mcp_servers_registered: string[];
+    /** Per-server reconciliation against the gateway's `--allowed-mcp-server-names` whitelist. */
+    mcp_reconciliation: {
+        whitelisted: string[];
+        missing_from_settings: string[];
+    };
+    next_actions: string[];
+}
+/**
+ * Probe ~/.vibe/config.toml to see whether session_logging is enabled. Vibe
+ * persists session logs (which sessionId/--continue depends on) only when
+ * `[session_logging] enabled = true` is set. The probe is read-only: the
+ * gateway never mutates this file.
+ */
+export declare function checkVibeSessionLogging(home?: string): VibeSessionLoggingStatus;
+/**
+ * U27: Probe Gemini's project/user config locations.
+ *
+ * - `./GEMINI.md` (gateway cwd) and `~/.gemini/GEMINI.md` are documented
+ *   "context" surfaces. Missing both means Gemini has no project-specific
+ *   guidance.
+ * - `~/.gemini/settings.json` defines registered MCP servers (`mcpServers`
+ *   block). The gateway tracks its own whitelist (`CLAUDE_MCP_SERVER_NAMES`)
+ *   and surfaces a reconciliation warning for each whitelisted server not
+ *   present in settings.json so callers don't ship requests for unregistered
+ *   servers.
+ */
+export declare function checkGeminiConfig(cwd?: string, home?: string, whitelist?: readonly string[]): GeminiConfigStatus;
+export interface DoctorReport {
+    schema_version: "1.0";
+    ok: boolean;
+    generated_at: string;
+    system: {
+        os: NodeJS.Platform;
+        arch: string;
+        release: string;
+        node_version: string;
+    };
+    gateway: {
+        name: string;
+        version: string;
+    };
+    transport: {
+        default: "stdio" | "http";
+        http: {
+            enabled: boolean;
+            host: string;
+            port: number;
+            path: string;
+            public_url_configured: boolean;
+            public_url: string | null;
+        };
+    };
+    auth: {
+        required: boolean;
+        token_configured: boolean;
+        source: string;
+    };
+    providers: Record<"claude" | "codex" | "gemini" | "grok" | "mistral", {
+        cli_available: boolean;
+        version: string | null;
+        login_status: ProviderLoginStatus;
+        version_command: string[];
+        login_check: {
+            method: "cli" | "credential_store" | "not_checked";
+            command: string[] | null;
+            credential_store: "present" | "not_found" | "not_checked";
+            detail: string;
+        };
+        install_guidance: {
+            summary: string;
+            commands: string[];
+            documentation_url?: string;
+        };
+        login_guidance: {
+            summary: string;
+            commands: string[];
+            credential_handling: string;
+        };
+    }>;
+    endpoint_exposure: EndpointExposureReport;
+    client_config: {
+        claude_desktop_config_present: boolean;
+        codex_config_present: boolean;
+        gemini_settings_present: boolean;
+        gemini_config: GeminiConfigStatus;
+        vibe_session_logging: VibeSessionLoggingStatus;
+    };
+    next_actions: string[];
+}
+export declare function createDoctorReport(env?: NodeJS.ProcessEnv): DoctorReport;
+export declare function printDoctorJson(): void;