zevairouter 1.0.66 → 1.0.67

package/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/cli/app/src/lib/terminal/ptyBridge.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Minimal PTY bridge for ZevaiRouter web terminal.
+
+stdin  -> PTY master (keystrokes)
+stdout <- PTY master (shell output), raw binary
+stderr  = control / errors (utf-8 text lines)
+
+Optional control on a side channel is not needed: resize arrives as
+OSC-like escape on stdin:  \\x1b]9999;<cols>;<rows>\\x07
+"""
+from __future__ import annotations
+
+import errno
+import fcntl
+import os
+import select
+import signal
+import struct
+import sys
+import termios
+
+
+def set_winsize(fd: int, rows: int, cols: int) -> None:
+    try:
+        packed = struct.pack("HHHH", max(5, rows), max(20, cols), 0, 0)
+        fcntl.ioctl(fd, termios.TIOCSWINSZ, packed)
+    except Exception:
+        pass
+
+
+def main() -> int:
+    cols = int(sys.argv[1]) if len(sys.argv) > 1 else 120
+    rows = int(sys.argv[2]) if len(sys.argv) > 2 else 40
+    shell = os.environ.get("SHELL") or ("/bin/bash" if os.path.exists("/bin/bash") else "/bin/sh")
+    cwd = os.path.expanduser("~")
+
+    pid, master = pty_fork = _fork_pty()
+    if pid == 0:
+        # child
+        try:
+            os.chdir(cwd)
+        except Exception:
+            pass
+        os.environ.setdefault("TERM", "xterm-256color")
+        os.environ.setdefault("COLORTERM", "truecolor")
+        os.environ.setdefault("FORCE_COLOR", "1")
+        try:
+            os.execv(shell, [shell, "-il"])
+        except Exception:
+            os.execv("/bin/sh", ["/bin/sh", "-i"])
+        return 1
+
+    set_winsize(master, rows, cols)
+
+    # Non-blocking master + stdin
+    for fd in (master, sys.stdin.fileno()):
+        fl = fcntl.fcntl(fd, fcntl.F_GETFL)
+        fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK)
+
+    # Binary stdout
+    stdout = sys.stdout.buffer
+    stdin = sys.stdin.buffer
+
+    resize_buf = b""
+
+    def handle_resize_escape(chunk: bytes) -> bytes:
+        """Strip and apply embedded resize escapes, return remaining bytes."""
+        nonlocal resize_buf
+        data = resize_buf + chunk
+        out = bytearray()
+        i = 0
+        while i < len(data):
+            # ESC ] 9999 ; cols ; rows BEL
+            if data[i] == 0x1B and data[i : i + 6] == b"\x1b]9999;":
+                end = data.find(b"\x07", i + 6)
+                if end < 0:
+                    resize_buf = data[i:]
+                    return bytes(out)
+                payload = data[i + 6 : end].decode("ascii", "ignore")
+                try:
+                    c_s, r_s = payload.split(";", 1)
+                    set_winsize(master, int(r_s), int(c_s))
+                except Exception:
+                    pass
+                i = end + 1
+                resize_buf = b""
+                continue
+            out.append(data[i])
+            i += 1
+        resize_buf = b""
+        return bytes(out)
+
+    alive = True
+
+    def on_chld(signum, frame):  # noqa: ARG001
+        nonlocal alive
+        alive = False
+
+    signal.signal(signal.SIGCHLD, on_chld)
+
+    try:
+        while alive:
+            try:
+                r, _, _ = select.select([master, sys.stdin.fileno()], [], [], 0.25)
+            except InterruptedError:
+                continue
+
+            if master in r:
+                try:
+                    data = os.read(master, 8192)
+                except OSError as e:
+                    if e.errno in (errno.EIO, errno.EAGAIN, errno.EWOULDBLOCK):
+                        data = b""
+                    else:
+                        break
+                if not data:
+                    # EIO often means child exited
+                    if not alive:
+                        break
+                else:
+                    stdout.write(data)
+                    stdout.flush()
+
+            if sys.stdin.fileno() in r:
+                try:
+                    data = stdin.read(8192)
+                except Exception:
+                    data = b""
+                if data is None:
+                    data = b""
+                if data == b"" and not alive:
+                    break
+                if data:
+                    cleaned = handle_resize_escape(data)
+                    if cleaned:
+                        try:
+                            os.write(master, cleaned)
+                        except OSError:
+                            break
+    finally:
+        try:
+            os.close(master)
+        except Exception:
+            pass
+        try:
+            os.waitpid(pid, 0)
+        except Exception:
+            pass
+    return 0
+
+
+def _fork_pty():
+    import pty
+
+    return pty.fork()
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except KeyboardInterrupt:
+        raise SystemExit(0)

package/cli/app/package.json

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

package/cli/cli.js

@@ -42,7 +42,16 @@ function createSpinner(text) {
   };
 }
 
-const pkg = require("./package.json");
+// Prefer root package.json (published name zevairouter) so CLI -v matches dashboard.
+// Fall back to cli/package.json for local monorepo layouts.
+function loadPkg() {
+  try {
+    return require("../package.json");
+  } catch {
+    return require("./package.json");
+  }
+}
+const pkg = loadPkg();
 const { ensureSqliteRuntime, buildEnvWithRuntime } = require("./hooks/sqliteRuntime");
 const { ensureTrayRuntime } = require("./hooks/trayRuntime");
 const args = process.argv.slice(2);

package/cli/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.66",
+  "version": "1.0.67",
   "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

@@ -1,34 +1,69 @@
+import fs from "fs";
 import https from "https";
+import path from "path";
+import { createRequire } from "module";
 import pkg from "../../../../package.json" with { type: "json" };
 
+export const dynamic = "force-dynamic";
+export const revalidate = 0;
+
 const NPM_PACKAGE_NAME = "zevairouter";
 
-// Fetch latest version from npm registry
-function fetchLatestVersion() {
+// Fetch latest version from npm registry (and common CN mirror fallback).
+function fetchLatestFromUrl(url) {
   return new Promise((resolve) => {
-    const req = https.get(
-      `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`,
-      { timeout: 4000 },
-      (res) => {
-        let data = "";
-        res.on("data", (chunk) => (data += chunk));
-        res.on("end", () => {
-          try {
-            resolve(JSON.parse(data).version || null);
-          } catch {
-            resolve(null);
-          }
-        });
+    const req = https.get(url, { timeout: 4000 }, (res) => {
+      // follow one redirect
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        res.resume();
+        fetchLatestFromUrl(res.headers.location).then(resolve);
+        return;
       }
-    );
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(data).version || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
     req.on("error", () => resolve(null));
-    req.on("timeout", () => { req.destroy(); resolve(null); });
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
   });
 }
 
+async function fetchLatestVersion() {
+  const urls = [
+    `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`,
+    // npmmirror is what many CN/VPS installs hit via npm config — keep in sync
+    `https://registry.npmmirror.com/${NPM_PACKAGE_NAME}/latest`,
+  ];
+  for (const url of urls) {
+    const v = await fetchLatestFromUrl(url);
+    if (v) return v;
+  }
+  return null;
+}
+
+function parseSemver(v) {
+  const m = String(v || "")
+    .trim()
+    .replace(/^v/i, "")
+    .match(/^(\d+)\.(\d+)\.(\d+)/);
+  if (!m) return null;
+  return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
+
+/** @returns {1|0|-1} a>b → 1, a<b → -1, equal/unparseable → 0 */
 function compareVersions(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb) return 0;
   for (let i = 0; i < 3; i++) {
     if (pa[i] > pb[i]) return 1;
     if (pa[i] < pb[i]) return -1;
@@ -36,10 +71,116 @@ function compareVersions(a, b) {
   return 0;
 }
 
+/**
+ * Resolve the *installed* package version from disk at request time.
+ * Prefer this over the webpack-inlined build-time import so a global npm
+ * upgrade + process restart always reflects the new package, and so we can
+ * detect "CLI updated but old server still running" mismatches.
+ */
+function readJsonVersion(filePath) {
+  try {
+    if (!filePath || !fs.existsSync(filePath)) return null;
+    const v = JSON.parse(fs.readFileSync(filePath, "utf8"))?.version;
+    return typeof v === "string" && v.trim() ? v.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function resolveInstalledVersion() {
+  const candidates = [];
+
+  // 1) Walk up from process.cwd() (standalone often starts in cli/app)
+  try {
+    let dir = process.cwd();
+    for (let i = 0; i < 6; i++) {
+      candidates.push(path.join(dir, "package.json"));
+      candidates.push(path.join(dir, "cli", "package.json"));
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    // ignore
+  }
+
+  // 2) Resolve the published package root via Node module resolution
+  try {
+    const requireFromCwd = createRequire(path.join(process.cwd(), "package.json"));
+    candidates.unshift(requireFromCwd.resolve(`${NPM_PACKAGE_NAME}/package.json`));
+  } catch {
+    // ignore
+  }
+  try {
+    // When server lives under .../zevairouter/cli/app, package root is ../..
+    candidates.unshift(path.resolve(process.cwd(), "../../package.json"));
+    candidates.unshift(path.resolve(process.cwd(), "../package.json"));
+  } catch {
+    // ignore
+  }
+
+  // 3) dirname of the running node entry (server.js / cli.js)
+  try {
+    if (typeof process.argv?.[1] === "string") {
+      let dir = path.dirname(path.resolve(process.argv[1]));
+      for (let i = 0; i < 5; i++) {
+        candidates.push(path.join(dir, "package.json"));
+        const parent = path.dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  const seen = new Set();
+  for (const file of candidates) {
+    const abs = path.resolve(file);
+    if (seen.has(abs)) continue;
+    seen.add(abs);
+    const v = readJsonVersion(abs);
+    if (!v) continue;
+    // Prefer our package only (skip random nested package.json)
+    try {
+      const name = JSON.parse(fs.readFileSync(abs, "utf8"))?.name;
+      if (name && name !== NPM_PACKAGE_NAME && name !== "zevairouter-cli") continue;
+    } catch {
+      // keep version anyway
+    }
+    return v;
+  }
+
+  // 4) Build-time fallback (webpack-inlined)
+  return typeof pkg?.version === "string" ? pkg.version : "0.0.0";
+}
+
 export async function GET() {
+  const buildVersion = 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 latestVersion = await fetchLatestVersion();
-  const currentVersion = pkg.version;
-  const hasUpdate = latestVersion ? compareVersions(latestVersion, currentVersion) > 0 : false;
+  const hasUpdate = latestVersion
+    ? compareVersions(latestVersion, currentVersion) > 0
+    : false;
 
-  return Response.json({ currentVersion, latestVersion, hasUpdate });
+  return Response.json(
+    {
+      currentVersion,
+      installedVersion,
+      buildVersion,
+      latestVersion,
+      hasUpdate,
+    },
+    {
+      headers: {
+        // Never let browser / proxy / Next cache a stale "please update" banner
+        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+        Pragma: "no-cache",
+        Expires: "0",
+      },
+    },
+  );
 }

package/src/shared/components/Sidebar.js

@@ -72,11 +72,14 @@ export default function Sidebar({ onClose }) {
       .catch(() => {});
   }, []);
 
-  // Lazy check for new npm version on mount
+  // Lazy check for new npm version on mount (no-store: avoid sticky update banner)
   useEffect(() => {
-    fetch("/api/version")
-      .then(res => res.json())
-      .then(data => { if (data.hasUpdate) setUpdateInfo(data); })
+    fetch("/api/version", { cache: "no-store" })
+      .then((res) => res.json())
+      .then((data) => {
+        if (data?.hasUpdate) setUpdateInfo(data);
+        else setUpdateInfo(null);
+      })
       .catch(() => {});
   }, []);