zevairouter 1.0.70 → 1.0.73

package/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/package.json

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

package/package.json

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

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

@@ -437,15 +437,15 @@ export async function createFreshContext(browser, proxy) {
   }
 
   const page = await context.newPage();
-  // Residential proxies often hang on third-party trackers; abort so SPA can boot
+  // Abort third-party trackers only. Do NOT intercept "**/*" with continue() —
+  // Playwright route interception on every request breaks Google→Cognito OAuth
+  // redirect chains (consent 302 → idpresponse 302 → kiro:// Location is dropped
+  // and the main frame parks forever on empty SetSID).
   try {
-    await page.route("**/*", (route) => {
-      const u = route.request().url();
-      if (/googletagmanager|googleadservices|google-analytics|doubleclick|facebook\.net|hotjar|clarity\.ms|hm\.baidu|sentry\.io|browser\.sentry-cdn/i.test(u)) {
-        return route.abort();
-      }
-      return route.continue();
-    });
+    await page.route(
+      /googletagmanager|googleadservices|google-analytics|doubleclick|facebook\.net|hotjar|clarity\.ms|hm\.baidu|sentry\.io|browser\.sentry-cdn/i,
+      (route) => route.abort(),
+    );
   } catch {
     // ignore if route fails
   }