zevairouter 1.0.66 → 1.0.68

package/cli/hooks/playwrightRuntime.js

@@ -1,10 +1,15 @@
 // Ensure Playwright + Chromium are usable at runtime. `npm i -g zevairouter`
-// installs the playwright npm package but does NOT trigger its postinstall
-// browser download under all package managers, so the first bulk-import
-// attempt fails with "Executable doesn't exist at .../chrome-headless-shell".
-// We download lazily on first launch so users who never touch automation
-// aren't billed ~150MB of disk.
+// may not ship a resolvable playwright package under webpack/standalone, and
+// does NOT always trigger browser download. We install into ~/.zevai/runtime
+// and resolve with real Node require (not webpack's registry).
+//
+// Bug we fix (Kiro bulk mass-fail):
+//   "playwright installed but cannot be required"
+//   → package exists under ~/.zevai/runtime/node_modules/playwright but
+//     bare require("playwright") is rewritten by webpack and throws.
+//   Same pattern as camoufoxRuntime: createRequire + __non_webpack_require__.
 const { spawnSync } = require("child_process");
+const { createRequire } = require("module");
 const fs = require("fs");
 const path = require("path");
 
@@ -13,19 +18,50 @@ const { runNpmInstall, getRuntimeDir, getRuntimeNodeModules } = require("./sqlit
 const PLAYWRIGHT_PACKAGE = "playwright";
 const PLAYWRIGHT_VERSION = "^1.54.2";
 
+// Webpack rewrites bare require(); __non_webpack_require__ stays real Node require.
+const nodeRequire =
+  typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
+
+function getRuntimeRequire() {
+  try {
+    const anchor = path.join(getRuntimeDir(), "noop.js");
+    return createRequire(anchor);
+  } catch {
+    return null;
+  }
+}
+
 let cachedReady = null;
 
 function tryRequirePlaywright() {
+  // 1) Runtime-anchored createRequire (works under webpack + any cwd)
   try {
-    return require(PLAYWRIGHT_PACKAGE);
+    const rreq = getRuntimeRequire();
+    const candidate = path.join(getRuntimeNodeModules(), PLAYWRIGHT_PACKAGE);
+    if (rreq && fs.existsSync(path.join(candidate, "package.json"))) {
+      return rreq(candidate);
+    }
+  } catch {}
+
+  // 2) Bare real require (global / NODE_PATH)
+  try {
+    return nodeRequire(PLAYWRIGHT_PACKAGE);
   } catch {}
+
+  // 3) Absolute path via nodeRequire
   try {
-    const runtimeNm = getRuntimeNodeModules();
-    const candidate = path.join(runtimeNm, PLAYWRIGHT_PACKAGE);
+    const candidate = path.join(getRuntimeNodeModules(), PLAYWRIGHT_PACKAGE);
     if (fs.existsSync(path.join(candidate, "package.json"))) {
-      return require(candidate);
+      return nodeRequire(candidate);
     }
   } catch {}
+
+  // 4) Resolve from process cwd node_modules (dev)
+  try {
+    const rreq = createRequire(path.join(process.cwd(), "package.json"));
+    return rreq(PLAYWRIGHT_PACKAGE);
+  } catch {}
+
   return null;
 }
 
@@ -45,11 +81,22 @@ function isChromiumBinaryAvailable() {
 function findCli() {
   const candidates = [];
   try {
-    const pwPkg = require.resolve("playwright/package.json");
+    const rreq = getRuntimeRequire();
+    if (rreq) {
+      try {
+        candidates.push(path.join(path.dirname(rreq.resolve(`${PLAYWRIGHT_PACKAGE}/package.json`)), "cli.js"));
+      } catch {}
+      try {
+        candidates.push(path.join(path.dirname(rreq.resolve("playwright-core/package.json")), "cli.js"));
+      } catch {}
+    }
+  } catch {}
+  try {
+    const pwPkg = nodeRequire.resolve("playwright/package.json");
     candidates.push(path.join(path.dirname(pwPkg), "cli.js"));
   } catch {}
   try {
-    const pwCorePkg = require.resolve("playwright-core/package.json");
+    const pwCorePkg = nodeRequire.resolve("playwright-core/package.json");
     candidates.push(path.join(path.dirname(pwCorePkg), "cli.js"));
   } catch {}
   try {
@@ -81,9 +128,17 @@ function ensurePlaywrightPackage({ silent = false } = {}) {
     };
   }
 
+  // Clear any half-state and re-resolve with createRequire
+  cachedReady = null;
   const installed = tryRequirePlaywright();
   if (!installed) {
-    return { ok: false, reason: "playwright installed but cannot be required" };
+    return {
+      ok: false,
+      reason:
+        "playwright installed into ~/.zevai/runtime but cannot be required " +
+        "(webpack/module path). Restart zevai after install, or run: " +
+        'node -e "require(require(\'path\').join(require(\'os\').homedir(),\'.zevai/runtime/node_modules/playwright\'))"',
+    };
   }
   return { ok: true, module: installed };
 }
@@ -96,10 +151,18 @@ function runInstall({ silent = false, timeout = 600_000 } = {}) {
 
   if (!silent) console.log("\u23f3 Downloading Playwright Chromium (first run, ~150MB)...");
 
+  // Never honor channel=chrome — Kiro bulk needs bundled Chromium, not /opt/google/chrome
+  const env = {
+    ...process.env,
+    PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: undefined,
+  };
+  delete env.PLAYWRIGHT_CHROMIUM_CHANNEL;
+
   const res = spawnSync(process.execPath, [cliPath, "install", "chromium"], {
     stdio: silent ? ["ignore", "pipe", "pipe"] : "inherit",
     timeout,
     encoding: "utf8",
+    env,
   });
 
   if (res.status === 0) {
@@ -118,14 +181,17 @@ function runInstall({ silent = false, timeout = 600_000 } = {}) {
 }
 
 function ensurePlaywrightRuntime({ silent = false, timeout } = {}) {
-  if (cachedReady === true) return { ok: true };
+  if (cachedReady === true) {
+    const mod = tryRequirePlaywright();
+    return { ok: true, module: mod };
+  }
 
   const pkg = ensurePlaywrightPackage({ silent });
   if (!pkg.ok) {
     cachedReady = false;
     const error = new Error(
       `Playwright not available. ${pkg.reason}. ` +
-      `Run "npm install -g playwright && npx playwright install chromium" manually, then retry.`
+        `Run "npm install -g playwright && npx playwright install chromium" manually, then retry.`
     );
     error.code = "PLAYWRIGHT_PACKAGE_MISSING";
     return { ok: false, error };
@@ -133,19 +199,19 @@ function ensurePlaywrightRuntime({ silent = false, timeout } = {}) {
 
   if (isChromiumBinaryAvailable()) {
     cachedReady = true;
-    return { ok: true, module: pkg.module };
+    return { ok: true, module: pkg.module || tryRequirePlaywright() };
   }
 
   const result = runInstall({ silent, timeout });
   if (result.ok && isChromiumBinaryAvailable()) {
     cachedReady = true;
-    return { ok: true, module: pkg.module };
+    return { ok: true, module: pkg.module || tryRequirePlaywright() };
   }
 
   cachedReady = false;
   const error = new Error(
     `Playwright Chromium not available. ${result.reason}. ` +
-    `Run "npx playwright install chromium" manually, then retry.`
+      `Run "npx playwright install chromium" manually, then retry.`
   );
   error.code = "PLAYWRIGHT_CHROMIUM_MISSING";
   return { ok: false, error };
@@ -165,4 +231,5 @@ module.exports = {
   isChromiumBinaryAvailable,
   resetCache,
   findPlaywrightCli: findCli,
+  tryRequirePlaywright,
 };

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.66",
+  "version": "1.0.68",
   "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.68",
   "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/lib/oauth/services/bulkImportBrowserEngine.js

@@ -112,32 +112,25 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
     await ensureHeadedDisplayOrThrow();
   }
 
+  // Prefer runtime helper first — under Next/webpack, dynamic import("playwright")
+  // often fails even when ~/.zevai/runtime has the package (Kiro mass-fail).
   let chromium = null;
   let importErr = null;
-  try {
-    chromium = await importPlaywright();
-  } catch (err) {
-    importErr = err;
+  const runtime = loadRuntimeHelper("playwrightRuntime");
+  if (runtime?.ensurePlaywrightRuntime) {
+    const ready = runtime.ensurePlaywrightRuntime({ silent: false });
+    if (ready.ok) {
+      const mod = ready.module || runtime.loadPlaywrightModule?.() || runtime.tryRequirePlaywright?.();
+      chromium = mod?.chromium ?? null;
+    } else if (ready.error) {
+      importErr = ready.error;
+    }
   }
-
   if (!chromium) {
-    const runtime = loadRuntimeHelper("playwrightRuntime");
-    if (runtime?.ensurePlaywrightRuntime) {
-      const ready = runtime.ensurePlaywrightRuntime({ silent: false });
-      if (ready.ok) {
-        try {
-          chromium = await importPlaywright();
-        } catch (err) {
-          importErr = err;
-        }
-        if (!chromium) {
-          const mod = ready.module || runtime.loadPlaywrightModule?.();
-          chromium = mod?.chromium ?? null;
-        }
-      } else if (ready.error) {
-        if (importErr) ready.error.cause = importErr;
-        throw ready.error;
-      }
+    try {
+      chromium = await importPlaywright();
+    } catch (err) {
+      importErr = err;
     }
   }
 
@@ -152,8 +145,11 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
 
   const width = windowSize?.width || (wantHeadless ? 1920 : 900);
   const height = windowSize?.height || (wantHeadless ? 1080 : 700);
+  // Force bundled Chromium — never Google Chrome channel (/opt/google/chrome),
+  // which is missing on most VPS and caused "distribution 'chrome' is not found".
   const options = {
     headless: wantHeadless,
+    channel: undefined,
     args: [
       "--disable-blink-features=AutomationControlled",
       "--disable-features=IsolateOrigins,site-per-process,AutomationControlled",
@@ -173,6 +169,14 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
     ],
     ignoreDefaultArgs: ["--enable-automation"],
   };
+  // Explicit bundled Chromium path when it exists (avoids channel=chrome hijack)
+  try {
+    const { existsSync } = await import("node:fs");
+    const exePath = typeof chromium.executablePath === "function" ? chromium.executablePath() : null;
+    if (exePath && existsSync(exePath)) options.executablePath = exePath;
+  } catch {
+    // ignore
+  }
   if (proxyUrl) {
     const { parsePlaywrightProxy } = await import("./proxyUtils.js");
     options.proxy = parsePlaywrightProxy(proxyUrl) || { server: proxyUrl };
@@ -188,6 +192,18 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
       const browser = await chromium.launch(options);
       return wrapBrowserWithStealth(browser);
     }
+    // Retry without executablePath if channel/chrome confusion remains
+    if (/distribution ['\"]chrome['\"]|Executable doesn't exist|chrome-headless-shell/i.test(msg)) {
+      try {
+        const retryOpts = { ...options };
+        delete retryOpts.channel;
+        delete retryOpts.executablePath;
+        const browser = await chromium.launch(retryOpts);
+        return wrapBrowserWithStealth(browser);
+      } catch {
+        // fall through
+      }
+    }
     throw error;
   }
 }

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(() => {});
   }, []);