llm-cli-gateway 1.5.18 → 1.5.21

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 All notable changes to the llm-cli-gateway project.
 
+## [1.5.21] - 2026-05-24
+
+### Fixed
+
+- Add a desktop `public-url` command that persists a public HTTPS `/mcp` endpoint for ChatGPT and other web clients.
+- Pass the persisted public URL and verification flag into managed gateway starts and `doctor --json`, instead of relying on one-off shell environment state.
+- Make `print-client-config` prefer the persisted public HTTPS URL while still reporting the local URL separately.
+
+## [1.5.20] - 2026-05-24
+
+### Fixed
+
+- Do not inject Mistral `VIBE_ACTIVE_MODEL` when a request omits `model`; let Vibe use its own CLI default unless the caller explicitly asks for a model.
+- Make `list_models`, `list_available_models`, and `models://*` omit bundled fallback entries from `models` and expose them only as `unverifiedModelHints`.
+- Add warnings when model entries are only bundled fallback hints, so clients do not present unvalidated model names as available provider models.
+
+## [1.5.19] - 2026-05-24
+
+### Fixed
+
+- Use the gateway's extended provider CLI PATH in `doctor --json`, not only in request execution.
+- Add common Windows npm/Corepack/Scoop/Volta/Chocolatey CLI shim directories to provider PATH discovery.
+- Resolve Windows PowerShell npm shims such as `gemini.ps1` and `claude.ps1` without invoking a shell command string.
+
 ## [1.5.18] - 2026-05-24
 
 ### Fixed

package/dist/async-job-manager.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "crypto";
-import { getExtendedPath, killProcessGroup, spawnCliProcess, unregisterProcessGroup, } from "./executor.js";
+import { envWithExtendedPath, getExtendedPath, killProcessGroup, spawnCliProcess, unregisterProcessGroup, } from "./executor.js";
 import { noopLogger } from "./logger.js";
 import { ProcessMonitor } from "./process-monitor.js";
 import { computeRequestKey } from "./job-store.js";
@@ -366,10 +366,11 @@ export class AsyncJobManager {
         // Mistral Vibe ships as the `vibe` binary; the gateway uses `mistral` as the
         // provider key but spawns `vibe` on the shell.
         const command = cli === "mistral" ? "vibe" : cli;
+        const baseEnv = envWithExtendedPath(process.env, getExtendedPath());
         const child = spawnCliProcess(command, args, {
             cwd,
             stdio: ["ignore", "pipe", "pipe"],
-            env: { ...process.env, PATH: getExtendedPath(), ...(extraEnv ?? {}) },
+            env: { ...baseEnv, ...(extraEnv ?? {}) },
         });
         // Single cleanup flag to prevent double-unregister
         let groupCleaned = false;

package/dist/executor.d.ts

@@ -13,7 +13,17 @@ export interface ExecuteResult {
     stderr: string;
     code: number;
 }
+export declare function buildExtendedPath(env?: NodeJS.ProcessEnv, home?: string, nodePath?: string, platform?: NodeJS.Platform): string;
 export declare function getExtendedPath(): string;
+export declare function envWithExtendedPath(baseEnv?: NodeJS.ProcessEnv, extendedPath?: string, platform?: NodeJS.Platform): NodeJS.ProcessEnv;
+export interface ResolvedSpawnCommand {
+    command: string;
+    args: string[];
+}
+export declare function resolveCommandForSpawn(command: string, args: string[], options?: {
+    envPath?: string;
+    platform?: NodeJS.Platform;
+}): ResolvedSpawnCommand;
 export declare function shouldDetachProviderProcess(platform?: NodeJS.Platform): boolean;
 export declare function registerProcessGroup(pid: number): void;
 export declare function unregisterProcessGroup(pid: number): void;

package/dist/executor.js

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from "child_process";
 import { homedir } from "os";
-import { delimiter, join, dirname } from "path";
+import { delimiter, join, dirname, extname, win32 } from "path";
 import { readdirSync, existsSync } from "fs";
 import { createCircuitBreaker, withRetry } from "./retry.js";
 const MAX_OUTPUT_SIZE = 50 * 1024 * 1024;
@@ -36,22 +36,123 @@ function getNvmPath() {
     }
     return cachedNvmPath;
 }
