nvicode 0.1.9 → 0.1.11

package/README.md

@@ -1,100 +1,30 @@
-# NviCode - Introducing one click Nvidia/OpenRouter keys to Claude Code. Free Claude code.
+# NviCode
 
-Run Claude Code through NVIDIA-hosted models or OpenRouter using a simple CLI wrapper.
-Use top open-source model APIs on NVIDIA Build for free, with `nvicode` paced to `40 RPM` by default.
+Connect Claude Code to NVIDIA or OpenRouter.
 
-Supported environments:
-- macOS
-- Ubuntu/Linux
-- WSL
-- Native Windows with Claude Code installed and working from PowerShell, CMD, or Git Bash
-
-## Quickstart
-
-Install the published package:
+## Install
 
 ```sh
 npm install -g nvicode
 ```
 
-On interactive global installs, `nvicode` opens guided setup automatically.
-If you skip it, run:
+## Setup
 
 ```sh
 nvicode select model
 ```
 
-The setup flow asks for provider, API key, and model:
-
-- NVIDIA: get a free key from [NVIDIA Build API Keys](https://build.nvidia.com/settings/api-keys)
-- OpenRouter: use your OpenRouter API key
+NVIDIA keys: [https://build.nvidia.com/settings/api-keys](https://build.nvidia.com/settings/api-keys)
 
-Launch Claude Code through your selected provider:
+## Launch
 
 ```sh
 nvicode launch claude
 ```
 
-## Screenshots
-
-### Save your API key
-
-![nvicode auth](https://raw.githubusercontent.com/dineshpotla/nvicode/main/assets/screenshots/auth.png)
-
-### Choose a model
-
-![nvicode select model](https://raw.githubusercontent.com/dineshpotla/nvicode/main/assets/screenshots/select-model.png)
-
-### Launch Claude Code through your selected provider
-
-![nvicode launch claude](https://raw.githubusercontent.com/dineshpotla/nvicode/main/assets/screenshots/launch.png)
-
-## Commands
-
-Useful commands:
-
-```sh
-nvicode dashboard
-nvicode usage
-nvicode activity
-nvicode models
-nvicode config
-nvicode auth
-nvicode launch claude -p "Reply with exactly OK"
-```
-
-Provider behavior:
-- NVIDIA: starts a local proxy on `127.0.0.1:8788`, points Claude Code at it with `ANTHROPIC_BASE_URL`, and forwards requests to NVIDIA `chat/completions`.
-- OpenRouter: points Claude Code directly at `https://openrouter.ai/api` using OpenRouter credentials and Anthropic-compatible model ids.
-
-In an interactive terminal, `nvicode usage` refreshes live every 2 seconds. When piped or redirected, it prints a single snapshot.
-
-`nvicode select model` now asks for provider, optional API key update, and model choice in one guided flow.
-If no API key is saved for the active provider yet, `nvicode` prompts for one on first use.
-By default, the proxy paces upstream NVIDIA requests at `40 RPM`. Override that with `NVICODE_MAX_RPM` if your account has a different limit.
-The usage dashboard compares your local NVIDIA run cost against Claude Opus 4.6 at `$5 / MTok input` and `$25 / MTok output`, based on Anthropic pricing as of `2026-03-30`.
-If your NVIDIA endpoint is not free, override local cost estimates with `NVICODE_INPUT_USD_PER_MTOK` and `NVICODE_OUTPUT_USD_PER_MTOK`.
-Local `usage`, `activity`, and `dashboard` commands are available for NVIDIA proxy sessions. OpenRouter sessions use OpenRouter's direct connection path instead.
+After the first successful launch, plain `claude` continues to use the selected `nvicode` provider and model.
 
 ## Requirements
 
-- Claude Code must already be installed on the machine.
-- Node.js 20 or newer is required to install `nvicode`.
-- On native Windows, Claude Code itself requires Git for Windows. See the [Claude Code setup docs](https://code.claude.com/docs/en/setup).
-
-## Local Development
-
-These steps are only for contributors working from a git checkout. End users do not need them.
-
-```sh
-npm install
-npm run build
-npm link
-```
-
-## Notes
-
-- `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 remains the frontend; the selected provider/model becomes the backend.
+- Claude Code must already be installed
+- Node.js 20 or newer

package/dist/cli.js

@@ -12,6 +12,7 @@ import { createProxyServer } from "./proxy.js";
 import { getRecommendedModels } 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 usage = () => {
     console.log(`nvicode
 
@@ -41,6 +42,47 @@ const getPathExts = () => {
 };
 const unique = (values) => [...new Set(values)];
 const getProviderLabel = (provider) => provider === "openrouter" ? "OpenRouter" : "NVIDIA";
+const getClaudeCommandNames = () => isWindows ? ["claude.exe", "claude.cmd", "claude.bat", "claude"] : ["claude"];
+const getClaudeNativeNames = () => isWindows
+    ? ["claude-native.exe", "claude-native.cmd", "claude-native.bat", "claude-native"]
+    : ["claude-native"];
+const pathExists = async (targetPath) => {
+    try {
+        await fs.access(targetPath, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const readIfExists = async (targetPath) => {
+    try {
+        return await fs.readFile(targetPath, "utf8");
+    }
+    catch {
+        return null;
+    }
+};
+const isManagedClaudeWrapper = async (targetPath) => {
+    const contents = await readIfExists(targetPath);
+    return contents?.includes(NVICODE_WRAPPER_MARKER) ?? false;
+};
+const renderClaudeWrapper = () => {
+    if (isWindows) {
+        return [
+            "@echo off",
+            `REM ${NVICODE_WRAPPER_MARKER}`,
+            `"${process.execPath}" "${__filename}" launch claude %*`,
+            "",
+        ].join("\r\n");
+    }
+    return [
+        "#!/bin/sh",
+        `# ${NVICODE_WRAPPER_MARKER}`,
+        `exec "${process.execPath}" "${__filename}" launch claude "$@"`,
+        "",
+    ].join("\n");
+};
 const question = async (prompt) => {
     const rl = createInterface({
         input: process.stdin,
@@ -424,11 +466,81 @@ const resolveClaudeVersionEntry = async (entryPath) => {
     }
     return null;
 };
+const findExistingClaudeNativeInDirectory = async (directory) => {
+    for (const name of getClaudeNativeNames()) {
+        const candidate = path.join(directory, name);
+        if (await isExecutable(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+};
+const resolvePersistentClaudeCommand = async () => {
+    for (const name of getClaudeCommandNames()) {
+        const found = await findExecutableInPath(name);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+};
+const getWrapperInstallPaths = async (claudeCommandPath) => {
+    const directory = path.dirname(claudeCommandPath);
+    const existingNative = await findExistingClaudeNativeInDirectory(directory);
+    if (existingNative) {
+        return {
+            wrapperPath: claudeCommandPath,
+            nativePath: existingNative,
+        };
+    }
+    if (isWindows && path.extname(claudeCommandPath).toLowerCase() === ".exe") {
+        return {
+            wrapperPath: path.join(directory, "claude.cmd"),
+            nativePath: path.join(directory, "claude-native.exe"),
+        };
+    }
+    const extension = path.extname(claudeCommandPath);
+    return {
+        wrapperPath: claudeCommandPath,
+        nativePath: path.join(directory, `claude-native${extension}`),
+    };
+};
+const writeExecutableTextFile = async (targetPath, contents) => {
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, contents, "utf8");
+    if (!isWindows) {
+        await fs.chmod(targetPath, 0o755);
+    }
+};
+const ensurePersistentClaudeRouting = async () => {
+    const claudeCommandPath = await resolvePersistentClaudeCommand();
+    if (!claudeCommandPath) {
+        return "skipped";
+    }
+    const wrapperContents = renderClaudeWrapper();
+    const { wrapperPath, nativePath } = await getWrapperInstallPaths(claudeCommandPath);
+    if (await isManagedClaudeWrapper(wrapperPath)) {
+        const currentWrapper = await readIfExists(wrapperPath);
+        if (currentWrapper === wrapperContents) {
+            return "already";
+        }
+        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 });
+    }
+    await writeExecutableTextFile(wrapperPath, wrapperContents);
+    return "installed";
+};
 const resolveClaudeBinary = async () => {
-    const nativeNames = isWindows
-        ? ["claude-native.exe", "claude-native.cmd", "claude-native.bat", "claude-native"]
-        : ["claude-native"];
-    for (const name of nativeNames) {
+    for (const name of getClaudeNativeNames()) {
         const nativeInPath = await findExecutableInPath(name);
         if (nativeInPath) {
             return nativeInPath;
@@ -467,12 +579,9 @@ const resolveClaudeBinary = async () => {
     catch {
         // continue
     }
-    const cliNames = isWindows
-        ? ["claude.exe", "claude.cmd", "claude.bat", "claude"]
-        : ["claude"];
-    for (const name of cliNames) {
+    for (const name of getClaudeCommandNames()) {
         const claudeInPath = await findExecutableInPath(name);
-        if (claudeInPath) {
+        if (claudeInPath && !(await isManagedClaudeWrapper(claudeInPath))) {
             return claudeInPath;
         }
     }
@@ -509,6 +618,7 @@ const spawnClaudeProcess = (claudeBinary, args, env) => {
 };
 const runLaunchClaude = async (args) => {
     const config = await ensureConfigured();
+    const routingStatus = await ensurePersistentClaudeRouting().catch(() => "skipped");
     const claudeBinary = await resolveClaudeBinary();
     const activeModel = getActiveModel(config);
     const activeApiKey = getActiveApiKey(config);
@@ -541,6 +651,10 @@ const runLaunchClaude = async (args) => {
     if (config.provider === "nvidia") {
         await ensureProxyRunning(config);
     }
+    if (process.stdout.isTTY &&
+        (routingStatus === "installed" || routingStatus === "updated")) {
+        console.error("nvicode installed persistent `claude` routing. Future plain `claude` launches will use the selected nvicode provider and model.");
+    }
     const child = spawnClaudeProcess(claudeBinary, args, env);
     await new Promise((resolve, reject) => {
         child.on("exit", (code, signal) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvicode",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "NviCode - Introducing one click Nvidia/OpenRouter keys to Claude Code. Free Claude code.",
   "author": "Dinesh Potla",
   "keywords": [
@@ -17,7 +17,7 @@
     "nvicode": "dist/cli.js"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true,maxRetries:10,retryDelay:100})\" && tsc -p tsconfig.json",
     "prepack": "npm run build",
     "postinstall": "node dist/postinstall.js",
     "typecheck": "tsc --noEmit",