nvicode 0.1.19 → 0.1.21

package/README.md

@@ -6,7 +6,7 @@
 [![node >=20](https://img.shields.io/badge/node-%3E%3D20-339933)](https://nodejs.org/)
 [![license: MIT](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
 
-Route Claude Code, Codex CLI, and OpenClaw through NVIDIA or OpenRouter with one setup.
+Route Claude Code, Codex CLI, Codex desktop app, and OpenClaw through NVIDIA or OpenRouter with one setup.
 
 `nvicode` lets you choose a provider once, save the API key once, pick a model once, and then launch the coding tool you want against that same backend.
 
@@ -14,9 +14,12 @@ What it gives you:
 - One guided setup flow for provider, key, and model
 - Claude Code support
 - Codex CLI support
+- Codex desktop app support on macOS
 - OpenClaw support
 - NVIDIA proxy mode with pacing and local usage tracking
 - OpenRouter direct mode for compatible models
+- Dynamic NVIDIA model discovery for current Kimi, DeepSeek, GLM, and Qwen picks
+- Dynamic OpenRouter free-model discovery for current Kimi, Qwen, GPT-OSS, Nemotron, Gemma, and Llama picks
 
 Supported environments:
 - macOS
@@ -43,17 +46,19 @@ Launch the tool you want:
 ```sh
 nvicode launch claude
 nvicode launch codex
+nvicode launch codex-app
 nvicode launch openclaw
 ```
 
 Provider setup:
 
 - NVIDIA: get a free key from [NVIDIA Build API Keys](https://build.nvidia.com/settings/api-keys)
-- OpenRouter: use your OpenRouter API key
+- OpenRouter: use your OpenRouter API key and pick from current free models
 
 What happens after first launch:
 - The first successful `nvicode launch claude` installs persistent plain `claude` routing.
 - The first successful `nvicode launch codex` installs persistent plain `codex` routing.
+- `nvicode launch codex-app` configures and opens the Codex desktop app.
 - `nvicode launch openclaw` updates the default OpenClaw profile for the selected provider/model.
 
 After that, plain:
@@ -87,6 +92,10 @@ continues using your selected `nvicode` provider and model.
 - Codex CLI:
   - uses the local `nvicode` proxy
   - `nvicode` configures Codex to talk to that proxy through the Responses API
+- Codex desktop app:
+  - uses the same local `nvicode` proxy through Codex user-level `config.toml`
+  - uses a managed authentication command that starts the proxy when needed
+  - preserves a one-time `config.toml.nvicode.bak` backup before the first config change
 - OpenClaw:
   - updates the default OpenClaw config for the selected provider/model
   - restart the gateway after config changes:
@@ -103,6 +112,8 @@ Common commands:
 nvicode select model
 nvicode launch claude
 nvicode launch codex
+nvicode configure codex-app
+nvicode launch codex-app
 nvicode launch openclaw
 nvicode dashboard
 nvicode usage
@@ -116,8 +127,13 @@ nvicode launch codex "Explain this project"
 
 Behavior notes:
 - `nvicode select model` asks for provider, optional API key update, and model choice in one guided flow.
+- For NVIDIA, model selection fetches the live NVIDIA catalog and highlights one current top pick each from Kimi, DeepSeek, GLM, and Qwen before falling back to curated defaults.
+- For OpenRouter, model selection fetches the live OpenRouter catalog and shows top free endpoints first. If no free DeepSeek or GLM endpoint exists, they are not shown as free.
+- On launch, `nvicode` replaces a retired saved NVIDIA model with the current recommended catalog pick.
 - Claude Code uses direct OpenRouter mode for OpenRouter, and proxy mode for NVIDIA.
-- Codex currently uses the local `nvicode` proxy path.
+- Codex CLI and the Codex desktop app use the local `nvicode` proxy path.
+- `nvicode configure codex-app` updates the user-level Codex `config.toml` model and provider while preserving unrelated Codex settings.
+- `nvicode launch codex-app` currently targets the macOS Codex desktop app.
 - `nvicode usage`, `activity`, and `dashboard` are currently focused on NVIDIA proxy sessions.
 - OpenRouter does not currently produce the same local usage visibility as the NVIDIA proxy flow.
 - NVIDIA requests are paced to `40 RPM` by default. Override with `NVICODE_MAX_RPM` if your account allows more.
@@ -131,6 +147,7 @@ If your NVIDIA endpoint is not free, override local cost estimates with `NVICODE
 
 - Claude Code must already be installed to use `nvicode launch claude`.
 - Codex must already be installed to use `nvicode launch codex`. Install with `npm install -g @openai/codex`.
+- Codex.app must already be installed on macOS to use `nvicode launch codex-app`.
 - OpenClaw must already be installed to use `nvicode launch openclaw`. Install with `npm install -g openclaw@latest`.
 - Node.js 20 or newer is required to install `nvicode`.
 - OpenClaw itself requires Node.js `>=22.14.0`.
@@ -151,4 +168,4 @@ npm link
 - `thinking` is disabled by default because some NVIDIA reasoning models can consume the entire output budget and return no visible answer to Claude Code.
 - The proxy supports basic text, tool calls, tool results, and token count estimation.
 - The proxy includes upstream request pacing and retries on NVIDIA `429` responses.
-- Claude Code, Codex CLI, and OpenClaw remain the frontends; the selected provider/model becomes the backend.
+- Claude Code, Codex CLI, Codex desktop app, and OpenClaw remain the frontends; the selected provider/model becomes the backend.

package/dist/cli.js

@@ -10,10 +10,12 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { getActiveApiKey, getActiveModel, getNvicodePaths, loadConfig, saveConfig, } from "./config.js";
 import { createProxyServer } from "./proxy.js";
-import { getRecommendedModels } from "./models.js";
+import { fetchAvailableModelIds, getRecommendedModels, getRecommendedNvidiaModels, } from "./models.js";
 import { filterRecordsSince, formatDuration, formatInteger, formatTimestamp, formatUsd, readUsageRecords, summarizeUsage, } from "./usage.js";
 const __filename = fileURLToPath(import.meta.url);
 const NVICODE_WRAPPER_MARKER = "managed by nvicode";
+const CODEX_APP_CONFIG_START = "# >>> nvicode codex app provider >>>";
+const CODEX_APP_CONFIG_END = "# <<< nvicode codex app provider <<<";
 const usage = () => {
     console.log(`nvicode
 
@@ -28,6 +30,8 @@ Commands:
   nvicode launch claude [...]   Launch Claude Code through nvicode
   nvicode launch openclaw [...] Launch OpenClaw through nvicode
   nvicode launch codex [...]    Launch Codex through nvicode
+  nvicode configure codex-app   Configure the Codex desktop app
+  nvicode launch codex-app      Configure and open the Codex desktop app
   nvicode serve                 Run the local proxy in the foreground
 `);
 };
@@ -75,8 +79,23 @@ const readIfExists = async (targetPath) => {
         return null;
     }
 };
+const readTextPrefixIfExists = async (targetPath, byteLength = 4096) => {
+    let handle = null;
+    try {
+        handle = await fs.open(targetPath, "r");
+        const buffer = Buffer.alloc(byteLength);
+        const { bytesRead } = await handle.read(buffer, 0, byteLength, 0);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    catch {
+        return null;
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+};
 const isManagedClaudeWrapper = async (targetPath) => {
-    const contents = await readIfExists(targetPath);
+    const contents = await readTextPrefixIfExists(targetPath);
     return contents?.includes(NVICODE_WRAPPER_MARKER) ?? false;
 };
 const renderClaudeWrapper = () => {
@@ -207,10 +226,29 @@ const ensureConfigured = async () => {
             ...config,
             ...(config.provider === "openrouter"
                 ? { openrouterModel: first?.id || "anthropic/claude-sonnet-4.6" }
-                : { nvidiaModel: first?.id || "moonshotai/kimi-k2.5" }),
+                : { nvidiaModel: first?.id || "moonshotai/kimi-k2.6" }),
         };
         changed = true;
     }
+    if (config.provider === "nvidia" && config.nvidiaApiKey && config.nvidiaModel) {
+        try {
+            const available = await fetchAvailableModelIds(config.nvidiaApiKey);
+            if (!available.has(config.nvidiaModel)) {
+                const [first] = getRecommendedNvidiaModels(available);
+                if (first && first.id !== config.nvidiaModel) {
+                    console.error(`Saved NVIDIA model ${config.nvidiaModel} is no longer available. Switching to ${first.id}.`);
+                    config = {
+                        ...config,
+                        nvidiaModel: first.id,
+                    };
+                    changed = true;
+                }
+            }
+        }
+        catch {
+            // Keep the saved model when the NVIDIA catalog is temporarily unavailable.
+        }
+    }
     if (changed) {
         config = await saveConfig(config);
     }
@@ -237,6 +275,9 @@ const runAuth = async () => {
 };
 const printModels = async (provider, apiKey) => {
     const models = await getRecommendedModels(provider, apiKey || "");
+    printModelOptions(models);
+};
+const printModelOptions = (models) => {
     models.forEach((model, index) => {
         console.log(`${index + 1}. ${model.label}`);
         console.log(`   ${model.id}`);
@@ -254,10 +295,12 @@ const runSelectModel = async () => {
         provider,
     });
     const models = await getRecommendedModels(provider, getActiveApiKey(nextConfig));
-    console.log(`Top popular ${providerLabel} models:`);
-    await printModels(provider, getActiveApiKey(nextConfig));
+    console.log(provider === "openrouter"
+        ? "Top free OpenRouter models:"
+        : "Top popular NVIDIA models:");
+    printModelOptions(models);
     console.log("Or paste a full model id.");
-    console.log("Example: qwen/qwen3.6-plus-preview:free");
+    console.log("Example: qwen/qwen3-coder:free");
     const answer = await question("Model selection: ");
     const index = Number(answer);
     const chosenModel = Number.isInteger(index) && index >= 1 && index <= models.length
@@ -448,11 +491,19 @@ const runDashboard = async () => {
     console.log("");
     await runActivity();
 };
-const waitForHealthyProxy = async (port) => {
+const PROXY_PROTOCOL_VERSION = 2;
+const isExpectedProxyHealth = (config, health) => health.ok === true &&
+    health.proxyProtocolVersion === PROXY_PROTOCOL_VERSION &&
+    health.provider === config.provider &&
+    health.model === getActiveModel(config) &&
+    health.port === config.proxyPort &&
+    health.thinking === config.thinking &&
+    health.maxRequestsPerMinute === config.maxRequestsPerMinute;
+const waitForHealthyProxy = async (config) => {
     for (let attempt = 0; attempt < 50; attempt += 1) {
         try {
-            const response = await fetch(`http://127.0.0.1:${port}/health`);
-            if (response.ok) {
+            const response = await fetch(`http://127.0.0.1:${config.proxyPort}/health`);
+            if (response.ok && isExpectedProxyHealth(config, await response.json())) {
                 return true;
             }
         }
@@ -463,11 +514,35 @@ const waitForHealthyProxy = async (port) => {
     }
     return false;
 };
+const stopExistingProxy = async () => {
+    const paths = getNvicodePaths();
+    const rawPid = await readIfExists(paths.pidFile);
+    const pid = Number(rawPid?.trim());
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return;
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        return;
+    }
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        try {
+            process.kill(pid, 0);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        catch {
+            break;
+        }
+    }
+};
 const ensureProxyRunning = async (config) => {
-    if (await waitForHealthyProxy(config.proxyPort)) {
+    if (await waitForHealthyProxy(config)) {
         return;
     }
     const paths = getNvicodePaths();
+    await stopExistingProxy();
     await fs.mkdir(paths.stateDir, { recursive: true });
     const logFd = openSync(paths.logFile, "a");
     const child = spawn(process.execPath, [__filename, "serve"], {
@@ -480,7 +555,7 @@ const ensureProxyRunning = async (config) => {
     });
     child.unref();
     await fs.writeFile(paths.pidFile, `${child.pid}\n`);
-    if (!(await waitForHealthyProxy(config.proxyPort))) {
+    if (!(await waitForHealthyProxy(config))) {
         throw new Error(`nvicode proxy failed to start. See ${paths.logFile}`);
     }
 };
@@ -536,6 +611,89 @@ const resolvePersistentClaudeCommand = async () => {
     }
     return null;
 };
+const normalizePathForComparison = async (targetPath) => {
+    const resolved = path.resolve(targetPath);
+    try {
+        const real = await fs.realpath(resolved);
+        return isWindows ? real.toLowerCase() : real;
+    }
+    catch {
+        return isWindows ? resolved.toLowerCase() : resolved;
+    }
+};
+const getPathDirectoryIndex = async (directory) => {
+    const target = await normalizePathForComparison(directory);
+    const pathEntries = (process.env.PATH || "").split(path.delimiter);
+    for (let index = 0; index < pathEntries.length; index += 1) {
+        const entry = pathEntries[index];
+        if (!entry) {
+            continue;
+        }
+        if ((await normalizePathForComparison(entry)) === target) {
+            return index;
+        }
+    }
+    return -1;
+};
+const resolveClaudeShadowWrapperPath = async (claudeCommandPath) => {
+    const nvicodeCommandPath = await findExecutableInPath("nvicode");
+    if (!nvicodeCommandPath) {
+        return null;
+    }
+    const nvicodeDirectory = path.dirname(nvicodeCommandPath);
+    const claudeDirectory = path.dirname(claudeCommandPath);
+    if ((await normalizePathForComparison(nvicodeDirectory)) ===
+        (await normalizePathForComparison(claudeDirectory))) {
+        return null;
+    }
+    const nvicodeIndex = await getPathDirectoryIndex(nvicodeDirectory);
+    const claudeIndex = await getPathDirectoryIndex(claudeDirectory);
+    if (nvicodeIndex < 0 || claudeIndex < 0 || nvicodeIndex > claudeIndex) {
+        return null;
+    }
+    for (const candidate of buildExecutableCandidates(nvicodeDirectory, "claude")) {
+        if ((await pathExists(candidate)) && !(await isManagedClaudeWrapper(candidate))) {
+            return null;
+        }
+    }
+    return path.join(nvicodeDirectory, isWindows ? "claude.cmd" : "claude");
+};
+const mergeRoutingStatus = (left, right) => {
+    if (left === "installed" || right === "installed") {
+        return "installed";
+    }
+    if (left === "updated" || right === "updated") {
+        return "updated";
+    }
+    if (left === "already" || right === "already") {
+        return "already";
+    }
+    return "skipped";
+};
+const resolveLatestClaudeManagedVersion = async () => {
+    const versionsDir = path.join(os.homedir(), ".local", "share", "claude", "versions");
+    try {
+        const entries = await fs.readdir(versionsDir);
+        const sortedEntries = entries.sort((left, right) => left.localeCompare(right, undefined, {
+            numeric: true,
+            sensitivity: "base",
+        }));
+        for (let index = sortedEntries.length - 1; index >= 0; index -= 1) {
+            const entry = sortedEntries[index];
+            if (!entry) {
+                continue;
+            }
+            const resolved = await resolveClaudeVersionEntry(path.join(versionsDir, entry));
+            if (resolved) {
+                return resolved;
+            }
+        }
+    }
+    catch {
+        // continue with other install layouts
+    }
+    return null;
+};
 const getWrapperInstallPaths = async (claudeCommandPath) => {
     const directory = path.dirname(claudeCommandPath);
     const existingNative = await findExistingClaudeNativeInDirectory(directory);
@@ -564,6 +722,101 @@ const writeExecutableTextFile = async (targetPath, contents) => {
         await fs.chmod(targetPath, 0o755);
     }
 };
+const getCodexConfigFile = () => path.join(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"), "config.toml");
+const renderTomlString = (value) => JSON.stringify(value);
+const renderTomlStringArray = (values) => `[${values.map(renderTomlString).join(", ")}]`;
+const stripManagedCodexAppProvider = (contents) => {
+    let remaining = contents;
+    while (remaining.includes(CODEX_APP_CONFIG_START)) {
+        const start = remaining.indexOf(CODEX_APP_CONFIG_START);
+        const end = remaining.indexOf(CODEX_APP_CONFIG_END, start);
+        if (end < 0) {
+            throw new Error(`Unable to update Codex app config: missing ${CODEX_APP_CONFIG_END}`);
+        }
+        remaining = [
+            remaining.slice(0, start).trimEnd(),
+            remaining.slice(end + CODEX_APP_CONFIG_END.length).trimStart(),
+        ]
+            .filter(Boolean)
+            .join("\n");
+    }
+    return remaining;
+};
+const upsertRootTomlSetting = (contents, key, value) => {
+    const lines = contents.split("\n");
+    const firstTableIndex = lines.findIndex((line) => /^\s*\[/.test(line));
+    const rootEnd = firstTableIndex < 0 ? lines.length : firstTableIndex;
+    const settingPattern = new RegExp(`^\\s*${key}\\s*=`);
+    for (let index = 0; index < rootEnd; index += 1) {
+        if (settingPattern.test(lines[index] || "")) {
+            lines[index] = `${key} = ${value}`;
+            return lines.join("\n");
+        }
+    }
+    const modelIndex = lines.findIndex((line, index) => index < rootEnd && /^\s*model\s*=/.test(line));
+    lines.splice(modelIndex >= 0 ? modelIndex + 1 : 0, 0, `${key} = ${value}`);
+    return lines.join("\n");
+};
+const renderManagedCodexAppProvider = (config) => {
+    const proxyBaseUrl = `http://127.0.0.1:${config.proxyPort}/v1`;
+    return [
+        CODEX_APP_CONFIG_START,
+        "[model_providers.nvicode]",
+        'name = "nvicode proxy"',
+        `base_url = ${renderTomlString(proxyBaseUrl)}`,
+        'wire_api = "responses"',
+        "supports_websockets = false",
+        "",
+        "[model_providers.nvicode.auth]",
+        `command = ${renderTomlString(process.execPath)}`,
+        `args = ${renderTomlStringArray([__filename, "codex-app-token"])}`,
+        "timeout_ms = 15000",
+        CODEX_APP_CONFIG_END,
+    ].join("\n");
+};
+const ensureCodexAppConfigured = async (config) => {
+    const configFile = getCodexConfigFile();
+    const existing = (await readIfExists(configFile)) || "";
+    let next = stripManagedCodexAppProvider(existing);
+    if (/^\s*\[model_providers\.nvicode(?:\.auth)?\]\s*$/m.test(next)) {
+        throw new Error(`Unable to configure Codex app: ${configFile} already contains an unmanaged [model_providers.nvicode] block.`);
+    }
+    next = upsertRootTomlSetting(next, "model", renderTomlString(getActiveModel(config)));
+    next = upsertRootTomlSetting(next, "model_provider", '"nvicode"');
+    next = `${next.trimEnd()}\n\n${renderManagedCodexAppProvider(config)}\n`;
+    if (next === existing) {
+        return { configFile, updated: false };
+    }
+    await fs.mkdir(path.dirname(configFile), { recursive: true });
+    if (await pathExists(configFile)) {
+        await fs.copyFile(configFile, `${configFile}.nvicode.bak`, constants.COPYFILE_EXCL).catch((error) => {
+            if (error.code !== "EEXIST") {
+                throw error;
+            }
+        });
+    }
+    await fs.writeFile(configFile, next, "utf8");
+    return { configFile, updated: true };
+};
+const ensureClaudeShadowRouting = async (claudeCommandPath, wrapperContents) => {
+    const shadowWrapperPath = await resolveClaudeShadowWrapperPath(claudeCommandPath);
+    if (!shadowWrapperPath) {
+        return "skipped";
+    }
+    if (await isManagedClaudeWrapper(shadowWrapperPath)) {
+        const currentWrapper = await readIfExists(shadowWrapperPath);
+        if (currentWrapper === wrapperContents) {
+            return "already";
+        }
+        await writeExecutableTextFile(shadowWrapperPath, wrapperContents);
+        return "updated";
+    }
+    if (await pathExists(shadowWrapperPath)) {
+        return "skipped";
+    }
+    await writeExecutableTextFile(shadowWrapperPath, wrapperContents);
+    return "installed";
+};
 const ensurePersistentClaudeRouting = async () => {
     const claudeCommandPath = await resolvePersistentClaudeCommand();
     if (!claudeCommandPath) {
@@ -571,25 +824,31 @@ const ensurePersistentClaudeRouting = async () => {
     }
     const wrapperContents = renderClaudeWrapper();
     const { wrapperPath, nativePath } = await getWrapperInstallPaths(claudeCommandPath);
+    let routingStatus = "skipped";
     if (await isManagedClaudeWrapper(wrapperPath)) {
         const currentWrapper = await readIfExists(wrapperPath);
         if (currentWrapper === wrapperContents) {
-            return "already";
+            routingStatus = "already";
+        }
+        else {
+            await writeExecutableTextFile(wrapperPath, wrapperContents);
+            routingStatus = "updated";
         }
-        await writeExecutableTextFile(wrapperPath, wrapperContents);
-        return "updated";
-    }
-    if (!(await pathExists(nativePath))) {
-        await fs.rename(claudeCommandPath, nativePath);
-    }
-    else if (claudeCommandPath !== wrapperPath && await pathExists(wrapperPath)) {
-        await fs.rm(wrapperPath, { force: true });
     }
-    else if (claudeCommandPath === wrapperPath) {
-        await fs.rm(wrapperPath, { force: true });
+    else {
+        if (!(await pathExists(nativePath))) {
+            await fs.rename(claudeCommandPath, nativePath);
+        }
+        else if (claudeCommandPath !== wrapperPath && await pathExists(wrapperPath)) {
+            await fs.rm(wrapperPath, { force: true });
+        }
+        else if (claudeCommandPath === wrapperPath) {
+            await fs.rm(wrapperPath, { force: true });
+        }
+        await writeExecutableTextFile(wrapperPath, wrapperContents);
+        routingStatus = "installed";
     }
-    await writeExecutableTextFile(wrapperPath, wrapperContents);
-    return "installed";
+    return mergeRoutingStatus(routingStatus, await ensureClaudeShadowRouting(claudeCommandPath, wrapperContents));
 };
 const findExistingCodexNativeInDirectory = async (directory) => {
     for (const name of getCodexNativeNames()) {
@@ -656,6 +915,10 @@ const ensurePersistentCodexRouting = async () => {
     return "installed";
 };
 const resolveClaudeBinary = async () => {
+    const latestManagedVersion = await resolveLatestClaudeManagedVersion();
+    if (latestManagedVersion) {
+        return latestManagedVersion;
+    }
     for (const name of getClaudeNativeNames()) {
         const nativeInPath = await findExecutableInPath(name);
         if (nativeInPath) {
@@ -674,27 +937,10 @@ const resolveClaudeBinary = async () => {
             path.join(os.homedir(), ".local", "bin", "claude"),
         ];
     for (const candidate of homeBinCandidates) {
-        if (await isExecutable(candidate)) {
+        if ((await isExecutable(candidate)) && !(await isManagedClaudeWrapper(candidate))) {
             return candidate;
         }
     }
-    const versionsDir = path.join(os.homedir(), ".local", "share", "claude", "versions");
-    try {
-        const entries = await fs.readdir(versionsDir);
-        const latest = entries.sort((left, right) => left.localeCompare(right, undefined, {
-            numeric: true,
-            sensitivity: "base",
-        })).at(-1);
-        if (latest) {
-            const resolved = await resolveClaudeVersionEntry(path.join(versionsDir, latest));
-            if (resolved) {
-                return resolved;
-            }
-        }
-    }
-    catch {
-        // continue
-    }
     for (const name of getClaudeCommandNames()) {
         const claudeInPath = await findExecutableInPath(name);
         if (claudeInPath && !(await isManagedClaudeWrapper(claudeInPath))) {
@@ -938,6 +1184,62 @@ const runLaunchCodex = async (args) => {
         child.on("error", reject);
     });
 };
+const resolveCodexAppBundle = async () => {
+    if (process.platform !== "darwin") {
+        throw new Error("Codex desktop app launch is currently supported on macOS only.");
+    }
+    const candidates = [
+        "/Applications/Codex.app",
+        path.join(os.homedir(), "Applications", "Codex.app"),
+    ];
+    for (const candidate of candidates) {
+        if (await pathExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to locate Codex.app. Install the Codex desktop app first.");
+};
+const runConfigureCodexApp = async () => {
+    const config = await ensureConfigured();
+    const { configFile, updated } = await ensureCodexAppConfigured(config);
+    console.log(updated
+        ? `Configured Codex desktop app routing in ${configFile}.`
+        : `Codex desktop app routing is already configured in ${configFile}.`);
+    console.log(`Codex desktop app model: ${getActiveModel(config)}`);
+};
+const runCodexAppToken = async () => {
+    const config = await ensureConfigured();
+    await ensureCodexAppConfigured(config);
+    await ensureProxyRunning(config);
+    console.log(config.proxyToken);
+};
+const runLaunchCodexApp = async (args) => {
+    const codexAppBundle = await resolveCodexAppBundle();
+    const config = await ensureConfigured();
+    const { configFile, updated } = await ensureCodexAppConfigured(config);
+    await ensureProxyRunning(config);
+    console.error(`${updated ? "Configured" : "Using"} Codex desktop app routing in ${configFile}.`);
+    console.error(`Opening Codex.app with ${getActiveModel(config)} through nvicode.`);
+    console.error("If Codex.app was already running, quit and reopen it once to reload the provider config.");
+    const child = spawn("/usr/bin/open", ["-a", codexAppBundle, ...args], {
+        stdio: "inherit",
+        windowsHide: true,
+    });
+    await new Promise((resolve, reject) => {
+        child.on("exit", (code, signal) => {
+            if (signal) {
+                reject(new Error(`Unable to open Codex.app: open exited with signal ${signal}`));
+                return;
+            }
+            if ((code ?? 0) !== 0) {
+                reject(new Error(`Unable to open Codex.app: open exited with code ${code ?? 0}`));
+                return;
+            }
+            resolve();
+        });
+        child.on("error", reject);
+    });
+};
 const runLaunchClaude = async (args) => {
     const config = await ensureConfigured();
     const routingStatus = await ensurePersistentClaudeRouting().catch(() => "skipped");
@@ -949,7 +1251,7 @@ const runLaunchClaude = async (args) => {
             ...process.env,
             ANTHROPIC_BASE_URL: "https://openrouter.ai/api",
             ANTHROPIC_AUTH_TOKEN: activeApiKey,
-            ANTHROPIC_API_KEY: "",
+            ANTHROPIC_API_KEY: activeApiKey,
             ANTHROPIC_MODEL: activeModel,
             ANTHROPIC_DEFAULT_SONNET_MODEL: activeModel,
             ANTHROPIC_DEFAULT_OPUS_MODEL: activeModel,
@@ -962,7 +1264,7 @@ const runLaunchClaude = async (args) => {
                 ...process.env,
                 ANTHROPIC_BASE_URL: `http://127.0.0.1:${config.proxyPort}`,
                 ANTHROPIC_AUTH_TOKEN: config.proxyToken,
-                ANTHROPIC_API_KEY: "",
+                ANTHROPIC_API_KEY: config.proxyToken,
                 ANTHROPIC_MODEL: activeModel,
                 CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
                 ANTHROPIC_CUSTOM_MODEL_OPTION: activeModel,
@@ -1015,6 +1317,10 @@ const main = async () => {
         await runServe();
         return;
     }
+    if (command === "codex-app-token") {
+        await runCodexAppToken();
+        return;
+    }
     if (command === "models") {
         const config = await loadConfig();
         await printModels(config.provider, getActiveApiKey(config) || undefined);
@@ -1045,6 +1351,10 @@ const main = async () => {
         await runSelectModel();
         return;
     }
+    if (command === "configure" && rest[0] === "codex-app") {
+        await runConfigureCodexApp();
+        return;
+    }
     if (command === "launch") {
         if (rest[0] === "claude") {
             await runLaunchClaude(rest.slice(1));
@@ -1058,7 +1368,11 @@ const main = async () => {
             await runLaunchCodex(rest.slice(1));
             return;
         }
-        throw new Error("Supported launch targets are `claude`, `openclaw`, and `codex`.");
+        if (rest[0] === "codex-app") {
+            await runLaunchCodexApp(rest.slice(1));
+            return;
+        }
+        throw new Error("Supported launch targets are `claude`, `openclaw`, `codex`, and `codex-app`.");
     }
     throw new Error(`Unknown command: ${command}`);
 };

package/dist/config.js

@@ -4,9 +4,20 @@ import os from "node:os";
 import path from "node:path";
 const DEFAULT_PROXY_PORT = 8788;
 const DEFAULT_PROVIDER = "nvidia";
-const DEFAULT_NVIDIA_MODEL = "moonshotai/kimi-k2.5";
+const DEFAULT_NVIDIA_MODEL = "moonshotai/kimi-k2.6";
 const DEFAULT_OPENROUTER_MODEL = "anthropic/claude-sonnet-4.6";
 const DEFAULT_MAX_REQUESTS_PER_MINUTE = 40;
+const NVIDIA_MODEL_ALIASES = {
+    "moonshotai/kimi-k2.5": "moonshotai/kimi-k2.6",
+    "deepseek/deepseek-v4-pro": "deepseek-ai/deepseek-v4-flash",
+    "deepseek-ai/deepseek-v4-pro": "deepseek-ai/deepseek-v4-flash",
+    "deepseek-ai/deepseek-v3.2": "deepseek-ai/deepseek-v4-flash",
+};
+const OPENROUTER_MODEL_ALIASES = {
+    "qwen/qwen3.6-plus-preview:free": "qwen/qwen3-coder:free",
+};
+const normalizeNvidiaModel = (model) => NVIDIA_MODEL_ALIASES[model] || model;
+const normalizeOpenRouterModel = (model) => OPENROUTER_MODEL_ALIASES[model] || model;
 const getEnvNumber = (name) => {
     const raw = process.env[name];
     if (!raw) {
@@ -61,9 +72,9 @@ const withDefaults = (config) => {
     return {
         provider: config.provider === "openrouter" ? "openrouter" : DEFAULT_PROVIDER,
         nvidiaApiKey: config.nvidiaApiKey?.trim() || legacyApiKey,
-        nvidiaModel: config.nvidiaModel?.trim() || legacyModel,
+        nvidiaModel: normalizeNvidiaModel(config.nvidiaModel?.trim() || legacyModel),
         openrouterApiKey: config.openrouterApiKey?.trim() || "",
-        openrouterModel: config.openrouterModel?.trim() || DEFAULT_OPENROUTER_MODEL,
+        openrouterModel: normalizeOpenRouterModel(config.openrouterModel?.trim() || DEFAULT_OPENROUTER_MODEL),
         proxyPort: Number.isInteger(config.proxyPort) && config.proxyPort > 0
             ? config.proxyPort
             : DEFAULT_PROXY_PORT,

package/dist/models.js

@@ -1,7 +1,7 @@
 export const NVIDIA_CURATED_MODELS = [
     {
-        id: "moonshotai/kimi-k2.5",
-        label: "Kimi K2.5",
+        id: "moonshotai/kimi-k2.6",
+        label: "Kimi K2.6",
         description: "Strong coding and agentic workflow model.",
     },
     {
@@ -15,9 +15,9 @@ export const NVIDIA_CURATED_MODELS = [
         description: "General purpose reasoning model with code capability.",
     },
     {
-        id: "deepseek-ai/deepseek-v3.2",
-        label: "DeepSeek V3.2",
-        description: "General coding and reasoning model.",
+        id: "deepseek-ai/deepseek-v4-flash",
+        label: "DeepSeek V4 Flash",
+        description: "Responsive DeepSeek V4-family model.",
     },
     {
         id: "mistralai/codestral-22b-instruct-v0.1",
@@ -30,29 +30,75 @@ export const NVIDIA_CURATED_MODELS = [
         description: "Smaller coding-focused Qwen model.",
     },
 ];
+const NVIDIA_MODEL_FAMILIES = [
+    {
+        name: "Kimi",
+        labelPrefix: "Kimi",
+        description: "Latest available Kimi model from NVIDIA.",
+        match: /^moonshotai\/kimi/i,
+        prefer: [/k2\.5/i, /thinking/i, /instruct/i],
+    },
+    {
+        name: "DeepSeek",
+        labelPrefix: "DeepSeek",
+        description: "Latest available DeepSeek model from NVIDIA.",
+        match: /^deepseek-ai\/deepseek/i,
+        prefer: [/v4-flash/i, /v4-pro/i, /v4/i, /v3\.2/i, /coder/i],
+    },
+    {
+        name: "GLM",
+        labelPrefix: "GLM",
+        description: "Latest available GLM model from NVIDIA.",
+        match: /^z-ai\/glm/i,
+        prefer: [/5\.1/i, /5/i, /4\.7/i],
+    },
+    {
+        name: "Qwen",
+        labelPrefix: "Qwen",
+        description: "Latest available Qwen coding model from NVIDIA.",
+        match: /^qwen\/qwen/i,
+        prefer: [/qwen3-coder/i, /qwen3\.5/i, /qwen3-next/i, /qwen3/i, /qwen2\.5-coder/i],
+    },
+];
 export const OPENROUTER_CURATED_MODELS = [
     {
-        id: "qwen/qwen3.6-plus-preview:free",
-        label: "Qwen 3.6 Plus Preview (Free)",
-        description: "Free OpenRouter Qwen preview model.",
+        id: "moonshotai/kimi-k2.6:free",
+        label: "Kimi K2.6 (Free)",
+        description: "Free OpenRouter Kimi endpoint for coding and agentic workflows.",
+    },
+    {
+        id: "qwen/qwen3-coder:free",
+        label: "Qwen3 Coder (Free)",
+        description: "Free OpenRouter Qwen coding model.",
+    },
+    {
+        id: "openai/gpt-oss-120b:free",
+        label: "GPT-OSS 120B (Free)",
+        description: "Free OpenRouter open-weight reasoning model.",
+    },
+    {
+        id: "nvidia/nemotron-3-super-120b-a12b:free",
+        label: "Nemotron 3 Super 120B (Free)",
+        description: "Free OpenRouter NVIDIA Nemotron model.",
     },
     {
-        id: "anthropic/claude-sonnet-4.6",
-        label: "Claude Sonnet 4.6",
-        description: "Recommended OpenRouter model for Claude Code compatibility.",
+        id: "google/gemma-4-31b-it:free",
+        label: "Gemma 4 31B (Free)",
+        description: "Free OpenRouter Gemma instruction model.",
     },
     {
-        id: "anthropic/claude-opus-4.6",
-        label: "Claude Opus 4.6",
-        description: "Higher-end Anthropic model through OpenRouter.",
+        id: "meta-llama/llama-3.3-70b-instruct:free",
+        label: "Llama 3.3 70B (Free)",
+        description: "Free OpenRouter Llama instruction model.",
     },
     {
-        id: "anthropic/claude-haiku-4.5",
-        label: "Claude Haiku 4.5",
-        description: "Faster lower-cost Anthropic model through OpenRouter.",
+        id: "qwen/qwen3-next-80b-a3b-instruct:free",
+        label: "Qwen3 Next 80B (Free)",
+        description: "Free OpenRouter Qwen instruction model.",
     },
 ];
 const MODELS_URL = "https://integrate.api.nvidia.com/v1/models";
+const OPENROUTER_MODELS_URL = "https://openrouter.ai/api/v1/models";
 export const fetchAvailableModelIds = async (apiKey) => {
     const response = await fetch(MODELS_URL, {
         headers: {
@@ -71,14 +117,218 @@ export const fetchAvailableModelIds = async (apiKey) => {
     }
     return ids;
 };
+const OPENROUTER_MODEL_FAMILIES = [
+    {
+        name: "Kimi",
+        labelPrefix: "Kimi",
+        description: "Top free Kimi model from OpenRouter.",
+        match: /^(?:~)?moonshotai\/kimi/i,
+        prefer: [/k2\.6/i, /k2\.5/i, /latest/i, /thinking/i],
+    },
+    {
+        name: "Qwen",
+        labelPrefix: "Qwen",
+        description: "Top free Qwen coding model from OpenRouter.",
+        match: /^qwen\/qwen/i,
+        prefer: [/qwen3-coder/i, /qwen3-next/i, /qwen3\.7/i, /qwen3\.6/i, /qwen3/i],
+    },
+    {
+        name: "GPT-OSS",
+        labelPrefix: "GPT-OSS",
+        description: "Top free GPT-OSS model from OpenRouter.",
+        match: /^openai\/gpt-oss/i,
+        prefer: [/120b/i, /20b/i],
+    },
+    {
+        name: "Nemotron",
+        labelPrefix: "Nemotron",
+        description: "Top free NVIDIA Nemotron model from OpenRouter.",
+        match: /^nvidia\/nemotron/i,
+        prefer: [/super/i, /ultra/i, /nano-omni/i, /nano-30b/i],
+    },
+    {
+        name: "Gemma",
+        labelPrefix: "Gemma",
+        description: "Top free Gemma model from OpenRouter.",
+        match: /^google\/gemma/i,
+        prefer: [/31b/i, /26b/i],
+    },
+    {
+        name: "Llama",
+        labelPrefix: "Llama",
+        description: "Top free Llama-family model from OpenRouter.",
+        match: /^(meta-llama\/llama|nousresearch\/hermes-3-llama)/i,
+        prefer: [/3\.3-70b/i, /405b/i, /3\.2-3b/i],
+    },
+];
+export const fetchOpenRouterModels = async (apiKey) => {
+    const headers = {
+        Accept: "application/json",
+    };
+    if (apiKey) {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(OPENROUTER_MODELS_URL, { headers });
+    if (!response.ok) {
+        throw new Error(`Unable to fetch OpenRouter models: HTTP ${response.status} ${response.statusText}`);
+    }
+    const body = (await response.json());
+    return body.data ?? [];
+};
+const formatModelNameToken = (part) => {
+    const normalized = part.toLowerCase();
+    const brandNames = {
+        deepseek: "DeepSeek",
+        gpt: "GPT",
+        glm: "GLM",
+        kimi: "Kimi",
+        llama: "Llama",
+        oss: "OSS",
+        qwen: "Qwen",
+    };
+    if (brandNames[normalized]) {
+        return brandNames[normalized];
+    }
+    if (/^[vk]\d/i.test(part) || /^\d+b$/i.test(part) || /^a\d+b$/i.test(part)) {
+        return part.toUpperCase();
+    }
+    return part.charAt(0).toUpperCase() + part.slice(1);
+};
+const titleCaseModelPart = (value) => value
+    .split(/[-_]/)
+    .filter(Boolean)
+    .map(formatModelNameToken)
+    .join(" ");
+const formatDynamicLabel = (family, id) => {
+    const modelName = (id.split("/").at(-1) || id).replace(/:free$/i, "");
+    return `${family.labelPrefix}: ${titleCaseModelPart(modelName)}`;
+};
+const getVersionScore = (id) => {
+    const versionNumbers = [...id.matchAll(/\d+(?:\.\d+)?/g)]
+        .map((match) => Number(match[0]))
+        .filter((value) => Number.isFinite(value));
+    if (versionNumbers.length === 0) {
+        return 0;
+    }
+    return Math.max(...versionNumbers);
+};
+const scoreFamilyModel = (family, id) => {
+    let score = getVersionScore(id);
+    family.prefer.forEach((pattern, index) => {
+        if (pattern.test(id)) {
+            score += (family.prefer.length - index) * 1000;
+        }
+    });
+    if (/preview|beta|experimental/i.test(id)) {
+        score -= 10;
+    }
+    return score;
+};
+const pickFamilyModel = (family, ids) => {
+    const candidates = ids.filter((id) => family.match.test(id));
+    if (candidates.length === 0) {
+        return null;
+    }
+    const [best] = candidates.sort((left, right) => {
+        const scoreDelta = scoreFamilyModel(family, right) - scoreFamilyModel(family, left);
+        return scoreDelta || right.localeCompare(left, undefined, { numeric: true });
+    });
+    if (!best) {
+        return null;
+    }
+    return {
+        id: best,
+        label: formatDynamicLabel(family, best),
+        description: family.description,
+    };
+};
+const isFreeOpenRouterModel = (model) => {
+    if (model.id?.endsWith(":free")) {
+        return true;
+    }
+    const prompt = Number(model.pricing?.prompt ?? Number.NaN);
+    const completion = Number(model.pricing?.completion ?? Number.NaN);
+    return prompt === 0 && completion === 0;
+};
+const scoreOpenRouterFamilyModel = (family, model) => {
+    const id = model.id || "";
+    const idWithoutDates = id.replace(/\b20\d{6}\b/g, "");
+    let score = getVersionScore(idWithoutDates);
+    family.prefer.forEach((pattern, index) => {
+        if (pattern.test(id)) {
+            score += (family.prefer.length - index) * 1000;
+        }
+    });
+    if (isFreeOpenRouterModel(model)) {
+        score += 500;
+    }
+    if (/preview|beta|experimental/i.test(id)) {
+        score -= 10;
+    }
+    if (id.startsWith("~")) {
+        score -= 100;
+    }
+    return score;
+};
+const pickOpenRouterFamilyModel = (family, models) => {
+    const candidates = models.filter((model) => {
+        const id = model.id || "";
+        return family.match.test(id);
+    });
+    if (candidates.length === 0) {
+        return null;
+    }
+    const [best] = candidates.sort((left, right) => {
+        const scoreDelta = scoreOpenRouterFamilyModel(family, right) -
+            scoreOpenRouterFamilyModel(family, left);
+        return (scoreDelta ||
+            (right.id || "").localeCompare(left.id || "", undefined, {
+                numeric: true,
+            }));
+    });
+    if (!best?.id) {
+        return null;
+    }
+    const freeLabel = isFreeOpenRouterModel(best) ? " (Free)" : "";
+    return {
+        id: best.id,
+        label: `${formatDynamicLabel(family, best.id)}${freeLabel}`,
+        description: family.description,
+    };
+};
+export const getRecommendedNvidiaModels = (available) => {
+    const ids = [...available];
+    const picked = NVIDIA_MODEL_FAMILIES
+        .map((family) => pickFamilyModel(family, ids))
+        .filter((model) => Boolean(model));
+    const seen = new Set(picked.map((model) => model.id));
+    const fallback = NVIDIA_CURATED_MODELS.filter((model) => available.has(model.id) && !seen.has(model.id));
+    return [...picked, ...fallback];
+};
+export const getRecommendedOpenRouterModels = (models) => {
+    const freeModels = models.filter(isFreeOpenRouterModel);
+    const picked = OPENROUTER_MODEL_FAMILIES
+        .map((family) => pickOpenRouterFamilyModel(family, freeModels))
+        .filter((model) => Boolean(model));
+    const seen = new Set(picked.map((model) => model.id));
+    const fallback = OPENROUTER_CURATED_MODELS.filter((model) => !seen.has(model.id));
+    return [...picked, ...fallback];
+};
 export const getRecommendedModels = async (provider, apiKey) => {
     if (provider === "openrouter") {
-        return OPENROUTER_CURATED_MODELS;
+        try {
+            const available = await fetchOpenRouterModels(apiKey);
+            const dynamic = getRecommendedOpenRouterModels(available);
+            return dynamic.length > 0 ? dynamic : OPENROUTER_CURATED_MODELS;
+        }
+        catch {
+            return OPENROUTER_CURATED_MODELS;
+        }
     }
     try {
         const available = await fetchAvailableModelIds(apiKey);
-        const curated = NVIDIA_CURATED_MODELS.filter((model) => available.has(model.id));
-        return curated.length > 0 ? curated : NVIDIA_CURATED_MODELS;
+        const dynamic = getRecommendedNvidiaModels(available);
+        return dynamic.length > 0 ? dynamic : NVIDIA_CURATED_MODELS;
     }
     catch {
         return NVIDIA_CURATED_MODELS;

package/dist/proxy.js

@@ -6,12 +6,33 @@ const NVIDIA_URL = "https://integrate.api.nvidia.com/v1/chat/completions";
 const OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions";
 const DEFAULT_RETRY_DELAY_MS = 2_000;
 const MAX_NVIDIA_RETRIES = 3;
+const UPSTREAM_TIMEOUT_MS = 60_000;
+const PROXY_PROTOCOL_VERSION = 2;
 const sleep = async (ms) => {
     if (ms <= 0) {
         return;
     }
     await new Promise((resolve) => setTimeout(resolve, ms));
 };
+const fetchWithTimeout = async (input, init) => {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), UPSTREAM_TIMEOUT_MS);
+    try {
+        return await fetch(input, {
+            ...init,
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            throw new Error(`Upstream API timed out after ${UPSTREAM_TIMEOUT_MS / 1000}s`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+};
 const parseRetryAfterMs = (value) => {
     if (!value) {
         return null;
@@ -415,14 +436,14 @@ const callNvidia = async (config, scheduleRequest, payload) => {
     if (toolChoice) {
         requestBody.tool_choice = toolChoice;
     }
-    if (config.thinking) {
+    if (config.provider === "nvidia") {
         requestBody.chat_template_kwargs = {
-            thinking: true,
+            thinking: config.thinking,
         };
     }
     const invoke = async () => {
         for (let attempt = 0; attempt <= MAX_NVIDIA_RETRIES; attempt += 1) {
-            const response = await fetch(NVIDIA_URL, {
+            const response = await fetchWithTimeout(NVIDIA_URL, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${config.nvidiaApiKey}`,
@@ -654,7 +675,7 @@ const callChatCompletions = async (config, scheduleRequest, body) => {
     const apiKey = getActiveApiKey(config);
     const invoke = async () => {
         for (let attempt = 0; attempt <= MAX_NVIDIA_RETRIES; attempt += 1) {
-            const resp = await fetch(upstreamUrl, {
+            const resp = await fetchWithTimeout(upstreamUrl, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${apiKey}`,
@@ -691,7 +712,9 @@ export const createProxyServer = (config) => {
             if (url.pathname === "/health") {
                 sendJson(response, 200, {
                     ok: true,
-                    model: config.nvidiaModel,
+                    proxyProtocolVersion: PROXY_PROTOCOL_VERSION,
+                    provider: config.provider,
+                    model: getActiveModel(config),
                     port: config.proxyPort,
                     thinking: config.thinking,
                     maxRequestsPerMinute: config.maxRequestsPerMinute,
@@ -715,6 +738,21 @@ export const createProxyServer = (config) => {
                 });
                 return;
             }
+            if (request.method === "GET" && url.pathname === "/v1/models") {
+                sendJson(response, 200, {
+                    object: "list",
+                    data: [
+                        {
+                            id: getActiveModel(config),
+                            object: "model",
+                            created: 0,
+                            owned_by: config.provider,
+                        },
+                    ],
+                    models: [],
+                });
+                return;
+            }
             if (request.method === "POST" && url.pathname === "/v1/messages") {
                 const rawBody = await readRequestBody(request);
                 const payload = JSON.parse(rawBody);
@@ -872,6 +910,11 @@ export const createProxyServer = (config) => {
                     max_tokens: payload.max_output_tokens ?? 16_384,
                     stream: false,
                 };
+                if (config.provider === "nvidia") {
+                    chatBody.chat_template_kwargs = {
+                        thinking: config.thinking,
+                    };
+                }
                 if (typeof payload.temperature === "number") {
                     chatBody.temperature = payload.temperature;
                 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nvicode",
-  "version": "0.1.19",
-  "description": "Route Claude Code, Codex CLI, and OpenClaw through NVIDIA or OpenRouter with one setup.",
+  "version": "0.1.21",
+  "description": "Route Claude Code, Codex CLI, Codex desktop app, and OpenClaw through NVIDIA or OpenRouter with one setup.",
   "author": "Dinesh Potla",
   "keywords": [
     "claude-code",