zevairouter 1.0.153 → 1.0.155

package/src/lib/updater/updater.js

@@ -1,327 +0,0 @@
-// Standalone detached updater process.
-// Spawns `npm i -g <pkg>@latest`, exposes progress via tiny HTTP server.
-// Survives after parent Next server exits (detached + unref by spawner).
-
-const { spawn } = require("child_process");
-const http = require("http");
-const net = require("net");
-const path = require("path");
-const fs = require("fs");
-const os = require("os");
-
-// 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);
-const retryDelayMs = parseInt(process.env.UPDATER_RETRY_DELAY_MS || "5000", 10);
-const lingerMs = parseInt(process.env.UPDATER_LINGER_MS || "30000", 10);
-const waitMinMs = parseInt(process.env.UPDATER_WAIT_MIN_MS || "3000", 10);
-const waitMaxMs = parseInt(process.env.UPDATER_WAIT_MAX_MS || "15000", 10);
-const waitCheckMs = parseInt(process.env.UPDATER_WAIT_CHECK_MS || "500", 10);
-const appPort = parseInt(process.env.UPDATER_APP_PORT || "1997", 10);
-
-// Data directory (match mitm/paths.js logic)
-function getDataDir() {
-  if (process.env.DATA_DIR) return process.env.DATA_DIR;
-  if (process.platform === "win32") {
-    return path.join(process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "zevai");
-  }
-  return path.join(os.homedir(), ".zevai");
-}
-const updateDir = path.join(getDataDir(), "update");
-try { fs.mkdirSync(updateDir, { recursive: true }); } catch { /* best effort */ }
-const statusFile = path.join(updateDir, "status.json");
-const logFile = path.join(updateDir, "install.log");
-
-const state = {
-  phase: "starting",
-  packageName,
-  startedAt: Date.now(),
-  finishedAt: null,
-  attempt: 0,
-  maxRetries,
-  done: false,
-  success: false,
-  exitCode: null,
-  error: null,
-  logTail: [],
-};
-
-function pushLog(line) {
-  const trimmed = line.replace(/\r?\n$/, "");
-  if (!trimmed) return;
-  state.logTail.push(trimmed);
-  if (state.logTail.length > tailLines) state.logTail = state.logTail.slice(-tailLines);
-  try { fs.appendFileSync(logFile, `${trimmed}\n`); } catch { /* best effort */ }
-}
-
-function persistStatus() {
-  try { fs.writeFileSync(statusFile, JSON.stringify(state, null, 2)); } catch { /* best effort */ }
-}
-
-function setPhase(phase) {
-  state.phase = phase;
-  persistStatus();
-}
-
-// HTTP server exposing status (browser polls this while Next server is dead)
-const server = http.createServer((req, res) => {
-  res.setHeader("Access-Control-Allow-Origin", "*");
-  res.setHeader("Cache-Control", "no-store");
-  if (req.url === "/update/status" || req.url === "/") {
-    res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify(state));
-    return;
-  }
-  res.statusCode = 404;
-  res.end("not found");
-});
-
-server.on("error", (e) => {
-  state.error = `status server error: ${e.message}`;
-  persistStatus();
-});
-
-server.listen(port, "127.0.0.1", () => {
-  persistStatus();
-  waitForAppExit().then(runInstall);
-});
-
-// Check if app port is still being listened on (= app server still alive)
-function isAppPortBusy() {
-  return new Promise((resolve) => {
-    const socket = new net.Socket();
-    const done = (busy) => {
-      socket.destroy();
-      resolve(busy);
-    };
-    socket.setTimeout(300);
-    socket.once("connect", () => done(true));
-    socket.once("timeout", () => done(false));
-    socket.once("error", () => done(false));
-    socket.connect(appPort, "127.0.0.1");
-  });
-}
-
-// Wait for app process to fully exit before running npm (avoids Windows file-lock)
-async function waitForAppExit() {
-  setPhase("waitingForExit");
-  pushLog(`[updater] waiting for app to exit (min ${Math.round(waitMinMs / 1000)}s)...`);
-
-  // Hard minimum delay: OS needs time to release file handles
-  await sleep(waitMinMs);
-
-  // Poll app port until free or max timeout
-  const deadline = Date.now() + (waitMaxMs - waitMinMs);
-  while (Date.now() < deadline) {
-    const busy = await isAppPortBusy();
-    if (!busy) {
-      pushLog(`[updater] app port :${appPort} is free, proceeding`);
-      return;
-    }
-    await sleep(waitCheckMs);
-  }
-  pushLog(`[updater] timeout waiting for app, proceeding anyway`);
-}
-
-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");
-  // 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 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 && !hook,
-    env: {
-      ...process.env,
-      npm_config_fund: "false",
-      npm_config_audit: "false",
-      npm_config_update_notifier: "false",
-    },
-  });
-
-  child.stdout.on("data", (buf) => {
-    buf.toString().split(/\r?\n/).forEach(pushLog);
-    persistStatus();
-  });
-  child.stderr.on("data", (buf) => {
-    buf.toString().split(/\r?\n/).forEach(pushLog);
-    persistStatus();
-  });
-
-  child.on("error", (e) => {
-    pushLog(`[updater] spawn error: ${e.message}`);
-    finalize(false, null, e.message);
-  });
-
-  child.on("close", (code) => {
-    pushLog(`[updater] install exited with code ${code}`);
-    if (code === 0) {
-      finalize(true, code, null);
-      return;
-    }
-    if (state.attempt < maxRetries) {
-      pushLog(`[updater] retrying in ${Math.round(retryDelayMs / 1000)}s...`);
-      setTimeout(runInstall, retryDelayMs);
-      return;
-    }
-    finalize(false, code, `Install failed after ${maxRetries} attempts`);
-  });
-}
-
-function openBrowser(url) {
-  const platform = process.platform;
-  const cmd = platform === "darwin" ? `open "${url}"`
-    : platform === "win32" ? `start "" "${url}"`
-    : `xdg-open "${url}"`;
-  try { spawn(cmd, { shell: true, detached: true, stdio: "ignore" }).unref(); } catch { /* ignore */ }
-}
-
-// Wait until app port is listening (server alive again), then open dashboard
-async function waitForAppAndOpenBrowser() {
-  const deadline = Date.now() + 30000;
-  while (Date.now() < deadline) {
-    const busy = await isAppPortBusy();
-    if (busy) {
-      openBrowser(`http://localhost:${appPort}/dashboard`);
-      pushLog(`[updater] app ready, opened dashboard`);
-      return;
-    }
-    await sleep(1000);
-  }
-  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 = [];
-  try { args = JSON.parse(process.env.UPDATER_RELAUNCH_ARGS || "[]"); } catch { /* noop */ }
-  const isWin = process.platform === "win32";
-  try {
-    const child = spawn(cmd, args, {
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-      shell: isWin,
-      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})`);
-    waitForAppAndOpenBrowser();
-  } catch (e) {
-    pushLog(`[updater] relaunch failed: ${e.message}`);
-  }
-}
-
-function finalize(success, exitCode, error) {
-  state.done = true;
-  state.success = success;
-  state.exitCode = exitCode;
-  state.error = error;
-  state.finishedAt = Date.now();
-  setPhase(success ? "done" : "error");
-  if (success) relaunchApp();
-  // Linger so browser can poll final status, then exit & close the port
-  setTimeout(() => {
-    try { server.close(); } catch { /* ignore */ }
-    process.exit(success ? 0 : 1);
-  }, lingerMs);
-}

package/src/lib/usage/fetcher.js

@@ -1,208 +0,0 @@
-/**
- * Usage Fetcher - Get usage data from provider APIs
- */
-
-import { GITHUB_CONFIG, GEMINI_CONFIG, ANTIGRAVITY_CONFIG } from "@/lib/oauth/constants/oauth";
-
-/**
- * Get usage data for a provider connection
- * @param {Object} connection - Provider connection with accessToken
- * @returns {Object} Usage data with quotas
- */
-export async function getUsageForProvider(connection) {
-  const { provider, accessToken, providerSpecificData } = connection;
-
-  switch (provider) {
-    case "github":
-      return await getGitHubUsage(accessToken, providerSpecificData);
-    case "gemini-cli":
-      return await getGeminiUsage(accessToken);
-    case "antigravity":
-      return await getAntigravityUsage(accessToken);
-    case "claude":
-      return await getClaudeUsage(accessToken);
-    case "codex":
-      return await getCodexUsage(accessToken);
-    case "qwen":
-      return await getQwenUsage(accessToken, providerSpecificData);
-    case "iflow":
-      return await getIflowUsage(accessToken);
-    default:
-      return { message: `Usage API not implemented for ${provider}` };
-  }
-}
-
-/**
- * GitHub Copilot Usage
- */
-async function getGitHubUsage(accessToken, providerSpecificData) {
-  try {
-    // Use copilotToken for copilot_internal API, not GitHub OAuth accessToken
-    const copilotToken = providerSpecificData?.copilotToken;
-    if (!copilotToken) {
-      throw new Error("Copilot token not found. Please refresh token first.");
-    }
-
-    const response = await fetch("https://api.github.com/copilot_internal/user", {
-      headers: {
-        Authorization: `Bearer ${copilotToken}`,
-        Accept: "application/json",
-        "X-GitHub-Api-Version": GITHUB_CONFIG.apiVersion,
-        "User-Agent": GITHUB_CONFIG.userAgent,
-      },
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`GitHub API error: ${error}`);
-    }
-
-    const data = await response.json();
-
-    // Handle different response formats (paid vs free)
-    if (data.quota_snapshots) {
-      // Paid plan format
-      const snapshots = data.quota_snapshots;
-      return {
-        plan: data.copilot_plan,
-        resetDate: data.quota_reset_date,
-        quotas: {
-          chat: formatGitHubQuotaSnapshot(snapshots.chat),
-          completions: formatGitHubQuotaSnapshot(snapshots.completions),
-          premium_interactions: formatGitHubQuotaSnapshot(snapshots.premium_interactions),
-        },
-      };
-    } else if (data.monthly_quotas || data.limited_user_quotas) {
-      // Free/limited plan format
-      const monthlyQuotas = data.monthly_quotas || {};
-      const usedQuotas = data.limited_user_quotas || {};
-      
-      return {
-        plan: data.copilot_plan || data.access_type_sku,
-        resetDate: data.limited_user_reset_date,
-        quotas: {
-          chat: {
-            used: usedQuotas.chat || 0,
-            total: monthlyQuotas.chat || 0,
-            unlimited: false,
-          },
-          completions: {
-            used: usedQuotas.completions || 0,
-            total: monthlyQuotas.completions || 0,
-            unlimited: false,
-          },
-        },
-      };
-    }
-
-    return { message: "GitHub Copilot connected. Unable to parse quota data." };
-  } catch (error) {
-    throw new Error(`Failed to fetch GitHub usage: ${error.message}`);
-  }
-}
-
-function formatGitHubQuotaSnapshot(quota) {
-  if (!quota) return { used: 0, total: 0, unlimited: true };
-  
-  return {
-    used: quota.entitlement - quota.remaining,
-    total: quota.entitlement,
-    remaining: quota.remaining,
-    unlimited: quota.unlimited || false,
-  };
-}
-
-/**
- * Gemini CLI Usage (Google Cloud)
- */
-async function getGeminiUsage(accessToken) {
-  try {
-    // Gemini CLI uses Google Cloud quotas
-    // Try to get quota info from Cloud Resource Manager
-    const response = await fetch(
-      "https://cloudresourcemanager.googleapis.com/v1/projects?filter=lifecycleState:ACTIVE",
-      {
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          Accept: "application/json",
-        },
-      }
-    );
-
-    if (!response.ok) {
-      // Quota API may not be accessible, return generic message
-      return { message: "Gemini CLI uses Google Cloud quotas. Check Google Cloud Console for details." };
-    }
-
-    return { message: "Gemini CLI connected. Usage tracked via Google Cloud Console." };
-  } catch (error) {
-    return { message: "Unable to fetch Gemini usage. Check Google Cloud Console." };
-  }
-}
-
-/**
- * Antigravity Usage
- */
-async function getAntigravityUsage(accessToken) {
-  try {
-    // Similar to Gemini, uses Google Cloud
-    return { message: "Antigravity connected. Usage tracked via Google Cloud Console." };
-  } catch (error) {
-    return { message: "Unable to fetch Antigravity usage." };
-  }
-}
-
-/**
- * Claude Usage
- */
-async function getClaudeUsage(accessToken) {
-  try {
-    // Claude OAuth doesn't expose usage API directly
-    // Could potentially check via inference endpoint
-    return { message: "Claude connected. Usage tracked per request." };
-  } catch (error) {
-    return { message: "Unable to fetch Claude usage." };
-  }
-}
-
-/**
- * Codex (OpenAI) Usage
- */
-async function getCodexUsage(accessToken) {
-  try {
-    // OpenAI usage requires organization API access
-    return { message: "Codex connected. Check OpenAI dashboard for usage." };
-  } catch (error) {
-    return { message: "Unable to fetch Codex usage." };
-  }
-}
-
-/**
- * Qwen Usage
- */
-async function getQwenUsage(accessToken, providerSpecificData) {
-  try {
-    const resourceUrl = providerSpecificData?.resourceUrl;
-    if (!resourceUrl) {
-      return { message: "Qwen connected. No resource URL available." };
-    }
-
-    // Qwen may have usage endpoint at resource URL
-    return { message: "Qwen connected. Usage tracked per request." };
-  } catch (error) {
-    return { message: "Unable to fetch Qwen usage." };
-  }
-}
-
-/**
- * iFlow Usage
- */
-async function getIflowUsage(accessToken) {
-  try {
-    // iFlow may have usage endpoint
-    return { message: "iFlow connected. Usage tracked per request." };
-  } catch (error) {
-    return { message: "Unable to fetch iFlow usage." };
-  }
-}
-

package/src/lib/usage/quotaRefresh.js

@@ -1,71 +0,0 @@
-// Background quota refresh loop.
-//
-// Periodically snapshots each active, usage-eligible connection's upstream quota
-// into the server-side quota cache (quotaCache table) so request routing can read
-// remaining quota synchronously. Requests are staggered to avoid a burst of
-// upstream calls. Guarded via globalThis so Next.js hot-reload / multiple imports
-// don't start duplicate loops.
-
-import { getProviderConnections } from "@/lib/localDb";
-import { resolveUsageForConnection, isUsageEligible } from "./quotaService.js";
-
-const REFRESH_INTERVAL_MS = 5 * 60 * 1000; // full sweep cadence per connection
-const STAGGER_MS = 4 * 1000;               // gap between connections in a sweep
-const MIN_START_DELAY_MS = 15 * 1000;      // let the server settle before first sweep
-
-if (!globalThis._quotaRefreshState) {
-  globalThis._quotaRefreshState = { started: false, startTimer: null, timer: null, running: false };
-}
-const state = globalThis._quotaRefreshState;
-
-async function sweepOnce() {
-  if (state.running) return;
-  state.running = true;
-  try {
-    let connections = [];
-    try {
-      connections = await getProviderConnections({ isActive: true });
-    } catch (e) {
-      console.warn(`[QuotaRefresh] failed to list connections: ${e.message}`);
-      return;
-    }
-    const eligible = connections.filter(isUsageEligible);
-    for (const conn of eligible) {
-      try {
-        await resolveUsageForConnection(conn.id, { writeCache: true });
-      } catch (e) {
-        console.warn(`[QuotaRefresh] ${conn.provider}/${conn.id}: ${e.message}`);
-      }
-      // Stagger to avoid hammering upstreams all at once.
-      await new Promise((r) => setTimeout(r, STAGGER_MS));
-    }
-  } finally {
-    state.running = false;
-  }
-}
-
-/** Start the background loop once per process. Safe to call repeatedly. */
-export function startQuotaRefreshLoop() {
-  if (state.started) return;
-  state.started = true;
-  state.startTimer = setTimeout(() => {
-    state.startTimer = null;
-    void sweepOnce();
-    state.timer = setInterval(() => void sweepOnce(), REFRESH_INTERVAL_MS);
-    if (state.timer.unref) state.timer.unref();
-  }, MIN_START_DELAY_MS);
-  if (state.startTimer.unref) state.startTimer.unref();
-}
-
-export function stopQuotaRefreshLoop() {
-  if (state.startTimer) clearTimeout(state.startTimer);
-  if (state.timer) clearInterval(state.timer);
-  state.startTimer = null;
-  state.timer = null;
-  state.started = false;
-}
-
-/** Trigger an immediate one-off sweep (fire-and-forget). */
-export function refreshQuotaNow() {
-  void sweepOnce();
-}