zevairouter 1.0.93 → 1.0.95

package/cli/cli.js

@@ -123,12 +123,16 @@ Options:
   --force-restart     Kill existing instance and start a new one (default: attach if healthy)
   --doctor            Show install paths (Node/npm/global) + dual-install hints
   --fix-install      Repair/reinstall global package for THIS Node (ENOTEMPTY-safe)
+  update [--to X.Y.Z] Force update + restart (VPS: systemctl, desktop: relaunch)
   -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
+Update (simple — same Node as this zevai, restarts service):
+  zevai update
+  zevai update --to 1.0.93
+
+One-shot install / reinstall (any device):
+  curl -fsSL https://gist.githubusercontent.com/Verifiedlabs/7fe0ab16692acbacd1b471d2c1bbd09b/raw/install.sh | bash
 `);
     process.exit(0);
   } else if (args[i] === "--version" || args[i] === "-v") {
@@ -142,30 +146,128 @@ One-shot install (any device):
       process.exit(1);
     }
     process.exit(0);
-  } else if (args[i] === "--fix-install") {
+  } else if (args[i] === "--fix-install" || args[i] === "update" || args[i] === "--update") {
+    // `zevai update` — one command, same as 9router simplicity.
+    // Force-clean global install + restart systemd (VPS) or relaunch process.
     try {
       const { safeInstallGlobal } = require("./hooks/safeGlobalInstall");
-      const { spawn } = require("child_process");
+      const { spawn, execFileSync } = require("child_process");
       const fs = require("fs");
       const path = require("path");
       const verIdx = args.indexOf("--to");
       const version = verIdx >= 0 && args[verIdx + 1] ? args[verIdx + 1] : "latest";
       const wasTray = process.argv.includes("--tray") || process.env.TRAY_MODE === "1";
+      console.log(`\nUpdating zevairouter@${version}…`);
       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(`\n✓ Installed zevairouter@${result.version || version}`);
+      console.log(`  binary: ${result.zevaiPath || "zevai"}`);
 
       // Relaunch new binary detached, then exit this process so the new build loads.
       if (process.env.ZEVAI_SKIP_RESTART === "1") {
         console.log(`Restart skipped (ZEVAI_SKIP_RESTART=1). Run: zevai`);
         process.exit(0);
       }
+
+      // VPS: rewrite systemd unit to THIS Node + zevai, hard-stop old processes, restart.
+      // Without rewrite, unit can keep pointing at /usr/bin while nvm got the new package
+      // → currentVersion jumps but buildVersion stays on the old Next bundle.
+      if (process.platform === "linux" && process.getuid && process.getuid() === 0) {
+        const { execSync } = require("child_process");
+        const unitName = "zevairouter.service";
+        const unitPath = `/etc/systemd/system/${unitName}`;
+        const nodeBin = result.nodePath || process.execPath;
+        const nodeDir = path.dirname(nodeBin);
+        const zevaiBin = result.zevaiPath
+          || path.join(result.globalBin || path.dirname(nodeBin), "zevai");
+        const cliJs = result.globalRoot
+          ? path.join(result.globalRoot, "zevairouter", "cli", "cli.js")
+          : null;
+        const port = process.env.PORT || "1997";
+        // Prefer `node cli.js` over shim so the unit always runs the package we just installed.
+        const execStart = cliJs && fs.existsSync(cliJs)
+          ? `${nodeBin} ${cliJs} --port ${port} --no-browser --skip-update --log`
+          : `${nodeBin} ${zevaiBin} --port ${port} --no-browser --skip-update --log`;
+
+        try {
+          const unitBody = `[Unit]
+Description=ZevaiRouter
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=root
+WorkingDirectory=/root
+Environment="PATH=${nodeDir}:/usr/local/bin:/usr/bin:/bin"
+Environment="PORT=${port}"
+Environment="HOSTNAME=0.0.0.0"
+Environment="DISPLAY=:99"
+Environment="ZEVAI_MINIMAL_POSTINSTALL=1"
+Environment="ZEVAI_SERVER_MODE=1"
+Environment="ZEVAI_MAX_OLD_SPACE_SIZE=1536"
+MemoryMax=2G
+MemorySwapMax=0
+ExecStartPre=/bin/bash -c "pgrep -x Xvfb >/dev/null || (Xvfb :99 -screen 0 1280x900x24 -ac -nolisten tcp >/var/log/xvfb-zevai.log 2>&1 & sleep 0.8)"
+ExecStart=${execStart}
+Restart=always
+RestartSec=3
+StandardOutput=append:/var/log/zevairouter.log
+StandardError=append:/var/log/zevairouter.log
+
+[Install]
+WantedBy=multi-user.target
+`;
+          fs.writeFileSync(unitPath, unitBody);
+          console.log(`Wrote ${unitPath}`);
+          console.log(`  ExecStart=${execStart}`);
+          try { execFileSync("systemctl", ["stop", unitName], { stdio: "ignore", timeout: 15000 }); } catch { /* ignore */ }
+          // Kill any leftover (old nvm / tray / orphan) so port is free.
+          try {
+            execSync("pkill -f 'zevairouter/cli/cli.js' 2>/dev/null || true; pkill -f '/bin/zevai' 2>/dev/null || true", {
+              stdio: "ignore",
+              timeout: 5000,
+            });
+          } catch { /* ignore */ }
+          execFileSync("systemctl", ["daemon-reload"], { stdio: "ignore", timeout: 10000 });
+          execFileSync("systemctl", ["enable", unitName], { stdio: "ignore", timeout: 10000 });
+          console.log(`Starting ${unitName}…`);
+          execFileSync("systemctl", ["restart", unitName], { stdio: "inherit", timeout: 30000 });
+
+          let live = null;
+          for (let i = 0; i < 20; i++) {
+            execSync("sleep 1");
+            try {
+              const out = execSync(`curl -sS -m 2 http://127.0.0.1:${port}/api/version`, { encoding: "utf8" });
+              live = JSON.parse(out);
+              break;
+            } catch { /* wait */ }
+          }
+          if (live) {
+            console.log(`✓ Live: ${JSON.stringify(live)}`);
+            if (live.buildVersion && live.installedVersion && live.buildVersion !== live.installedVersion) {
+              console.warn(`! buildVersion (${live.buildVersion}) != installed (${live.installedVersion})`);
+              console.warn("  Still mixed install — check: systemctl cat zevairouter | grep ExecStart");
+              console.warn("  and:  ls -la $(npm root -g)/zevairouter/package.json");
+            } else {
+              console.log(`✓ Version consistent: ${live.currentVersion}`);
+            }
+            process.exit(0);
+          }
+          console.warn("Service started but /api/version not responding yet.");
+          console.log(`Check: journalctl -u ${unitName} -n 40 --no-pager`);
+          process.exit(0);
+        } catch (e) {
+          console.warn(`systemd path failed (${e.message}) — falling back to direct relaunch`);
+        }
+      }
+
       const relaunchArgs = wasTray
         ? ["--tray", "--skip-update"]
