nvicode 0.1.9 → 0.1.10

package/README.md

@@ -17,8 +17,7 @@ Install the published package:
 npm install -g nvicode
 ```
 
-On interactive global installs, `nvicode` opens guided setup automatically.
-If you skip it, run:
+Set up provider, key, and model:
 
 ```sh
 nvicode select model
@@ -35,6 +34,15 @@ Launch Claude Code through your selected provider:
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nvicode",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "NviCode - Introducing one click Nvidia/OpenRouter keys to Claude Code. Free Claude code.",
   "author": "Dinesh Potla",
   "keywords": [