nvicode 0.1.2 → 0.1.6

package/dist/cli.js

@@ -7,22 +7,40 @@ import path from "node:path";
 import process from "node:process";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { getNvicodePaths, loadConfig, saveConfig, } from "./config.js";
+import { getActiveApiKey, getActiveModel, getNvicodePaths, loadConfig, saveConfig, } from "./config.js";
 import { createProxyServer } from "./proxy.js";
-import { CURATED_MODELS, getRecommendedModels } from "./models.js";
+import { getRecommendedModels } from "./models.js";
+import { filterRecordsSince, formatDuration, formatInteger, formatTimestamp, formatUsd, readUsageRecords, summarizeUsage, } from "./usage.js";
 const __filename = fileURLToPath(import.meta.url);
 const usage = () => {
     console.log(`nvicode
 
 Commands:
-  nvicode select model        Select and save a NVIDIA model
-  nvicode models              Show recommended coding models
-  nvicode auth                Save or update NVIDIA API key
+  nvicode select model        Guided provider, key, and model selection
+  nvicode models              Show recommended models for the active provider
+  nvicode auth                Save or update the API key for the active provider
   nvicode config              Show current nvicode config
+  nvicode usage               Show token usage and cost comparison
+  nvicode activity            Show recent request activity
+  nvicode dashboard           Show usage summary and recent activity
   nvicode launch claude [...] Launch Claude Code through nvicode
   nvicode serve               Run the local proxy in the foreground
 `);
 };
