zevairouter 1.0.62 → 1.0.65

package/open-sse/config/kiroConstants.js

@@ -169,7 +169,7 @@ export function shouldExposeKiroReasoning(body) {
   const envSource = typeof process !== "undefined" ? process.env : {};
   const env = firstDefined(
     envSource.KIRO_EXPOSE_REASONING,
-    envSource.NINE_ROUTER_EXPOSE_REASONING
+    envSource.ZEVAI_EXPOSE_REASONING
   );
   const parsedEnv = parseBooleanLike(env);
   return parsedEnv === true;

package/package.json

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

package/src/app/landing/components/Features.js

@@ -104,9 +104,9 @@ export default function Features() {
     <section className="py-24 px-6" id="features">
       <div className="max-w-7xl mx-auto">
         <div className="mb-16">
-          <h2 className="text-3xl md:text-4xl font-bold mb-4">Powerful Features</h2>
+          <h2 className="text-3xl md:text-4xl font-bold mb-4">Features</h2>
           <p className="text-gray-400 max-w-xl text-lg">
-            Everything you need to manage your AI infrastructure in one place, built for scale.
+            Routing, dashboard, and tooling for the accounts you connect.
           </p>
         </div>
         

package/src/app/landing/components/HeroSection.js

@@ -21,7 +21,7 @@ export default function HeroSection() {
 
         {/* Description */}
         <p className="text-lg md:text-xl text-gray-400 max-w-2xl mx-auto font-light">
-          AI endpoint proxy with web dashboard - A JavaScript port of CLIProxyAPI. Works seamlessly with Claude Code, OpenAI Codex, Cline, RooCode, and other CLI tools.
+          Self-hosted AI router with a web dashboard. One OpenAI-compatible endpoint for Claude Code, Codex, Cline, Cursor, and similar tools.
         </p>
 
         {/* CTA Buttons */}

package/src/app/landing/components/HowItWorks.js

@@ -7,7 +7,7 @@ export default function HowItWorks() {
         <div className="mb-16">
           <h2 className="text-3xl md:text-4xl font-bold mb-4">How ZevaiRouter Works</h2>
           <p className="text-gray-400 max-w-xl text-lg">
-            Data flows seamlessly from your application through our intelligent routing layer to the best provider for the job.
+            Tools call one local endpoint. ZevaiRouter routes to the accounts you connected and can fall back when one hits a limit.
           </p>
         </div>
         
@@ -36,7 +36,7 @@ export default function HowItWorks() {
             <div>
               <h3 className="text-xl font-bold mb-2 text-[#f97815]">2. ZevaiRouter Hub</h3>
               <p className="text-sm text-gray-400">
-                Our engine analyzes the prompt, checks provider health, and routes for lowest latency or cost.
+                Routes to your connected providers using combos, strategies, and quota-aware fallback.
               </p>
             </div>
           </div>

package/src/app/landing/page.js

@@ -51,16 +51,16 @@ export default function LandingPage() {
         <section className="py-32 px-6 relative overflow-hidden">
           <div className="absolute inset-0 bg-linear-to-t from-[#f97815]/5 to-transparent pointer-events-none"></div>
           <div className="max-w-4xl mx-auto text-center relative z-10">
-            <h2 className="text-4xl md:text-5xl font-black mb-6">Ready to Simplify Your AI Infrastructure?</h2>
+            <h2 className="text-4xl md:text-5xl font-black mb-6">Open the dashboard</h2>
             <p className="text-xl text-gray-400 mb-10 max-w-2xl mx-auto">
-              Join developers who are streamlining their AI integrations with ZevaiRouter. Open source and free to start.
+              Self-hosted. Open source (MIT). Point your tools at <code className="text-sm text-gray-300">http://localhost:1997/v1</code>.
             </p>
             <div className="flex flex-col sm:flex-row items-center justify-center gap-4">
               <button 
                 onClick={() => router.push("/dashboard")}
                 className="w-full sm:w-auto h-14 px-10 rounded-lg bg-[#f97815] hover:bg-[#e0650a] text-[#181411] text-lg font-bold transition-all shadow-[0_0_20px_rgba(249,120,21,0.5)]"
               >
-                Start Free
+                Open dashboard
               </button>
               <button 
                 onClick={() => window.open("https://github.com/Verifiedlabs/zevairouter#readme", "_blank")}

package/src/lib/network/outboundProxy.js

@@ -3,24 +3,38 @@ function normalizeString(value) {
   return String(value).trim();
 }
 
+/** Env markers for managed outbound proxy (ZevaiRouter). */
+const MARK_MANAGED = "ZEVAI_PROXY_MANAGED";
+const MARK_URL = "ZEVAI_PROXY_URL";
+const MARK_NO_PROXY = "ZEVAI_NO_PROXY";
+
+function isManaged(env) {
+  return env[MARK_MANAGED] === "1";
+}
+
+function clearManagedMarkers(env) {
+  delete env[MARK_MANAGED];
+  delete env[MARK_URL];
+  delete env[MARK_NO_PROXY];
+}
+
 export function applyOutboundProxyEnv(
   { outboundProxyEnabled, outboundProxyUrl, outboundNoProxy } = {}
 ) {
   if (typeof process === "undefined" || !process.env) return;
+  const env = process.env;
   const enabled = Boolean(outboundProxyEnabled);
   const proxyUrl = normalizeString(outboundProxyUrl);
   const noProxy = normalizeString(outboundNoProxy);
 
   // If disabled, only clear env vars we previously managed.
   if (!enabled) {
-    if (process.env.NINE_ROUTER_PROXY_MANAGED === "1") {
-      delete process.env.HTTP_PROXY;
-      delete process.env.HTTPS_PROXY;
-      delete process.env.ALL_PROXY;
-      delete process.env.NO_PROXY;
-      delete process.env.NINE_ROUTER_PROXY_MANAGED;
-      delete process.env.NINE_ROUTER_PROXY_URL;
-      delete process.env.NINE_ROUTER_NO_PROXY;
+    if (isManaged(env)) {
+      delete env.HTTP_PROXY;
+      delete env.HTTPS_PROXY;
+      delete env.ALL_PROXY;
+      delete env.NO_PROXY;
+      clearManagedMarkers(env);
     }
     return;
   }
@@ -29,40 +43,40 @@ export function applyOutboundProxyEnv(
   // - If values are provided, write them and mark as managed
   // - If values are empty, do not touch externally-provided env,
   //   but do clear values we previously managed.
-  const wasManaged = process.env.NINE_ROUTER_PROXY_MANAGED === "1";
+  const wasManaged = isManaged(env);
   let managed = false;
 
   if (wasManaged) {
     if (!proxyUrl) {
-      delete process.env.HTTP_PROXY;
-      delete process.env.HTTPS_PROXY;
-      delete process.env.ALL_PROXY;
-      delete process.env.NINE_ROUTER_PROXY_URL;
+      delete env.HTTP_PROXY;
+      delete env.HTTPS_PROXY;
+      delete env.ALL_PROXY;
+      delete env[MARK_URL];
     }
     if (!noProxy) {
-      delete process.env.NO_PROXY;
-      delete process.env.NINE_ROUTER_NO_PROXY;
+      delete env.NO_PROXY;
+      delete env[MARK_NO_PROXY];
     }
   }
 
   if (proxyUrl) {
-    process.env.HTTP_PROXY = proxyUrl;
-    process.env.HTTPS_PROXY = proxyUrl;
-    process.env.ALL_PROXY = proxyUrl;
-    process.env.NINE_ROUTER_PROXY_URL = proxyUrl;
+    env.HTTP_PROXY = proxyUrl;
+    env.HTTPS_PROXY = proxyUrl;
+    env.ALL_PROXY = proxyUrl;
+    env[MARK_URL] = proxyUrl;
     managed = true;
   }
 
   if (noProxy) {
-    process.env.NO_PROXY = noProxy;
-    process.env.NINE_ROUTER_NO_PROXY = noProxy;
+    env.NO_PROXY = noProxy;
+    env[MARK_NO_PROXY] = noProxy;
     managed = true;
   }
 
   if (managed) {
-    process.env.NINE_ROUTER_PROXY_MANAGED = "1";
+    env[MARK_MANAGED] = "1";
   } else if (wasManaged) {
     // If we previously managed env but now cleared everything, drop the marker.
-    delete process.env.NINE_ROUTER_PROXY_MANAGED;
+    clearManagedMarkers(env);
   }
 }

package/src/lib/oauth/services/bulkImportBrowserEngine.js

@@ -91,7 +91,27 @@ function wrapBrowserWithStealth(browser) {
   return browser;
 }
 
+/**
+ * Headed engines (Camoufox / Chromium / CloakBrowser) need a display on Linux VPS.
+ * Auto-start Xvfb via displayEnv when available.
+ */
+async function ensureHeadedDisplayOrThrow() {
+  const { ensureDisplayForHeadedBrowser } = await import("./displayEnv.js");
+  const display = ensureDisplayForHeadedBrowser();
+  if (!display.ok) {
+    const err = display.error || new Error("No display for headed browser");
+    err.code = err.code || "NO_DISPLAY";
+    throw err;
+  }
+  return display;
+}
+
 async function launchChromium({ proxyUrl, headless = true, windowSize = null } = {}) {
+  const wantHeadless = headless !== false;
+  if (!wantHeadless) {
+    await ensureHeadedDisplayOrThrow();
+  }
+
   let chromium = null;
   let importErr = null;
   try {
@@ -130,10 +150,10 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
     throw friendly;
   }
 
-  const width = windowSize?.width || (headless ? 1920 : 900);
-  const height = windowSize?.height || (headless ? 1080 : 700);
+  const width = windowSize?.width || (wantHeadless ? 1920 : 900);
+  const height = windowSize?.height || (wantHeadless ? 1080 : 700);
   const options = {
-    headless: headless !== false,
+    headless: wantHeadless,
     args: [
       "--disable-blink-features=AutomationControlled",
       "--disable-features=IsolateOrigins,site-per-process,AutomationControlled",
@@ -149,7 +169,7 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
       "--password-store=basic",
       "--use-mock-keychain",
       `--window-size=${width},${height}`,
-      ...(headless ? [] : ["--window-position=80,80"]),
+      ...(wantHeadless ? [] : ["--window-position=80,80"]),
     ],
     ignoreDefaultArgs: ["--enable-automation"],
   };
@@ -158,15 +178,31 @@ async function launchChromium({ proxyUrl, headless = true, windowSize = null } =
     options.proxy = parsePlaywrightProxy(proxyUrl) || { server: proxyUrl };
   }
 
-  const browser = await chromium.launch(options);
-  return wrapBrowserWithStealth(browser);
+  try {
+    const browser = await chromium.launch(options);
+    return wrapBrowserWithStealth(browser);
+  } catch (error) {
+    const msg = String(error?.message || error || "");
+    if (!wantHeadless && /XServer|DISPLAY|Missing X server|headed browser|no DISPLAY/i.test(msg)) {
+      await ensureHeadedDisplayOrThrow();
+      const browser = await chromium.launch(options);
+      return wrapBrowserWithStealth(browser);
+    }
+    throw error;
+  }
 }
 
 async function launchCamoufox({ proxyUrl, headless = true, windowSize = null } = {}) {
+  // CodeBuddy CN bulk defaults to headed Camoufox — needs Xvfb on Linux VPS.
+  const useHeadless = headless !== false;
+  if (!useHeadless) {
+    await ensureHeadedDisplayOrThrow();
+  }
+
   const runtime = loadRuntimeHelper("camoufoxRuntime");
   if (!runtime?.ensureCamoufoxRuntime) {
     const err = new Error(
-      `Camoufox runtime helper missing. Reinstall z‍evairouter or pick the Chromium engine.`
+      `Camoufox runtime helper missing. Reinstall zevairouter or pick the Chromium engine.`
     );
     err.code = "CAMOUFOX_RUNTIME_HELPER_MISSING";
     throw err;
@@ -205,23 +241,131 @@ async function launchCamoufox({ proxyUrl, headless = true, windowSize = null } =
   // Context-only proxy is flaky (blank pages / half-sessions / 401 on console APIs).
   const { parsePlaywrightProxy } = await import("./proxyUtils.js");
   const parsedProxy = proxyUrl ? (parsePlaywrightProxy(proxyUrl) || { server: proxyUrl }) : null;
-  const useHeadless = headless !== false;
-  const camoufoxOptions = await camoufox.launchOptions({
-    headless: useHeadless,
-    ...(parsedProxy ? { proxy: parsedProxy, geoip: true } : {}),
-  });
-  const launchOptions = { ...camoufoxOptions, headless: useHeadless };
-  if (parsedProxy) {
-    launchOptions.proxy = parsedProxy;
-  }
-  // Small visible window for headed CN runs (server desktop)
-  if (!useHeadless) {
-    const width = windowSize?.width || 900;
-    const height = windowSize?.height || 700;
-    launchOptions.args = [...(launchOptions.args || []), `--width=${width}`, `--height=${height}`];
+
+  const buildLaunchOptions = async () => {
+    const camoufoxOptions = await camoufox.launchOptions({
+      headless: useHeadless,
+      ...(parsedProxy ? { proxy: parsedProxy, geoip: true } : {}),
+    });
+    // camoufox-js can emit fingerprint keys (e.g. audio:seed) that older Camoufox
+    // binaries reject → "Unknown property audio:seed in config". Always sanitize
+    // so Mac/Ubuntu users with a stale ~/.cache (or Library/Caches) still launch.
+    let opts = sanitizeCamoufoxLaunchOptions({
+      ...camoufoxOptions,
+      headless: useHeadless,
+    });
+    if (parsedProxy) opts.proxy = parsedProxy;
+    if (!useHeadless) {
+      const width = windowSize?.width || 900;
+      const height = windowSize?.height || 700;
+      opts.args = [...(opts.args || []), `--width=${width}`, `--height=${height}`];
+    }
+    return opts;
+  };
+
+  let launchOptions = await buildLaunchOptions();
+
+  const launchOnce = async (opts) => firefox.launch(opts);
+
+  try {
+    return await launchOnce(launchOptions);
+  } catch (error) {
+    const msg = String(error?.message || error || "");
+
+    // 1) Strip the exact unknown property the binary reported, retry.
+    const unknownProp = msg.match(/Unknown property\s+([^\s]+)\s+in config/i);
+    if (unknownProp?.[1]) {
+      try {
+        launchOptions = sanitizeCamoufoxLaunchOptions(launchOptions, {
+          extraDropKeys: [unknownProp[1]],
+        });
+        return await launchOnce(launchOptions);
+      } catch {
+        // continue to binary refresh
+      }
+    }
+
+    // 2) Config/fingerprint mismatch often means binary is older than camoufox-js.
+    //    Force-fetch the matching browser (Mac + Linux + Windows) and retry once.
+    if (/Unknown property|not described in this scheme|CAMOU_CONFIG|fingerprint/i.test(msg)) {
+      try {
+        if (typeof runtime.refreshCamoufoxBinary === "function") {
+          runtime.refreshCamoufoxBinary({ silent: false });
+        } else if (typeof runtime.ensureCamoufoxRuntime === "function") {
+          runtime.ensureCamoufoxRuntime({ silent: false, forceBinaryRefresh: true });
+        }
+        launchOptions = await buildLaunchOptions();
+        return await launchOnce(launchOptions);
+      } catch {
+        // fall through
+      }
+    }
+
+    if (!useHeadless && /XServer|DISPLAY|Missing X server|headed browser|no DISPLAY/i.test(msg)) {
+      await ensureHeadedDisplayOrThrow();
+      return launchOnce(launchOptions);
+    }
+    if (!useHeadless) {
+      const friendly = new Error(
+        `${msg}\n\nVPS has no display for headed Camoufox (CodeBuddy CN). Install then restart:\n` +
+          `  sudo apt-get update && sudo apt-get install -y xvfb\n` +
+          `  sudo systemctl restart zevairouter\n` +
+          `ZevaiRouter auto-starts Xvfb when installed.`
+      );
+      friendly.code = "NO_DISPLAY";
+      friendly.cause = error;
+      throw friendly;
+    }
+    throw error;
   }
+}
 
-  return firefox.launch(launchOptions);
+/**
+ * Remove fingerprint keys older Camoufox binaries do not understand.
+ * Keys are dropped from CAMOU_CONFIG* env JSON blobs produced by camoufox-js.
+ *
+ * Keep this conservative: drop known-bad families (audio:*) plus any keys the
+ * binary explicitly complained about. Do NOT strip the whole config.
+ */
+function sanitizeCamoufoxLaunchOptions(options = {}, { extraDropKeys = [] } = {}) {
+  const dropKeys = new Set([
+    "audio:seed",
+    "audio.seed",
+    "Audio:seed",
+    ...extraDropKeys.filter(Boolean),
+  ]);
+  if (!options?.env || typeof options.env !== "object") {
+    return options;
+  }
+  const env = { ...options.env };
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value !== "string") continue;
+    // CAMOU_CONFIG may be split across CAMOU_CONFIG_1, _2, ...
+    if (!/^CAMOU_CONFIG/i.test(key) && !/camou.*config/i.test(key)) continue;
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{")) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      let changed = false;
+      for (const drop of dropKeys) {
+        if (Object.prototype.hasOwnProperty.call(parsed, drop)) {
+          delete parsed[drop];
+          changed = true;
+        }
+      }
+      // Older binaries (pre-152) reject the whole audio:* family.
+      for (const k of Object.keys(parsed)) {
+        if (/^audio[:.]/i.test(k) || dropKeys.has(k)) {
+          delete parsed[k];
+          changed = true;
+        }
+      }
+      if (changed) env[key] = JSON.stringify(parsed);
+    } catch {
+      // leave non-JSON env alone
+    }
+  }
+  return { ...options, env };
 }
 
 /**
@@ -320,6 +464,59 @@ export async function launchBulkImportBrowser({
   return launchChromium({ proxyUrl, headless, windowSize });
 }
 
+/**
+ * Force-close a Playwright/Camoufox browser. Graceful close can hang forever when
+ * the browser is stuck on a blackholed proxy / spinning renderer — on a 2GB VPS
+ * that pins CPU until reboot. Always race close() with a kill of the process tree.
+ */
+export async function forceCloseBrowser(browser, { timeoutMs = 4_000 } = {}) {
+  if (!browser) return;
+
+  let pid = null;
+  try {
+    const proc = typeof browser.process === "function" ? browser.process() : null;
+    pid = proc?.pid || null;
+  } catch {
+    pid = null;
+  }
+
+  try {
+    await Promise.race([
+      Promise.resolve()
+        .then(() => browser.close())
+        .catch(() => null),
+      new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+  } catch {
+    // ignore
+  }
+
+  if (pid && Number.isFinite(pid) && pid > 1) {
+    // Still alive? SIGTERM then SIGKILL. Also try process-group kill (negative pid)
+    // so Camoufox helper children die with the parent.
+    for (const signal of ["SIGTERM", "SIGKILL"]) {
+      try {
+        process.kill(pid, 0); // throws ESRCH if gone
+      } catch {
+        break;
+      }
+      try {
+        process.kill(pid, signal);
+      } catch {
+        // ignore
+      }
+      try {
+        process.kill(-pid, signal);
+      } catch {
+        // ignore (no process group / permission)
+      }
+      if (signal === "SIGTERM") {
+        await new Promise((r) => setTimeout(r, 400));
+      }
+    }
+  }
+}
+
 export function makeBrowserLauncher({ engine, proxyUrl, headless = true, windowSize = null } = {}) {
   return () => launchBulkImportBrowser({ engine, proxyUrl, headless, windowSize });
 }