-// Extend PATH to include common locations for CLI tools
-export function getExtendedPath() {
-    const home = homedir();
+function pathDelimiterFor(platform) {
+    return platform === "win32" ? ";" : delimiter;
+}
+function pathJoinFor(platform, ...segments) {
+    return platform === "win32" ? win32.join(...segments) : join(...segments);
+}
+function dirnameFor(platform, path) {
+    return platform === "win32" ? win32.dirname(path) : dirname(path);
+}
+function pathValueFromEnv(env, platform) {
+    if (platform === "win32") {
+        return env.Path || env.PATH || "";
+    }
+    return env.PATH || "";
+}
+function addIfPresent(paths, value) {
+    if (value)
+        paths.push(value);
+}
+function windowsCommonCliPaths(env, home) {
+    const paths = [];
+    addIfPresent(paths, env.APPDATA ? pathJoinFor("win32", env.APPDATA, "npm") : undefined);
+    addIfPresent(paths, env.LOCALAPPDATA ? pathJoinFor("win32", env.LOCALAPPDATA, "pnpm") : undefined);
+    addIfPresent(paths, env.LOCALAPPDATA ? pathJoinFor("win32", env.LOCALAPPDATA, "Programs", "nodejs") : undefined);
+    addIfPresent(paths, env.LOCALAPPDATA ? pathJoinFor("win32", env.LOCALAPPDATA, "Programs", "npm") : undefined);
+    addIfPresent(paths, env.ProgramFiles ? pathJoinFor("win32", env.ProgramFiles, "nodejs") : undefined);
+    addIfPresent(paths, env["ProgramFiles(x86)"] ? pathJoinFor("win32", env["ProgramFiles(x86)"], "nodejs") : undefined);
+    addIfPresent(paths, env.ProgramData ? pathJoinFor("win32", env.ProgramData, "chocolatey", "bin") : undefined);
+    paths.push(pathJoinFor("win32", home, "AppData", "Roaming", "npm"));
+    paths.push(pathJoinFor("win32", home, "AppData", "Local", "pnpm"));
+    paths.push(pathJoinFor("win32", home, ".volta", "bin"));
+    paths.push(pathJoinFor("win32", home, "scoop", "shims"));
+    return paths;
+}
+export function buildExtendedPath(env = process.env, home = homedir(), nodePath = process.execPath, platform = process.platform) {
     const additionalPaths = [
-        join(home, ".local/bin"),
-        dirname(process.execPath), // Current node's bin directory
+        pathJoinFor(platform, home, ".local", "bin"),
+        dirnameFor(platform, nodePath), // Current node's bin directory
         "/usr/local/bin",
         "/usr/bin",
     ];
+    if (platform === "win32") {
+        additionalPaths.push(...windowsCommonCliPaths(env, home));
+    }
     // Add all nvm node version bin directories
     const nvmPath = getNvmPath();
     if (nvmPath) {
         additionalPaths.push(nvmPath);
     }
-    const currentPath = process.env.PATH || "";
-    return [...additionalPaths, currentPath].join(delimiter);
+    const currentPath = pathValueFromEnv(env, platform);
+    return [...dedupePaths(additionalPaths, platform), currentPath]
+        .filter(Boolean)
+        .join(pathDelimiterFor(platform));
+}
+// Extend PATH to include common locations for CLI tools.
+export function getExtendedPath() {
+    return buildExtendedPath();
+}
+export function envWithExtendedPath(baseEnv = process.env, extendedPath = getExtendedPath(), platform = process.platform) {
+    const env = { ...baseEnv };
+    const key = platform === "win32"
+        ? Object.keys(env).find(existing => existing.toLowerCase() === "path") || "Path"
+        : "PATH";
+    env[key] = extendedPath;
+    if (platform === "win32") {
+        for (const existing of Object.keys(env)) {
+            if (existing !== key && existing.toLowerCase() === "path") {
+                delete env[existing];
+            }
+        }
+    }
+    return env;
+}
+function dedupePaths(paths, platform) {
+    const seen = new Set();
+    const result = [];
+    for (const path of paths) {
+        const normalized = platform === "win32" ? path.toLowerCase() : path;
+        if (seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        result.push(path);
+    }
+    return result;
+}
+export function resolveCommandForSpawn(command, args, options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform !== "win32") {
+        return { command, args };
+    }
+    const resolved = resolveWindowsCommandPath(command, options.envPath ?? getExtendedPath());
+    if (!resolved) {
+        return { command, args };
+    }
+    if (extname(resolved).toLowerCase() === ".ps1") {
+        return {
+            command: "powershell.exe",
+            args: ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", resolved, ...args],
+        };
+    }
+    return { command: resolved, args };
+}
+function resolveWindowsCommandPath(command, envPath) {
+    if (/[\\/]/.test(command)) {
+        return existsSync(command) ? command : null;
+    }
+    const hasExtension = extname(command) !== "";
+    const extensions = hasExtension ? [""] : ["", ".exe", ".ps1", ".cmd", ".bat"];
+    for (const dir of envPath.split(pathDelimiterFor("win32")).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = pathJoinFor("win32", dir, command + extension);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
 }
 /** Registry of active detached process groups for shutdown cleanup. */
 const activeProcessGroups = new Set();
@@ -152,7 +253,10 @@ function killWindowsProcessTree(pid) {
 }
 export function spawnCliProcess(command, args, options) {
     const detached = shouldDetachProviderProcess();
-    const proc = spawn(command, args, {
+    const resolved = resolveCommandForSpawn(command, args, {
+        envPath: pathValueFromEnv(options.env, process.platform),
+    });
+    const proc = spawn(resolved.command, resolved.args, {
         cwd: options.cwd,
         detached,
         windowsHide: true,
@@ -167,12 +271,13 @@ export function spawnCliProcess(command, args, options) {
 export async function executeCli(command, args, options = {}) {
     const { timeout, idleTimeout, cwd, env: extraEnv } = options;
     const extendedPath = getExtendedPath();
+    const baseEnv = envWithExtendedPath(process.env, extendedPath);
     const circuitBreaker = getCircuitBreaker(command);
     const runOnce = () => new Promise((resolve, reject) => {
         const proc = spawnCliProcess(command, args, {
             cwd,
             stdio: ["ignore", "pipe", "pipe"],
-            env: { ...process.env, PATH: extendedPath, ...(extraEnv ?? {}) },
+            env: { ...baseEnv, ...(extraEnv ?? {}) },
         });
         let stdout = "";
         let stderr = "";

package/dist/index.d.ts

@@ -160,6 +160,24 @@ export declare function prepareGeminiRequest(params: {
     adminPolicyFiles?: string[];
     attachments?: string[];
 }, runtime?: GatewayServerRuntime): CliRequestPrep | ExtendedToolResponse;
+export declare function prepareMistralRequest(params: {
+    prompt: string;
+    model?: string;
+    outputFormat?: string;
+    permissionMode?: MistralAgentMode;
+    effort?: string;
+    reasoningEffort?: string;
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    approvalStrategy: "legacy" | "mcp_managed";
+    approvalPolicy?: string;
+    mcpServers?: ClaudeMcpServerName[];
+    correlationId?: string;
+    optimizePrompt: boolean;
+    operation: string;
+}, runtime?: GatewayServerRuntime): (CliRequestPrep & {
+    mistralEnv: Record<string, string>;
+}) | ExtendedToolResponse;
 export interface GeminiRequestParams {
     prompt: string;
     model?: string;

package/dist/index.js

@@ -16,7 +16,7 @@ import { PerformanceMetrics } from "./metrics.js";
 import { estimateTokens, optimizePrompt as optimizePromptText, optimizeResponse as optimizeResponseText, } from "./optimizer.js";
 import { loadConfig, loadPersistenceConfig } from "./config.js";
 import { checkHealth } from "./health.js";
-import { clearModelRegistryCache, getCliInfo, resolveModelAlias } from "./model-registry.js";
+import { clearModelRegistryCache, getAvailableCliInfo, getCliInfo, resolveModelAlias, } from "./model-registry.js";
 import { AsyncJobManager } from "./async-job-manager.js";
 import { createJobStore } from "./job-store.js";
 import { ApprovalManager } from "./approval-manager.js";
@@ -1061,11 +1061,10 @@ function prepareGrokRequest(params, runtime = resolveGatewayServerRuntime()) {
         args,
     };
 }
-function prepareMistralRequest(params, runtime = resolveGatewayServerRuntime()) {
+export function prepareMistralRequest(params, runtime = resolveGatewayServerRuntime()) {
     const corrId = params.correlationId || randomUUID();
     const cliInfo = getCliInfo();
-    const requestedModel = params.model ?? (cliInfo.mistral.defaultModel ? "default" : undefined);
-    const resolvedModel = resolveModelAlias("mistral", requestedModel, cliInfo);
+    const resolvedModel = resolveModelAlias("mistral", params.model, cliInfo);
     const reviewIntegrity = checkReviewIntegrity({
         prompt: params.prompt,
         allowedTools: params.allowedTools,
@@ -3567,7 +3566,7 @@ export function createGatewayServer(deps = {}) {
             .preprocess(value => (value === "" || value === null ? undefined : value), z.enum(["claude", "codex", "gemini", "grok", "mistral"]).optional())
             .describe("CLI filter (claude|codex|gemini|grok|mistral)"),
     }, async ({ cli }) => {
-        const cliInfo = getCliInfo();
+        const cliInfo = getAvailableCliInfo();
         const result = cli ? { [cli]: cliInfo[cli] } : cliInfo;
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     });

package/dist/model-registry.d.ts

@@ -10,6 +10,7 @@ export interface ModelMetadata {
 export interface CliInfo {
     description: string;
     models: Record<string, string>;
+    unverifiedModelHints?: Record<string, string>;
     defaultModel?: string;
     defaultModelSource?: string;
     modelOrder?: string[];
@@ -19,6 +20,7 @@ export interface CliInfo {
 }
 export type CliInfoMap = Record<CliType, CliInfo>;
 export declare function getCliInfo(forceRefresh?: boolean): CliInfoMap;
+export declare function getAvailableCliInfo(forceRefresh?: boolean): CliInfoMap;
 export declare function clearModelRegistryCache(): void;
 export declare function resolveModelAlias(cli: CliType, model: string | undefined, info: CliInfoMap): string | undefined;
 export {};

package/dist/model-registry.js

@@ -75,6 +75,16 @@ export function getCliInfo(forceRefresh = false) {
     cachedInfo = { loadedAt: Date.now(), info };
     return info;
 }
+export function getAvailableCliInfo(forceRefresh = false) {
+    const info = getCliInfo(forceRefresh);
+    return {
+        claude: filterUnverifiedModelHints(info.claude),
+        codex: filterUnverifiedModelHints(info.codex),
+        gemini: filterUnverifiedModelHints(info.gemini),
+        grok: filterUnverifiedModelHints(info.grok),
+        mistral: filterUnverifiedModelHints(info.mistral),
+    };
+}
 export function clearModelRegistryCache() {
     cachedInfo = null;
 }
@@ -125,6 +135,9 @@ function cloneInfo(source) {
     const cloned = {
         description: source.description,
         models: { ...source.models },
+        unverifiedModelHints: source.unverifiedModelHints
+            ? { ...source.unverifiedModelHints }
+            : undefined,
         defaultModel: source.defaultModel,
         defaultModelSource: source.defaultModelSource,
         modelOrder: source.modelOrder ? [...source.modelOrder] : undefined,
@@ -141,6 +154,41 @@ function cloneInfo(source) {
     });
     return cloned;
 }
+function filterUnverifiedModelHints(source) {
+    const filtered = cloneInfo(source);
+    const models = {};
+    const metadata = {};
+    const hints = {};
+    Object.entries(source.models).forEach(([model, description]) => {
+        const modelMetadata = source.modelMetadata?.[model];
+        if (modelMetadata?.source === "fallback") {
+            hints[model] = description;
+            return;
+        }
+        models[model] = description;
+        if (modelMetadata) {
+            metadata[model] = modelMetadata;
+        }
+    });
+    filtered.models = models;
+    filtered.modelMetadata = metadata;
+    filtered.unverifiedModelHints = Object.keys(hints).length > 0 ? hints : undefined;
+    filtered.modelOrder = source.modelOrder?.filter(model => model in models);
+    if (filtered.defaultModel && !(filtered.defaultModel in models)) {
+        filtered.defaultModel = undefined;
+        filtered.defaultModelSource = undefined;
+    }
+    if (filtered.aliases) {
+        filtered.aliases = Object.fromEntries(Object.entries(filtered.aliases).filter(([, target]) => target === "default" || target in models));
+        if (Object.keys(filtered.aliases).length === 0) {
+            filtered.aliases = undefined;
+        }
+    }
+    if (filtered.unverifiedModelHints) {
+        addWarning(filtered, "Bundled fallback model hints were omitted from models because they are not validated against the installed CLI. They are exposed as unverifiedModelHints only.");
+    }
+    return filtered;
+}
 function addWarning(info, warning) {
     info.warnings = info.warnings ?? [];
     if (!info.warnings.includes(warning)) {

package/dist/provider-status.js

@@ -3,6 +3,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { getProviderLoginGuidance } from "./provider-login-guidance.js";
+import { envWithExtendedPath, getExtendedPath, resolveCommandForSpawn } from "./executor.js";
 const PROVIDERS = ["claude", "codex", "gemini", "grok", "mistral"];
 const VERSION_ARGS = {
     claude: ["--version"],
@@ -96,8 +97,12 @@ export function getProviderRuntimeStatus(provider) {
     };
 }
 function runCommand(command, args, timeoutMs) {
-    const result = spawnSync(command, args, {
+    const extendedPath = getExtendedPath();
+    const env = envWithExtendedPath(process.env, extendedPath);
+    const resolved = resolveCommandForSpawn(command, args, { envPath: extendedPath });
+    const result = spawnSync(resolved.command, resolved.args, {
         encoding: "utf8",
+        env,
         input: "",
         timeout: timeoutMs,
         windowsHide: true,

package/dist/resources.js

@@ -1,4 +1,4 @@
-import { getCliInfo } from "./model-registry.js";
+import { getAvailableCliInfo } from "./model-registry.js";
 export class ResourceProvider {
     sessionManager;
     performanceMetrics;
@@ -238,7 +238,7 @@ export class ResourceProvider {
         }
         // Model capability resources
         if (uri === "models://claude") {
-            const cliInfo = getCliInfo();
+            const cliInfo = getAvailableCliInfo();
             return {
                 uri,
                 mimeType: "application/json",
@@ -246,7 +246,7 @@ export class ResourceProvider {
             };
         }
         if (uri === "models://codex") {
-            const cliInfo = getCliInfo();
+            const cliInfo = getAvailableCliInfo();
             return {
                 uri,
                 mimeType: "application/json",
@@ -254,7 +254,7 @@ export class ResourceProvider {
             };
         }
         if (uri === "models://gemini") {
-            const cliInfo = getCliInfo();
+            const cliInfo = getAvailableCliInfo();
             return {
                 uri,
                 mimeType: "application/json",
@@ -262,7 +262,7 @@ export class ResourceProvider {
             };
         }
         if (uri === "models://grok") {
-            const cliInfo = getCliInfo();
+            const cliInfo = getAvailableCliInfo();
             return {
                 uri,
                 mimeType: "application/json",
@@ -270,7 +270,7 @@ export class ResourceProvider {
             };
         }
         if (uri === "models://mistral") {
-            const cliInfo = getCliInfo();
+            const cliInfo = getAvailableCliInfo();
             return {
                 uri,
                 mimeType: "application/json",

package/dist/validation-tools.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { getCliInfo } from "./model-registry.js";
+import { getAvailableCliInfo } from "./model-registry.js";
 import { collectValidationJobResult, startJudgeSynthesis, startValidationRun, } from "./validation-orchestrator.js";
 const providerSchema = z.enum(["claude", "codex", "gemini", "grok", "mistral"]);
 const providerListSchema = z.array(providerSchema).min(1).default(["claude", "codex"]);
@@ -160,7 +160,7 @@ export function registerValidationTools(server, deps) {
             judgeProvider: judgeModel,
         }),
     }));
-    server.tool("list_available_models", {}, async () => textResponse({ success: true, models: getCliInfo() }));
+    server.tool("list_available_models", {}, async () => textResponse({ success: true, models: getAvailableCliInfo() }));
     server.tool("job_status", {
         jobId: z.string().min(1).describe("Validation job ID."),
     }, async ({ jobId }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "llm-cli-gateway",
-  "version": "1.5.18",
+  "version": "1.5.21",
   "mcpName": "io.github.verivus-oss/llm-cli-gateway",
   "description": "MCP server providing unified access to Claude Code, Codex, Gemini, Grok, and Mistral Vibe CLIs with session management, retry logic, async job orchestration, durable job results, and cross-LLM validation.",
   "license": "MIT",