zevairouter 1.0.72 → 1.0.74

package/cli/app/cli/hooks/safeGlobalInstall.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+/**
+ * Safe global install/upgrade of zevairouter across macOS / Linux / Windows.
+ *
+ * Fixes common multi-device chaos:
+ * - ENOTEMPTY rename failures (partial global install)
+ * - dual Node (nvm vs /usr/bin) — always use the Node that is running this process
+ * - leftover .zevairouter-* temp dirs after failed upgrades
+ *
+ * Usage (from any shell after install):
+ *   node cli/hooks/safeGlobalInstall.js
+ *   node cli/hooks/safeGlobalInstall.js --version 1.0.72
+ *   node cli/hooks/safeGlobalInstall.js --latest
+ *
+ * Or programmatically:
+ *   const { safeInstallGlobal } = require("./safeGlobalInstall");
+ *   await safeInstallGlobal({ version: "latest" });
+ */
+"use strict";
+
+const { execFileSync, spawnSync } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const APP_NAME = "zevairouter";
+const BIN_NAME = "zevai";
+
+function log(msg) {
+  console.log(`[zevai-install] ${msg}`);
+}
+
+function warn(msg) {
+  console.warn(`[zevai-install] ${msg}`);
+}
+
+function detectPlatform() {
+  const p = process.platform;
+  if (p === "darwin") return { id: "mac", label: "macOS" };
+  if (p === "win32") return { id: "windows", label: "Windows" };
+  if (p === "linux") return { id: "linux", label: "Linux" };
+  return { id: p, label: p };
+}
+
+/** Resolve npm CLI that belongs to the same Node as process.execPath */
+function resolveNpmForThisNode() {
+  const nodeDir = path.dirname(process.execPath);
+  const candidates = process.platform === "win32"
+    ? [
+        path.join(nodeDir, "npm.cmd"),
+        path.join(nodeDir, "npm"),
+        "npm.cmd",
+        "npm",
+      ]
+    : [
+        path.join(nodeDir, "npm"),
+        path.join(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+      ];
+
+  for (const c of candidates) {
+    if (c === "npm" || c === "npm.cmd") continue;
+    if (fs.existsSync(c)) return c;
+  }
+
+  // Fall back to PATH npm (may differ on dual-Node boxes — we still force NODE)
+  try {
+    const which = process.platform === "win32" ? "where" : "which";
+    const out = execFileSync(which, ["npm"], { encoding: "utf8" }).trim().split(/\r?\n/)[0];
+    if (out) return out;
+  } catch {
+    /* ignore */
+  }
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+
+function runNpm(npmBin, args, opts = {}) {
+  const env = {
+    ...process.env,
+    npm_config_fund: "false",
+    npm_config_audit: "false",
+    npm_config_update_notifier: "false",
+    // Force nested tools to use this Node when possible
+    npm_node_execpath: process.execPath,
+  };
+
+  // If npmBin is npm-cli.js, invoke via node
+  const isJsCli = npmBin.endsWith("npm-cli.js");
+  const cmd = isJsCli ? process.execPath : npmBin;
+  const fullArgs = isJsCli ? [npmBin, ...args] : args;
+
+  const res = spawnSync(cmd, fullArgs, {
+    encoding: "utf8",
+    env,
+    shell: process.platform === "win32" && !isJsCli,
+    timeout: opts.timeout || 600_000,
+  });
+  return {
+    ok: res.status === 0,
+    status: res.status,
+    stdout: res.stdout || "",
+    stderr: res.stderr || "",
+    error: res.error,
+  };
+}
+
+function getGlobalRoot(npmBin) {
+  const res = runNpm(npmBin, ["root", "-g"], { timeout: 30_000 });
+  const line = (res.stdout || "").trim().split(/\r?\n/).filter(Boolean).pop();
+  if (line && fs.existsSync(line)) return line;
+  // Fallback guess
+  if (process.platform === "win32") {
+    return path.join(path.dirname(process.execPath), "node_modules");
+  }
+  return path.join(path.dirname(process.execPath), "..", "lib", "node_modules");
+}
+
+function getGlobalBin(npmBin) {
+  // npm 9+ removed `npm bin -g`. Prefer prefix/bin (Unix) or prefix (Windows).
+  const res = runNpm(npmBin, ["prefix", "-g"], { timeout: 30_000 });
+  const prefix = (res.stdout || "").trim().split(/\r?\n/).filter(Boolean).pop();
+  if (prefix && fs.existsSync(prefix)) {
+    if (process.platform === "win32") return prefix;
+    const bin = path.join(prefix, "bin");
+    if (fs.existsSync(bin)) return bin;
+  }
+  return path.dirname(process.execPath);
+}
+
+function forceRemoveGlobalPackage(globalRoot) {
+  const pkgDir = path.join(globalRoot, APP_NAME);
+  if (fs.existsSync(pkgDir)) {
+    log(`Removing previous install: ${pkgDir}`);
+    fs.rmSync(pkgDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+  }
+  // npm ENOTEMPTY leftovers: .zevairouter-XXXX
+  try {
+    for (const name of fs.readdirSync(globalRoot)) {
+      if (name.startsWith(`.${APP_NAME}-`) || name === `.${APP_NAME}`) {
+        const p = path.join(globalRoot, name);
+        log(`Removing leftover: ${p}`);
+        fs.rmSync(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+}
+
+function forceRemoveBinLinks(globalBin) {
+  const names = process.platform === "win32"
+    ? [`${BIN_NAME}.cmd`, `${BIN_NAME}`, `${BIN_NAME}.ps1`]
+    : [BIN_NAME];
+  for (const name of names) {
+    const p = path.join(globalBin, name);
+    try {
+      if (fs.existsSync(p)) fs.rmSync(p, { force: true });
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+/**
+ * @param {{ version?: string, packageSpec?: string, forceClean?: boolean }} opts
+ * @returns {{ ok: boolean, version?: string, zevaiPath?: string, nodePath: string, npmPath: string, globalRoot: string, platform: object, error?: string, log?: string }}
+ */
+function safeInstallGlobal(opts = {}) {
+  const platform = detectPlatform();
+  const version = opts.version || "latest";
+  const packageSpec = opts.packageSpec || `${APP_NAME}@${version}`;
+  const npmBin = resolveNpmForThisNode();
+  const globalRoot = getGlobalRoot(npmBin);
+  const globalBin = getGlobalBin(npmBin);
+
+  log(`OS: ${platform.label} (${process.platform}/${process.arch})`);
+  log(`Node: ${process.version} @ ${process.execPath}`);
+  log(`npm:  ${npmBin}`);
+  log(`global root: ${globalRoot}`);
+  log(`global bin:  ${globalBin}`);
+  log(`installing:  ${packageSpec}`);
+
+  // Always soft-uninstall first (best effort)
+  runNpm(npmBin, ["uninstall", "-g", APP_NAME], { timeout: 120_000 });
+
+  // Hard clean if requested or after known ENOTEMPTY scenarios
+  if (opts.forceClean !== false) {
+    forceRemoveGlobalPackage(globalRoot);
+    forceRemoveBinLinks(globalBin);
+  }
+
+  let install = runNpm(npmBin, ["install", "-g", packageSpec, "--prefer-online"], {
+    timeout: 600_000,
+  });
+
+  // Retry once on ENOTEMPTY / rename failures
+  const errText = `${install.stderr}\n${install.stdout}\n${install.error || ""}`;
+  if (!install.ok && /ENOTEMPTY|directory not empty|rename/i.test(errText)) {
+    warn("ENOTEMPTY/rename failed — force-clean and retry once");
+    forceRemoveGlobalPackage(globalRoot);
+    forceRemoveBinLinks(globalBin);
+    install = runNpm(npmBin, ["install", "-g", packageSpec, "--prefer-online"], {
+      timeout: 600_000,
+    });
+  }
+
+  if (!install.ok) {
+    return {
+      ok: false,
+      nodePath: process.execPath,
+      npmPath: npmBin,
+      globalRoot,
+      platform,
+      error: errText.slice(0, 1500) || `npm exited ${install.status}`,
+      log: errText.slice(0, 3000),
+    };
+  }
+
+  // Resolve installed version + bin path
+  let installedVersion = null;
+  try {
+    const pkgJson = path.join(globalRoot, APP_NAME, "package.json");
+    installedVersion = JSON.parse(fs.readFileSync(pkgJson, "utf8")).version;
+  } catch {
+    /* ignore */
+  }
+
+  const zevaiPath = process.platform === "win32"
+    ? path.join(globalBin, `${BIN_NAME}.cmd`)
+    : path.join(globalBin, BIN_NAME);
+
+  // Dual-node warning
+  try {
+    const pathZevai = spawnSync(
+      process.platform === "win32" ? "where" : "which",
+      [BIN_NAME],
+      { encoding: "utf8", shell: process.platform === "win32" },
+    );
+    const first = (pathZevai.stdout || "").trim().split(/\r?\n/)[0];
+    if (first && fs.existsSync(zevaiPath) && path.resolve(first) !== path.resolve(zevaiPath)) {
+      warn(`PATH resolves '${BIN_NAME}' to ${first}`);
+      warn(`This install put binary at     ${zevaiPath}`);
+      warn("Use the Node that owns this install, or put that bin dir first in PATH.");
+    }
+  } catch {
+    /* ignore */
+  }
+
+  log(`OK ${APP_NAME}@${installedVersion || "?"} → ${zevaiPath}`);
+  return {
+    ok: true,
+    version: installedVersion,
+    zevaiPath: fs.existsSync(zevaiPath) ? zevaiPath : null,
+    nodePath: process.execPath,
+    npmPath: npmBin,
+    globalRoot,
+    globalBin,
+    platform,
+  };
+}
+
+function printDoctor() {
+  const platform = detectPlatform();
+  const npmBin = resolveNpmForThisNode();
+  const globalRoot = getGlobalRoot(npmBin);
+  const globalBin = getGlobalBin(npmBin);
+  const pkgDir = path.join(globalRoot, APP_NAME);
+  let ver = null;
+  try {
+    ver = JSON.parse(fs.readFileSync(path.join(pkgDir, "package.json"), "utf8")).version;
+  } catch {
+    ver = null;
+  }
+
+  console.log(`
+Zevai install doctor
+────────────────────
+  OS:          ${platform.label} (${process.platform}/${process.arch})
+  Node:        ${process.version}
+  Node path:   ${process.execPath}
+  npm:         ${npmBin}
+  global root: ${globalRoot}
+  global bin:  ${globalBin}
+  package dir: ${pkgDir} ${fs.existsSync(pkgDir) ? "(exists)" : "(missing)"}
+  version:     ${ver || "not installed for this Node"}
+  home data:   ${path.join(os.homedir(), ".zevai")}
+`);
+
+  // PATH zevai
+  try {
+    const out = spawnSync(
+      process.platform === "win32" ? "where" : "which",
+      ["-a", BIN_NAME],
+      { encoding: "utf8", shell: process.platform === "win32" },
+    );
+    const lines = (out.stdout || "").trim().split(/\r?\n/).filter(Boolean);
+    if (lines.length) {
+      console.log("  PATH zevai binaries:");
+      for (const l of lines) console.log(`    - ${l}`);
+      if (lines.length > 1) {
+        console.log("\n  ⚠ Multiple zevai on PATH — use one Node only (nvm use / brew unlink).");
+      }
+    }
+  } catch {
+    console.log("  PATH zevai: not found");
+  }
+  console.log("");
+}
+
+// CLI entry
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.includes("--doctor") || args.includes("doctor")) {
+    printDoctor();
+    process.exit(0);
+  }
+  let version = "latest";
+  const vi = args.indexOf("--version");
+  if (vi >= 0 && args[vi + 1]) version = args[vi + 1];
+  if (args.includes("--latest")) version = "latest";
+  const forceClean = !args.includes("--no-clean");
+
+  const result = safeInstallGlobal({ version, forceClean });
+  if (!result.ok) {
+    console.error(result.error || "install failed");
+    process.exit(1);
+  }
+  console.log(`\nDone. Run:  zevai --version`);
+  if (result.zevaiPath) console.log(`Binary: ${result.zevaiPath}`);
+  process.exit(0);
+}
+
+module.exports = {
+  safeInstallGlobal,
+  printDoctor,
+  detectPlatform,
+  resolveNpmForThisNode,
+  getGlobalRoot,
+  APP_NAME,
+  BIN_NAME,
+};

package/cli/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.72",
+  "version": "1.0.74",
   "description": "Self-hosted AI router: many providers, one OpenAI-compatible /v1 endpoint and dashboard",
   "bin": {
     "zevai": "./cli/cli.js"

package/cli/cli.js

@@ -109,7 +109,7 @@ for (let i = 0; i < args.length; i++) {
     process.env.TRAY_MODE = "1";
   } else if (args[i] === "--help" || args[i] === "-h") {
     console.log(`
-Usage: ${APP_NAME} [options]
+Usage: zevai [options]
 
 Options:
   -p, --port <port>   Port to run the server (default: ${DEFAULT_PORT})
@@ -118,13 +118,44 @@ Options:
   -l, --log           Show server logs (default: hidden)
   -t, --tray          Run in system tray mode (background)
   --skip-update       Skip auto-update check
+  --doctor            Show install paths (Node/npm/global) + dual-install hints
+  --fix-install      Repair/reinstall global package for THIS Node (ENOTEMPTY-safe)
   -h, --help          Show this help message
   -v, --version       Show version
+
+One-shot install (any device):
+  macOS/Linux:  curl -fsSL https://raw.githubusercontent.com/Verifiedlabs/zevairouter/main/install.sh | bash
+  Windows:      irm https://raw.githubusercontent.com/Verifiedlabs/zevairouter/main/install.ps1 | iex
 `);
     process.exit(0);
   } else if (args[i] === "--version" || args[i] === "-v") {
     console.log(pkg.version);
     process.exit(0);
+  } else if (args[i] === "--doctor") {
+    try {
+      require("./hooks/safeGlobalInstall").printDoctor();
+    } catch (e) {
+      console.error("doctor failed:", e.message);
+      process.exit(1);
+    }
+    process.exit(0);
+  } else if (args[i] === "--fix-install") {
+    try {
+      const { safeInstallGlobal } = require("./hooks/safeGlobalInstall");
+      const verIdx = args.indexOf("--to");
+      const version = verIdx >= 0 && args[verIdx + 1] ? args[verIdx + 1] : "latest";
+      const result = safeInstallGlobal({ version, forceClean: true });
+      if (!result.ok) {
+        console.error(result.error || "install failed");
+        process.exit(1);
+      }
+      console.log(`\nInstalled zevairouter@${result.version || version}`);
+      console.log(`Restart: close this process and run  zevai --version`);
+      process.exit(0);
+    } catch (e) {
+      console.error("fix-install failed:", e.message);
+      process.exit(1);
+    }
   }
 }
 
@@ -694,11 +725,36 @@ function startServer(latestVersion) {
           const { clearScreen } = require("./src/cli/utils/display");
           clearScreen();
           console.log(`\n⬆  Update v${pkg.version} → v${latestVersion}\n`);
-          console.log(`Run this after exit:\n`);
-          console.log(`   \x1b[33m${INSTALL_CMD_LATEST}\x1b[0m\n`);
+          try {
+            const { safeInstallGlobal } = require("./hooks/safeGlobalInstall");
+            console.log("Installing for this Node (auto-clean if needed)…\n");
+            const result = safeInstallGlobal({ version: latestVersion, forceClean: true });
+            if (!result.ok) {
+              console.log(`❌ Auto-update failed:\n${result.error || ""}\n`);
+              console.log(`Manual:\n   \x1b[33mzevai --fix-install --to ${latestVersion}\x1b[0m\n`);
+              console.log(`   or: \x1b[33m${INSTALL_CMD_LATEST}\x1b[0m\n`);
+            } else {
+              console.log(`\n✅ Updated to v${result.version || latestVersion}`);
+              console.log("   Restarting…\n");
+            }
+          } catch (e) {
+            console.log(`❌ Auto-update error: ${e.message}\n`);
+            console.log(`Manual: \x1b[33m${INSTALL_CMD_LATEST}\x1b[0m\n`);
+          }
           cleanup();
           await killAllAppProcesses(port);
           await killProcessOnPort(port);
+          // Relaunch if new binary exists
+          try {
+            const child = spawn(process.execPath, [process.argv[1], "--skip-update", ...process.argv.slice(2).filter((a) => a !== "--skip-update")], {
+              detached: true,
+              stdio: "ignore",
+              env: process.env,
+            });
+            child.unref();
+          } catch {
+            /* user restarts manually */
+          }
           setTimeout(() => process.exit(0), 200);
           return;
         } else if (choice === "web") {