llm-cli-gateway 1.4.0 → 1.5.4

package/dist/cli-updater.d.ts

@@ -1,11 +1,15 @@
 import type { Logger } from "./logger.js";
 import type { CliType } from "./session-manager.js";
+import { type ProviderLoginStatus } from "./provider-status.js";
+import type { ProviderLoginGuidance } from "./provider-login-guidance.js";
 export interface CliVersionInfo {
     cli: CliType;
     command: string;
     args: string[];
     installed: boolean;
     version?: string;
+    loginStatus?: ProviderLoginStatus;
+    loginGuidance?: ProviderLoginGuidance["login"];
     stdout: string;
     stderr: string;
     error?: string;
@@ -15,10 +19,23 @@ export interface CliUpgradePlan {
     target: string;
     command: string;
     args: string[];
-    strategy: "self-update" | "npm-global-install";
+    strategy: "self-update" | "npm-global-install" | "pip-install" | "uv-tool-upgrade" | "brew-upgrade";
     requiresNetwork: boolean;
     note?: string;
 }
+export type MistralInstallMethod = "pip" | "uv" | "brew" | "unknown";
+/**
+ * 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 declare function detectMistralInstallMethod(exec?: (cmd: string, args: string[]) => {
+    exitCode: number | null;
+    stdout: string;
+}): MistralInstallMethod;
 export interface CliUpgradeResult {
     dryRun: boolean;
     plan: CliUpgradePlan;
@@ -26,7 +43,7 @@ export interface CliUpgradeResult {
     stderr?: string;
     exitCode?: number;
 }
-export declare function buildCliUpgradePlan(cli: CliType, target?: string): CliUpgradePlan;
+export declare function buildCliUpgradePlan(cli: CliType, target?: string, detectMistral?: () => MistralInstallMethod): CliUpgradePlan;
 export declare function getCliVersion(cli: CliType): Promise<CliVersionInfo>;
 export declare function getCliVersions(cli?: CliType): Promise<CliVersionInfo[]>;
 export declare function runCliUpgrade(params: {

package/dist/cli-updater.js

@@ -1,16 +1,51 @@
+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") {
+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 {
@@ -79,18 +114,23 @@ export function buildCliUpgradePlan(cli, target = "latest") {
 export async function getCliVersion(cli) {
     const args = VERSION_ARGS[cli];
     try {
-        const result = await executeCli(cli, args, { timeout: 15_000 });
+        const status = getProviderRuntimeStatus(cli);
         return {
             cli,
             command: cli,
             args,
-            installed: true,
-            version: extractVersion(result.stdout, result.stderr),
-            stdout: result.stdout,
-            stderr: result.stderr,
+            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,
@@ -104,9 +144,72 @@ export async function getCliVersion(cli) {
     }
 }
 export async function getCliVersions(cli) {
-    const clis = cli ? [cli] : ["claude", "codex", "gemini", "grok"];
+    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) {

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;