-        : ["--port", process.env.PORT || "1997", "--no-browser", "--skip-update"];
+        : ["--port", process.env.PORT || "1997", "--no-browser", "--skip-update", "--log"];
       try {
         const logDir = path.join(process.env.HOME || process.env.USERPROFILE || ".", ".zevai", "logs");
         fs.mkdirSync(logDir, { recursive: true });
@@ -179,13 +281,21 @@ One-shot install (any device):
           ? spawn(process.execPath, [cliEntry, ...relaunchArgs], {
               detached: true,
               stdio: ["ignore", out, out],
-              env: { ...process.env, TRAY_MODE: wasTray ? "1" : process.env.TRAY_MODE },
+              env: {
+                ...process.env,
+                TRAY_MODE: wasTray ? "1" : "",
+                ZEVAI_SERVER_MODE: wasTray ? "" : "1",
+              },
             })
           : spawn(result.zevaiPath || "zevai", relaunchArgs, {
               detached: true,
               stdio: ["ignore", out, out],
               shell: process.platform === "win32",
-              env: { ...process.env, TRAY_MODE: wasTray ? "1" : process.env.TRAY_MODE },
+              env: {
+                ...process.env,
+                TRAY_MODE: wasTray ? "1" : "",
+                ZEVAI_SERVER_MODE: wasTray ? "" : "1",
+              },
             });
         child.unref();
         console.log(`Restarting ${wasTray ? "tray" : "server"}… (log ${logFile})`);
@@ -197,14 +307,24 @@ One-shot install (any device):
       // Exit soon so :1997 is free for the new process.
       setTimeout(() => process.exit(0), 500);
     } catch (e) {
-      console.error("fix-install failed:", e.message);
+      console.error("update failed:", e.message);
       process.exit(1);
     }
   }
 }
 
 // Auto-relaunch after update: detached process has no TTY → fallback to tray