+const isWindows = process.platform === "win32";
+const getPathExts = () => {
+    if (!isWindows) {
+        return [""];
+    }
+    const raw = process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD";
+    return raw
+        .split(";")
+        .map((ext) => ext.trim())
+        .filter(Boolean)
+        .map((ext) => ext.toLowerCase());
+};
+const unique = (values) => [...new Set(values)];
+const getProviderLabel = (provider) => provider === "openrouter" ? "OpenRouter" : "NVIDIA";
 const question = async (prompt) => {
     const rl = createInterface({
         input: process.stdin,
@@ -35,28 +53,85 @@ const question = async (prompt) => {
         rl.close();
     }
 };
+const promptProviderSelection = async (initialProvider) => {
+    console.log("Choose a provider:");
+    console.log("1. NVIDIA");
+    console.log("   Uses the local nvicode proxy and usage dashboard.");
+    console.log("2. OpenRouter");
+    console.log("   Uses Claude Code direct Anthropic-compatible connection.");
+    const defaultChoice = initialProvider === "openrouter" ? "2" : "1";
+    const answer = (await question(`Provider selection [${defaultChoice}]: `)).toLowerCase();
+    const normalized = answer || defaultChoice;
+    if (normalized === "1" || normalized === "nvidia") {
+        return "nvidia";
+    }
+    if (normalized === "2" ||
+        normalized === "openrouter" ||
+        normalized === "open-router") {
+        return "openrouter";
+    }
+    throw new Error("Provider selection is required.");
+};
+const promptApiKeyUpdate = async (config, provider) => {
+    const providerLabel = getProviderLabel(provider);
+    const currentApiKey = provider === "openrouter" ? config.openrouterApiKey : config.nvidiaApiKey;
+    if (currentApiKey) {
+        const answer = (await question(`${providerLabel} API key already saved. Update it? [y/N]: `)).toLowerCase();
+        if (answer !== "y" && answer !== "yes") {
+            return provider === "openrouter"
+                ? { openrouterApiKey: currentApiKey, nvidiaApiKey: config.nvidiaApiKey }
+                : { nvidiaApiKey: currentApiKey, openrouterApiKey: config.openrouterApiKey };
+        }
+        const nextKey = await question(`${providerLabel} API key (press Enter or type "skip" to keep current): `);
+        if (!nextKey || nextKey.toLowerCase() === "skip") {
+            return provider === "openrouter"
+                ? { openrouterApiKey: currentApiKey, nvidiaApiKey: config.nvidiaApiKey }
+                : { nvidiaApiKey: currentApiKey, openrouterApiKey: config.openrouterApiKey };
+        }
+        return provider === "openrouter"
+            ? { openrouterApiKey: nextKey, nvidiaApiKey: config.nvidiaApiKey }
+            : { nvidiaApiKey: nextKey, openrouterApiKey: config.openrouterApiKey };
+    }
+    const nextKey = await question(`${providerLabel} API key (press Enter or type "skip" to skip): `);
+    if (!nextKey || nextKey.toLowerCase() === "skip") {
+        return {
+            nvidiaApiKey: config.nvidiaApiKey,
+            openrouterApiKey: config.openrouterApiKey,
+        };
+    }
+    return provider === "openrouter"
+        ? { openrouterApiKey: nextKey, nvidiaApiKey: config.nvidiaApiKey }
+        : { nvidiaApiKey: nextKey, openrouterApiKey: config.openrouterApiKey };
+};
 const ensureConfigured = async () => {
     let config = await loadConfig();
     let changed = false;
-    if (!config.apiKey) {
+    const providerLabel = getProviderLabel(config.provider);
+    const activeApiKey = getActiveApiKey(config);
+    const activeModel = getActiveModel(config);
+    if (!activeApiKey) {
         if (!process.stdin.isTTY) {
-            throw new Error("Missing NVIDIA API key. Run `nvicode auth` first.");
+            throw new Error(`Missing ${providerLabel} API key. Run \`nvicode auth\` first.`);
         }
-        const apiKey = await question("NVIDIA API key: ");
+        const apiKey = await question(`${providerLabel} API key: `);
         if (!apiKey) {
-            throw new Error("NVIDIA API key is required.");
+            throw new Error(`${providerLabel} API key is required.`);
         }
         config = {
             ...config,
-            apiKey,
+            ...(config.provider === "openrouter"
+                ? { openrouterApiKey: apiKey }
+                : { nvidiaApiKey: apiKey }),
         };
         changed = true;
     }
-    if (!config.model) {
-        const [first] = await getRecommendedModels(config.apiKey);
+    if (!activeModel) {
+        const [first] = await getRecommendedModels(config.provider, getActiveApiKey(config));
         config = {
             ...config,
-            model: first?.id || CURATED_MODELS[0].id,
+            ...(config.provider === "openrouter"
+                ? { openrouterModel: first?.id || "anthropic/claude-sonnet-4.6" }
+                : { nvidiaModel: first?.id || "moonshotai/kimi-k2.5" }),
         };
         changed = true;
     }
@@ -67,22 +142,28 @@ const ensureConfigured = async () => {
 };
 const runAuth = async () => {
     const config = await loadConfig();
-    const apiKey = await question(config.apiKey ? "NVIDIA API key (leave blank to keep current): " : "NVIDIA API key: ");
-    if (!apiKey && config.apiKey) {
-        console.log("Kept existing NVIDIA API key.");
+    const providerLabel = getProviderLabel(config.provider);
+    const currentApiKey = getActiveApiKey(config);
+    const apiKey = await question(currentApiKey
+        ? `${providerLabel} API key (leave blank to keep current): `
+        : `${providerLabel} API key: `);
+    if (!apiKey && currentApiKey) {
+        console.log(`Kept existing ${providerLabel} API key.`);
         return;
     }
     if (!apiKey) {
-        throw new Error("NVIDIA API key is required.");
+        throw new Error(`${providerLabel} API key is required.`);
     }
     await saveConfig({
         ...config,
-        apiKey,
+        ...(config.provider === "openrouter"
+            ? { openrouterApiKey: apiKey }
+            : { nvidiaApiKey: apiKey }),
     });
-    console.log("Saved NVIDIA API key.");
+    console.log(`Saved ${providerLabel} API key.`);
 };
-const printModels = async (apiKey) => {
-    const models = apiKey ? await getRecommendedModels(apiKey) : CURATED_MODELS;
+const printModels = async (provider, apiKey) => {
+    const models = await getRecommendedModels(provider, apiKey || "");
     models.forEach((model, index) => {
         console.log(`${index + 1}. ${model.label}`);
         console.log(`   ${model.id}`);
@@ -90,11 +171,20 @@ const printModels = async (apiKey) => {
     });
 };
 const runSelectModel = async () => {
-    const config = await ensureConfigured();
-    const models = await getRecommendedModels(config.apiKey);
-    console.log("Recommended NVIDIA coding models:");
-    await printModels(config.apiKey);
-    console.log("Type a number from the list or enter a custom model id.");
+    const config = await loadConfig();
+    const provider = await promptProviderSelection(config.provider);
+    const providerLabel = getProviderLabel(provider);
+    const keyPatch = await promptApiKeyUpdate(config, provider);
+    const nextConfig = await saveConfig({
+        ...config,
+        ...keyPatch,
+        provider,
+    });
+    const models = await getRecommendedModels(provider, getActiveApiKey(nextConfig));
+    console.log(`Top popular ${providerLabel} models:`);
+    await printModels(provider, getActiveApiKey(nextConfig));
+    console.log("Or paste a full model id.");
+    console.log("Example: qwen/qwen3.6-plus-preview:free");
     const answer = await question("Model selection: ");
     const index = Number(answer);
     const chosenModel = Number.isInteger(index) && index >= 1 && index <= models.length
@@ -104,8 +194,10 @@ const runSelectModel = async () => {
         throw new Error("Model selection is required.");
     }
     await saveConfig({
-        ...config,
-        model: chosenModel,
+        ...nextConfig,
+        ...(provider === "openrouter"
+            ? { openrouterModel: chosenModel }
+            : { nvidiaModel: chosenModel }),
     });
     console.log(`Saved model: ${chosenModel}`);
 };
@@ -114,10 +206,153 @@ const runConfig = async () => {
     const paths = getNvicodePaths();
     console.log(`Config file: ${paths.configFile}`);
     console.log(`State dir:   ${paths.stateDir}`);
-    console.log(`Model:       ${config.model}`);
+    console.log(`Usage log:   ${paths.usageLogFile}`);
+    console.log(`Provider:    ${getProviderLabel(config.provider)}`);
+    console.log(`Model:       ${getActiveModel(config)}`);
     console.log(`Proxy port:  ${config.proxyPort}`);
+    console.log(`Max RPM:     ${config.maxRequestsPerMinute}`);
     console.log(`Thinking:    ${config.thinking ? "on" : "off"}`);
-    console.log(`API key:     ${config.apiKey ? "saved" : "missing"}`);
+    console.log(`NVIDIA key:  ${config.nvidiaApiKey ? "saved" : "missing"}`);
+    console.log(`OpenRouter key: ${config.openrouterApiKey ? "saved" : "missing"}`);
+};
+const printUsageBlock = (label, records) => {
+    const summary = summarizeUsage(records);
+    console.log(label);
+    console.log(`Requests: ${formatInteger(summary.requests)} (${formatInteger(summary.successes)} ok, ${formatInteger(summary.errors)} error)`);
+    console.log(`Turn input tokens: ${formatInteger(summary.turnInputTokens)}`);
+    console.log(`Billed input tokens: ${formatInteger(summary.inputTokens)}`);
+    console.log(`Turn output tokens: ${formatInteger(summary.turnOutputTokens)}`);
+    console.log(`Billed output tokens: ${formatInteger(summary.outputTokens)}`);
+    console.log(`NVIDIA cost: ${formatUsd(summary.providerCostUsd)}`);
+    console.log(`Estimated savings: ${formatUsd(summary.savingsUsd)}`);
+};
+const getUsageView = async () => {
+    const records = await readUsageRecords();
+    if (records.length === 0) {
+        return [
+            "nvicode usage",
+            "",
+            "No usage recorded yet.",
+            "Keep this open and new activity will appear automatically.",
+        ].join("\n");
+    }
+    const now = Date.now();
+    const latestPricing = records[0]?.pricing;
+    const lines = ["nvicode usage", ""];
+    if (latestPricing) {
+        lines.push("Pricing basis:");
+        lines.push(`- NVIDIA configured cost: ${formatUsd(latestPricing.providerInputUsdPerMTok)} / MTok input, ${formatUsd(latestPricing.providerOutputUsdPerMTok)} / MTok output`);
+        lines.push(`- ${latestPricing.compareModel}: ${formatUsd(latestPricing.compareInputUsdPerMTok)} / MTok input, ${formatUsd(latestPricing.compareOutputUsdPerMTok)} / MTok output`);
+        lines.push(`- Comparison source: ${latestPricing.comparePricingSource} (${latestPricing.comparePricingUpdatedAt})`);
+        lines.push("- In/Out columns show current-turn tokens.");
+        lines.push("- Billed In/Billed Out include the full Claude Code request context.");
+        lines.push("");
+    }
+    const windows = [
+        { label: "Last 1 hour", durationMs: 1 * 60 * 60 * 1000 },
+        { label: "Last 6 hours", durationMs: 6 * 60 * 60 * 1000 },
+        { label: "Last 12 hours", durationMs: 12 * 60 * 60 * 1000 },
+        { label: "Last 1 day", durationMs: 24 * 60 * 60 * 1000 },
+        { label: "Last 1 week", durationMs: 7 * 24 * 60 * 60 * 1000 },
+        { label: "Last 1 month", durationMs: 30 * 24 * 60 * 60 * 1000 },
+    ];
+    const rows = windows.map((window) => {
+        const summary = summarizeUsage(filterRecordsSince(records, now - window.durationMs));
+        return {
+            window: window.label,
+            requests: `${formatInteger(summary.requests)} (${formatInteger(summary.successes)} ok/${formatInteger(summary.errors)} err)`,
+            inputTokens: formatInteger(summary.turnInputTokens),
+            billedInputTokens: formatInteger(summary.inputTokens),
+            outputTokens: formatInteger(summary.turnOutputTokens),
+            billedOutputTokens: formatInteger(summary.outputTokens),
+            nvidiaCost: formatUsd(summary.providerCostUsd),
+            savings: formatUsd(summary.savingsUsd),
+        };
+    });
+    lines.push(`Snapshot: ${formatTimestamp(new Date(now).toISOString())}`);
+    lines.push("");
+    lines.push("Window        Requests         In Tok   Billed In  Out Tok  Billed Out  NVIDIA      Saved");
+    rows.forEach((row) => {
+        lines.push(`${row.window.padEnd(13)} ${row.requests.padEnd(16)} ${row.inputTokens.padStart(8)} ${row.billedInputTokens.padStart(11)} ${row.outputTokens.padStart(8)} ${row.billedOutputTokens.padStart(11)} ${row.nvidiaCost.padStart(10)} ${row.savings.padStart(10)}`);
+    });
+    return lines.join("\n");
+};
+const sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const clearTerminal = () => {
+    process.stdout.write("\x1b[2J\x1b[H");
+};
+const runUsage = async () => {
+    const config = await loadConfig();
+    if (config.provider === "openrouter") {
+        console.log("OpenRouter uses a direct Claude Code connection.");
+        console.log("Local nvicode usage stats are only available for NVIDIA proxy sessions.");
+        console.log("Use the OpenRouter activity dashboard for OpenRouter usage.");
+        return;
+    }
+    const interactive = process.stdout.isTTY && process.stdin.isTTY;
+    if (!interactive) {
+        console.log(await getUsageView());
+        return;
+    }
+    let stopped = false;
+    const stop = () => {
+        stopped = true;
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    try {
+        while (!stopped) {
+            clearTerminal();
+            process.stdout.write(await getUsageView());
+            process.stdout.write("\n\nRefreshing every 2s. Press Ctrl+C to exit.\n");
+            await sleep(2_000);
+        }
+    }
+    finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+    }
+};
+const runActivity = async () => {
+    const config = await loadConfig();
+    if (config.provider === "openrouter") {
+        console.log("OpenRouter uses a direct Claude Code connection.");
+        console.log("Local nvicode activity logs are only available for NVIDIA proxy sessions.");
+        return;
+    }
+    const records = await readUsageRecords();
+    if (records.length === 0) {
+        console.log("No activity recorded yet.");
+        return;
+    }
+    console.log("Timestamp             Status  Model                         In Tok  Bill In  Out Tok Bill Out  Latency  NVIDIA     Saved");
+    for (const record of records.slice(0, 15)) {
+        const model = record.model.length > 28 ? `${record.model.slice(0, 25)}...` : record.model;
+        const status = record.status === "success" ? "ok" : "error";
+        console.log(`${formatTimestamp(record.timestamp).padEnd(21)} ${status.padEnd(6)} ${model.padEnd(29)} ${formatInteger(record.turnInputTokens ?? record.visibleInputTokens ?? record.inputTokens).padStart(7)} ${formatInteger(record.inputTokens).padStart(8)} ${formatInteger(record.turnOutputTokens ?? record.visibleOutputTokens ?? record.outputTokens).padStart(8)} ${formatInteger(record.outputTokens).padStart(8)} ${formatDuration(record.latencyMs).padStart(8)} ${formatUsd(record.providerCostUsd).padStart(10)} ${formatUsd(record.savingsUsd).padStart(10)}`);
+        if (record.error) {
+            console.log(`  error: ${record.error}`);
+        }
+    }
+};
+const runDashboard = async () => {
+    const config = await loadConfig();
+    if (config.provider === "openrouter") {
+        console.log("OpenRouter uses a direct Claude Code connection.");
+        console.log("Local nvicode dashboards are only available for NVIDIA proxy sessions.");
+        return;
+    }
+    const records = await readUsageRecords();
+    if (records.length === 0) {
+        console.log("No usage recorded yet.");
+        return;
+    }
+    const last7Days = filterRecordsSince(records, Date.now() - 7 * 24 * 60 * 60 * 1000);
+    printUsageBlock("Usage (7d)", last7Days);
+    console.log("");
+    console.log("Recent activity");
+    console.log("");
+    await runActivity();
 };
 const waitForHealthyProxy = async (port) => {
     for (let attempt = 0; attempt < 50; attempt += 1) {
@@ -147,6 +382,7 @@ const ensureProxyRunning = async (config) => {
             ...process.env,
         },
         stdio: ["ignore", logFd, logFd],
+        windowsHide: true,
     });
     child.unref();
     await fs.writeFile(paths.pidFile, `${child.pid}\n`);
@@ -156,17 +392,63 @@ const ensureProxyRunning = async (config) => {
 };
 const isExecutable = async (filePath) => {
     try {
-        await fs.access(filePath, constants.X_OK);
+        await fs.access(filePath, isWindows ? constants.F_OK : constants.X_OK);
         return true;
     }
     catch {
         return false;
     }
 };
+const buildExecutableCandidates = (entry, name) => {
+    const base = path.join(entry, name);
+    if (!isWindows) {
+        return [base];
+    }
+    if (path.extname(name)) {
+        return [base];
+    }
+    return unique([base, ...getPathExts().map((ext) => `${base}${ext}`)]);
+};
+const resolveClaudeVersionEntry = async (entryPath) => {
+    if (await isExecutable(entryPath)) {
+        return entryPath;
+    }
+    const nestedCandidates = isWindows
+        ? ["claude.exe", "claude.cmd", "claude.bat", "claude"]
+        : ["claude"];
+    for (const candidateName of nestedCandidates) {
+        const candidate = path.join(entryPath, candidateName);
+        if (await isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+};
 const resolveClaudeBinary = async () => {
-    const nativeInPath = await findExecutableInPath("claude-native");
-    if (nativeInPath) {
-        return nativeInPath;
+    const nativeNames = isWindows
+        ? ["claude-native.exe", "claude-native.cmd", "claude-native.bat", "claude-native"]
+        : ["claude-native"];
+    for (const name of nativeNames) {
+        const nativeInPath = await findExecutableInPath(name);
+        if (nativeInPath) {
+            return nativeInPath;
+        }
+    }
+    const homeBinCandidates = isWindows
+        ? [
+            path.join(os.homedir(), ".local", "bin", "claude.exe"),
+            path.join(os.homedir(), ".local", "bin", "claude.cmd"),
+            path.join(os.homedir(), ".local", "bin", "claude.bat"),
+            path.join(os.homedir(), ".local", "bin", "claude"),
+        ]
+        : [
+            path.join(os.homedir(), ".local", "bin", "claude-native"),
+            path.join(os.homedir(), ".local", "bin", "claude"),
+        ];
+    for (const candidate of homeBinCandidates) {
+        if (await isExecutable(candidate)) {
+            return candidate;
+        }
     }
     const versionsDir = path.join(os.homedir(), ".local", "share", "claude", "versions");
     try {
@@ -176,15 +458,23 @@ const resolveClaudeBinary = async () => {
             sensitivity: "base",
         })).at(-1);
         if (latest) {
-            return path.join(versionsDir, latest);
+            const resolved = await resolveClaudeVersionEntry(path.join(versionsDir, latest));
+            if (resolved) {
+                return resolved;
+            }
         }
     }
     catch {
         // continue
     }
-    const claudeInPath = await findExecutableInPath("claude");
-    if (claudeInPath) {
-        return claudeInPath;
+    const cliNames = isWindows
+        ? ["claude.exe", "claude.cmd", "claude.bat", "claude"]
+        : ["claude"];
+    for (const name of cliNames) {
+        const claudeInPath = await findExecutableInPath(name);
+        if (claudeInPath) {
+            return claudeInPath;
+        }
     }
     throw new Error("Unable to locate Claude Code binary.");
 };
@@ -194,31 +484,64 @@ const findExecutableInPath = async (name) => {
         if (!entry) {
             continue;
         }
-        const candidate = path.join(entry, name);
-        if (await isExecutable(candidate)) {
-            return candidate;
+        for (const candidate of buildExecutableCandidates(entry, name)) {
+            if (await isExecutable(candidate)) {
+                return candidate;
+            }
         }
     }
     return null;
 };
+const spawnClaudeProcess = (claudeBinary, args, env) => {
+    if (isWindows && /\.(cmd|bat)$/i.test(claudeBinary)) {
+        return spawn(claudeBinary, args, {
+            stdio: "inherit",
+            env,
+            shell: true,
+            windowsHide: true,
+        });
+    }
+    return spawn(claudeBinary, args, {
+        stdio: "inherit",
+        env,
+        windowsHide: true,
+    });
+};
 const runLaunchClaude = async (args) => {
     const config = await ensureConfigured();
-    await ensureProxyRunning(config);
     const claudeBinary = await resolveClaudeBinary();
-    const child = spawn(claudeBinary, args, {
-        stdio: "inherit",
-        env: {
+    const activeModel = getActiveModel(config);
+    const activeApiKey = getActiveApiKey(config);
+    const env = config.provider === "openrouter"
+        ? {
             ...process.env,
-            ANTHROPIC_BASE_URL: `http://127.0.0.1:${config.proxyPort}`,
-            ANTHROPIC_AUTH_TOKEN: config.proxyToken,
+            ANTHROPIC_BASE_URL: "https://openrouter.ai/api",
+            ANTHROPIC_AUTH_TOKEN: activeApiKey,
             ANTHROPIC_API_KEY: "",
-            ANTHROPIC_MODEL: config.model,
+            ANTHROPIC_MODEL: activeModel,
+            ANTHROPIC_DEFAULT_SONNET_MODEL: activeModel,
+            ANTHROPIC_DEFAULT_OPUS_MODEL: activeModel,
+            ANTHROPIC_DEFAULT_HAIKU_MODEL: activeModel,
+            CLAUDE_CODE_SUBAGENT_MODEL: activeModel,
             CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
-            ANTHROPIC_CUSTOM_MODEL_OPTION: config.model,
-            ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: "nvicode custom model",
-            ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: "Claude Code via local NVIDIA gateway",
-        },
-    });
+        }
+        : (() => {
+            return {
+                ...process.env,
+                ANTHROPIC_BASE_URL: `http://127.0.0.1:${config.proxyPort}`,
+                ANTHROPIC_AUTH_TOKEN: config.proxyToken,
+                ANTHROPIC_API_KEY: "",
+                ANTHROPIC_MODEL: activeModel,
+                CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS: "1",
+                ANTHROPIC_CUSTOM_MODEL_OPTION: activeModel,
+                ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: "nvicode custom model",
+                ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: "Claude Code via local NVIDIA gateway",
+            };
+        })();
+    if (config.provider === "nvidia") {
+        await ensureProxyRunning(config);
+    }
+    const child = spawnClaudeProcess(claudeBinary, args, env);
     await new Promise((resolve, reject) => {
         child.on("exit", (code, signal) => {
             if (signal) {
@@ -233,12 +556,15 @@ const runLaunchClaude = async (args) => {
 };
 const runServe = async () => {
     const config = await ensureConfigured();
+    if (config.provider !== "nvidia") {
+        throw new Error("`nvicode serve` is only available for the NVIDIA provider.");
+    }
     const server = createProxyServer(config);
     await new Promise((resolve, reject) => {
         server.once("error", reject);
         server.listen(config.proxyPort, "127.0.0.1", () => resolve());
     });
-    console.error(`nvicode proxy listening on http://127.0.0.1:${config.proxyPort} using ${config.model}`);
+    console.error(`nvicode proxy listening on http://127.0.0.1:${config.proxyPort} using ${config.nvidiaModel}`);
     const shutdown = () => {
         server.close(() => process.exit(0));
     };
@@ -258,7 +584,7 @@ const main = async () => {
     }
     if (command === "models") {
         const config = await loadConfig();
-        await printModels(config.apiKey || undefined);
+        await printModels(config.provider, getActiveApiKey(config) || undefined);
         return;
     }
     if (command === "auth") {
@@ -269,6 +595,18 @@ const main = async () => {
         await runConfig();
         return;
     }
+    if (command === "usage") {
+        await runUsage();
+        return;
+    }
+    if (command === "activity") {
+        await runActivity();
+        return;
+    }
+    if (command === "dashboard") {
+        await runDashboard();
+        return;
+    }
     if ((command === "select" && rest[0] === "model") ||
         command === "select-model") {
         await runSelectModel();