nvicode 0.1.7 → 0.1.10

package/README.md

@@ -19,19 +19,30 @@ npm install -g nvicode
 
 Set up provider, 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
-
 ```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
+
 Launch Claude Code through your selected provider:
 
 ```sh
 nvicode launch claude
 ```
 
+The first successful `nvicode launch claude` also installs persistent plain-`claude` routing.
+After that, restarting your terminal or PC and running:
+
+```sh
+claude
+```
+
+will continue using your selected `nvicode` provider and model.
+
 ## Screenshots
 
 ### Save your API key

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/dist/postinstall.js

@@ -0,0 +1,46 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./config.js";
+const isTruthy = (value) => value === "1" || value === "true" || value === "yes";
+const isGlobalInstall = () => process.env.npm_config_global === "true" ||
+    process.env.npm_config_location === "global";
+const isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const main = async () => {
+    if (isTruthy(process.env.NVICODE_SKIP_POSTINSTALL) || isTruthy(process.env.CI)) {
+        return;
+    }
+    if (!isGlobalInstall()) {
+        return;
+    }
+    if (!isInteractive()) {
+        console.log("nvicode installed. Run `nvicode select model` to finish setup.");
+        return;
+    }
+    const config = await loadConfig();
+    if (config.nvidiaApiKey || config.openrouterApiKey) {
+        console.log("nvicode is already configured. Run `nvicode select model` to change provider, key, or model.");
+        return;
+    }
+    console.log("");
+    console.log("nvicode installed. Starting guided setup.");
+    console.log("If you want to skip now, press Ctrl+C and run `nvicode select model` later.");
+    console.log("");
+    const cliPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "cli.js");
+    const result = spawnSync(process.execPath, [cliPath, "select", "model"], {
+        stdio: "inherit",
+        env: {
+            ...process.env,
+            NVICODE_FROM_POSTINSTALL: "1",
+        },
+    });
+    if (result.error || result.status !== 0) {
+        console.log("");
+        console.log("nvicode setup was skipped or did not complete.");
+        console.log("Run `nvicode select model` any time to finish setup.");
+    }
+};
+void main().catch(() => {
+    console.log("nvicode installed. Run `nvicode select model` to finish setup.");
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvicode",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "description": "NviCode - Introducing one click Nvidia/OpenRouter keys to Claude Code. Free Claude code.",
   "author": "Dinesh Potla",
   "keywords": [
@@ -19,6 +19,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "prepack": "npm run build",
+    "postinstall": "node dist/postinstall.js",
     "typecheck": "tsc --noEmit",
     "dev": "tsx src/cli.ts"
   },