-if (skipUpdate && !trayMode && !process.stdin.isTTY) {
+// ONLY for desktop/tray flows. VPS server mode must stay server.
+if (
+  skipUpdate
+  && !trayMode
+  && !process.stdin.isTTY
+  && process.env.ZEVAI_SERVER_MODE !== "1"
+  && !process.env.PORT
+  && process.env.TRAY_MODE !== "0"
+) {
+  // Heuristic: systemd / nohup restarts often set PORT or ZEVAI_SERVER_MODE.
+  // If neither is set and no TTY, assume desktop tray (legacy 9router behaviour).
   trayMode = true;
   process.env.TRAY_MODE = "1";
 }

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.93",
+  "version": "1.0.95",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/package.json

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

package/src/app/api/version/route.js

@@ -156,16 +156,25 @@ function resolveInstalledVersion() {
 }
 
 export async function GET() {
-  const buildVersion = typeof pkg?.version === "string" ? pkg.version : null;
+  // Webpack-inlined at `next build` time (can lag if an old process is still up).
+  const webpackBuildVersion = typeof pkg?.version === "string" ? pkg.version : null;
   const installedVersion = resolveInstalledVersion();
   // What the dashboard should treat as "this server": prefer disk install, then build
-  const currentVersion = installedVersion || buildVersion || "0.0.0";
+  const currentVersion = installedVersion || webpackBuildVersion || "0.0.0";
+  // Expose webpack embed as buildVersion for diagnostics; UI should use currentVersion.
+  const buildVersion = webpackBuildVersion;
 
   const latestVersion = await fetchLatestVersion();
   const hasUpdate = latestVersion
     ? compareVersions(latestVersion, currentVersion) > 0
     : false;
 
+  const buildMismatch = Boolean(
+    installedVersion
+    && webpackBuildVersion
+    && installedVersion !== webpackBuildVersion,
+  );
+
   return Response.json(
     {
       currentVersion,
@@ -173,6 +182,9 @@ export async function GET() {
       buildVersion,
       latestVersion,
       hasUpdate,
+      // true when package.json is new but the running Next bundle is old
+      // (usually: systemd still on a different Node path, or process not fully restarted)
+      buildMismatch,
     },
     {
       headers: {

package/src/lib/appUpdater.js

@@ -169,10 +169,12 @@ export function spawnUpdaterAndExit(packageName = UPDATER_CONFIG.npmPackageName)
   const updaterPath = ensureRuntimeUpdater(resolveBundledUpdaterPath());
   const isTray = process.env.TRAY_MODE === "1";
   const relaunch = resolveRelaunchCommand();
-  // Relaunch matching original env: tray stays tray, foreground stays foreground
+  // Relaunch matching original env: tray stays tray; server stays server
+  // (must pass --port/--no-browser so VPS doesn't flip into tray via no-TTY).
+  const appPort = String(process.env.PORT || UPDATER_CONFIG.appPort || 1997);
   const relaunchArgs = isTray
     ? [...relaunch.args, "--tray", "--skip-update"]
-    : [...relaunch.args, "--skip-update"];
+    : [...relaunch.args, "--port", appPort, "--no-browser", "--skip-update", "--log"];
 
   spawn(process.execPath, [updaterPath], {
     detached: true,
@@ -180,7 +182,8 @@ export function spawnUpdaterAndExit(packageName = UPDATER_CONFIG.npmPackageName)
     windowsHide: true,
     env: {
       ...process.env,
-      UPDATER_PKG_NAME: packageName,
+      // Always npm package name — never the CLI bin name "zevai".
+      UPDATER_PKG_NAME: packageName || "zevairouter",
       UPDATER_PORT: String(UPDATER_CONFIG.statusPort),
       UPDATER_TAIL_LINES: String(UPDATER_CONFIG.statusLogTailLines),
       UPDATER_RETRIES: String(UPDATER_CONFIG.installRetries),
@@ -189,10 +192,11 @@ export function spawnUpdaterAndExit(packageName = UPDATER_CONFIG.npmPackageName)
       UPDATER_WAIT_MIN_MS: String(UPDATER_CONFIG.waitForExitMinMs),
       UPDATER_WAIT_MAX_MS: String(UPDATER_CONFIG.waitForExitMaxMs),
       UPDATER_WAIT_CHECK_MS: String(UPDATER_CONFIG.waitForExitCheckMs),
-      UPDATER_APP_PORT: String(UPDATER_CONFIG.appPort),
+      UPDATER_APP_PORT: appPort,
       UPDATER_RELAUNCH: "1",
       UPDATER_RELAUNCH_CMD: relaunch.cmd,
       UPDATER_RELAUNCH_ARGS: JSON.stringify(relaunchArgs),
+      ZEVAI_SERVER_MODE: isTray ? "" : "1",
     },
   }).unref();
 

package/src/lib/updater/updater.js

@@ -9,7 +9,8 @@ const path = require("path");
 const fs = require("fs");
 const os = require("os");
 
-const packageName = process.env.UPDATER_PKG_NAME || "zevai";
+// Must be npm package name (zevairouter), NOT the CLI bin (zevai).
+const packageName = process.env.UPDATER_PKG_NAME || "zevairouter";
 const port = parseInt(process.env.UPDATER_PORT || "20129", 10);
 const tailLines = parseInt(process.env.UPDATER_TAIL_LINES || "8", 10);
 const maxRetries = parseInt(process.env.UPDATER_RETRIES || "3", 10);
@@ -128,19 +129,72 @@ function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
 
+function resolveSafeInstallHook() {
+  const candidates = [
+    path.join(path.dirname(process.execPath), "..", "lib", "node_modules", "zevairouter", "cli", "hooks", "safeGlobalInstall.js"),
+    path.join("/usr/lib/node_modules/zevairouter/cli/hooks/safeGlobalInstall.js"),
+    path.join("/usr/local/lib/node_modules/zevairouter/cli/hooks/safeGlobalInstall.js"),
+    path.join("/opt/homebrew/lib/node_modules/zevairouter/cli/hooks/safeGlobalInstall.js"),
+    ...String(process.env.NODE_PATH || "")
+      .split(path.delimiter)
+      .filter(Boolean)
+      .map((p) => path.join(p, "zevairouter", "cli", "hooks", "safeGlobalInstall.js")),
+  ];
+  try {
+    const { createRequire } = require("module");
+    const req = createRequire(path.join(process.cwd(), "package.json"));
+    candidates.unshift(req.resolve("zevairouter/cli/hooks/safeGlobalInstall.js"));
+  } catch { /* ignore */ }
+  // Updater itself may live next to a package tree under ~/.zevai
+  try {
+    const dataDir = getDataDir();
+    candidates.push(
+      path.join(dataDir, "runtime", "node_modules", "zevairouter", "cli", "hooks", "safeGlobalInstall.js"),
+    );
+  } catch { /* ignore */ }
+
+  for (const p of candidates) {
+    try {
+      if (p && fs.existsSync(p)) return p;
+    } catch { /* next */ }
+  }
+  return null;
+}
+
 function runInstall() {
   state.attempt += 1;
   setPhase("installing");
-  pushLog(`[updater] attempt ${state.attempt}/${maxRetries} — npm i -g ${packageName} --prefer-online`);
+  // Force-clean path (ENOTEMPTY-safe) like `zevai update` / install.sh.
+  // Plain `npm i -g` often leaves the old build running or fails half-way on VPS.
+  const pkgSpec = packageName.includes("@") ? packageName : `${packageName}@latest`;
+  pushLog(`[updater] attempt ${state.attempt}/${maxRetries} — safe install ${pkgSpec}`);
 
   const isWin = process.platform === "win32";
-  const cmd = isWin ? "npm.cmd" : "npm";
-  const args = ["i", "-g", packageName, "--prefer-online"];
+  const hook = resolveSafeInstallHook();
+
+  let cmd;
+  let args;
+  if (hook) {
+    cmd = process.execPath;
+    args = [hook, "--latest"];
+    pushLog(`[updater] using safeGlobalInstall: ${hook}`);
+  } else {
+    cmd = isWin ? "npm.cmd" : "npm";
+    // Explicit @latest — never install a phantom "zevai" package.
+    args = ["i", "-g", pkgSpec, "--prefer-online"];
+    pushLog(`[updater] safe hook missing — fallback npm ${args.join(" ")}`);
+  }
 
   const child = spawn(cmd, args, {
     stdio: ["ignore", "pipe", "pipe"],
     windowsHide: true,
-    shell: isWin,
+    shell: isWin && !hook,
+    env: {
+      ...process.env,
+      npm_config_fund: "false",
+      npm_config_audit: "false",
+      npm_config_update_notifier: "false",
+    },
   });
 
   child.stdout.on("data", (buf) => {
@@ -158,7 +212,7 @@ function runInstall() {
   });
 
   child.on("close", (code) => {
-    pushLog(`[updater] npm exited with code ${code}`);
+    pushLog(`[updater] install exited with code ${code}`);
     if (code === 0) {
       finalize(true, code, null);
       return;
@@ -195,8 +249,40 @@ async function waitForAppAndOpenBrowser() {
   pushLog(`[updater] app not responding within 30s, skip browser open`);
 }
 
+function trySystemdRestart() {
+  if (process.platform === "win32" || process.platform === "darwin") return false;
+  try {
+    const { execFileSync } = require("child_process");
+    // Prefer our unit name; fall back to common aliases.
+    const units = ["zevairouter.service", "zevai.service"];
+    for (const unit of units) {
+      try {
+        execFileSync("systemctl", ["cat", unit], { stdio: "ignore", timeout: 3000 });
+      } catch {
+        continue;
+      }
+      pushLog(`[updater] restarting systemd unit ${unit}`);
+      execFileSync("systemctl", ["daemon-reload"], { stdio: "ignore", timeout: 10000 });
+      execFileSync("systemctl", ["restart", unit], { stdio: "ignore", timeout: 30000 });
+      pushLog(`[updater] systemctl restart ${unit} OK`);
+      return true;
+    }
+  } catch (e) {
+    pushLog(`[updater] systemd restart skipped: ${e.message}`);
+  }
+  return false;
+}
+
 function relaunchApp() {
   if (process.env.UPDATER_RELAUNCH !== "1") return;
+
+  // VPS path: if systemd owns the service, restart that — don't spawn a second
+  // tray process that leaves the unit on the old binary forever.
+  if (trySystemdRestart()) {
+    waitForAppAndOpenBrowser();
+    return;
+  }
+
   const cmd = process.env.UPDATER_RELAUNCH_CMD;
   if (!cmd) return;
   let args = [];
@@ -208,11 +294,17 @@ function relaunchApp() {
       stdio: "ignore",
       windowsHide: true,
       shell: isWin,
-      env: { ...process.env, UPDATER_RELAUNCH: "", UPDATER_RELAUNCH_CMD: "", UPDATER_RELAUNCH_ARGS: "" },
+      env: {
+        ...process.env,
+        UPDATER_RELAUNCH: "",
+        UPDATER_RELAUNCH_CMD: "",
+        UPDATER_RELAUNCH_ARGS: "",
+        // Prevent cli.js from flipping headless server restarts into tray mode.
+        ZEVAI_SERVER_MODE: args.includes("--tray") ? "" : "1",
+      },
     });
     child.unref();
     pushLog(`[updater] relaunched: ${cmd} ${args.join(" ")} (pid=${child.pid})`);
-    // Wait for new app to come up, then auto-open browser so user sees the result
     waitForAppAndOpenBrowser();
   } catch (e) {
     pushLog(`[updater] relaunch failed: ${e.message}`);