wyxrouter 0.4.71

package/src/lib/updater/updater.js

@@ -0,0 +1,235 @@
+// 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");
+
+const packageName = process.env.UPDATER_PKG_NAME || "9router";
+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 || "20128", 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"), "9router");
+  }
+  return path.join(os.homedir(), ".9router");
+}
+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 runInstall() {
+  state.attempt += 1;
+  setPhase("installing");
+  pushLog(`[updater] attempt ${state.attempt}/${maxRetries} — npm i -g ${packageName} --prefer-online`);
+
+  const isWin = process.platform === "win32";
+  const cmd = isWin ? "npm.cmd" : "npm";
+  const args = ["i", "-g", packageName, "--prefer-online"];
+
+  const child = spawn(cmd, args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+    shell: isWin,
+  });
+
+  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] npm 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 relaunchApp() {
+  if (process.env.UPDATER_RELAUNCH !== "1") 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: "" },
+    });
+    child.unref();
+    pushLog(`[updater] relaunched: ${cmd} ${args.join(" ")} (pid=${child.pid})`);
+    // Wait for new app to come up, then auto-open browser so user sees the result
+    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

@@ -0,0 +1,208 @@
+/**
+ * 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/usageDb.js

@@ -0,0 +1,7 @@
+// Shim → re-export from new SQLite-based DB layer (src/lib/db/)
+export {
+  statsEmitter, trackPendingRequest, getActiveRequests,
+  saveRequestUsage, getUsageHistory, getUsageStats, getChartData,
+  appendRequestLog, getRecentLogs,
+  saveRequestDetail, getRequestDetails, getRequestDetailById,
+} from "@/lib/db/index.js";

package/src/mitm/antigravityIdeVersion.js

@@ -0,0 +1,50 @@
+"use strict";
+
+// Rewrite Antigravity IDE markers so upstream AG 2.x backend accepts the request.
+// User-Agent header (antigravity/<old>) and body.metadata.ideVersion are forced
+// to a known-good IDE version. Hardcoded MVP — toggle/version configurable later.
+
+const ANTIGRAVITY_IDE_VERSION = "1.23.2";
+const ANTIGRAVITY_IDE_VERSION_OVERRIDE_ENABLED = true;
+
+function shouldRewriteMetadata(metadata) {
+  if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return false;
+  if (String(metadata.ideName || "").toLowerCase() === "antigravity") return true;
+  if (String(metadata.ideType || "").toUpperCase() === "ANTIGRAVITY") return true;
+  return Object.prototype.hasOwnProperty.call(metadata, "ideVersion");
+}
+
+function rewriteAntigravityUserAgent(userAgent, version) {
+  if (typeof userAgent !== "string" || !userAgent.includes("antigravity/")) return userAgent;
+  return userAgent.replace(/antigravity\/[^\s]+/, `antigravity/${version}`);
+}
+
+function applyAntigravityIdeVersionOverride(bodyBuffer, headers) {
+  if (!ANTIGRAVITY_IDE_VERSION_OVERRIDE_ENABLED) {
+    return { bodyBuffer, headers, applied: false, version: ANTIGRAVITY_IDE_VERSION };
+  }
+
+  const nextHeaders = { ...headers };
+  const nextUserAgent = rewriteAntigravityUserAgent(nextHeaders["user-agent"], ANTIGRAVITY_IDE_VERSION);
+  const userAgentChanged = nextUserAgent !== nextHeaders["user-agent"];
+  if (userAgentChanged) nextHeaders["user-agent"] = nextUserAgent;
+
+  try {
+    const parsed = JSON.parse(bodyBuffer.toString());
+    if (!shouldRewriteMetadata(parsed?.metadata)) {
+      return { bodyBuffer, headers: nextHeaders, applied: userAgentChanged, version: ANTIGRAVITY_IDE_VERSION };
+    }
+
+    parsed.metadata.ideVersion = ANTIGRAVITY_IDE_VERSION;
+    const nextBodyBuffer = Buffer.from(JSON.stringify(parsed));
+    return { bodyBuffer: nextBodyBuffer, headers: nextHeaders, applied: true, version: ANTIGRAVITY_IDE_VERSION };
+  } catch {
+    return { bodyBuffer, headers: nextHeaders, applied: userAgentChanged, version: ANTIGRAVITY_IDE_VERSION };
+  }
+}
+
+module.exports = {
+  ANTIGRAVITY_IDE_VERSION,
+  applyAntigravityIdeVersionOverride,
+  rewriteAntigravityUserAgent,
+};

package/src/mitm/cert/generate.js

@@ -0,0 +1,32 @@
+const path = require("path");
+const fs = require("fs");
+const { MITM_DIR } = require("../paths");
+const { generateRootCA, loadRootCA, generateLeafCert } = require("./rootCA");
+
+/**
+ * Generate Root CA certificate (one-time setup)
+ * This replaces the old static wildcard cert approach
+ */
+async function generateCert() {
+  return await generateRootCA();
+}
+
+/**
+ * Get certificate for a specific domain (dynamic generation)
+ * Used by SNICallback in server.js
+ */
+function getCertForDomain(domain) {
+  try {
+    const rootCA = loadRootCA();
+    const leafCert = generateLeafCert(domain, rootCA);
+    return {
+      key: leafCert.key,
+      cert: leafCert.cert
+    };
+  } catch (error) {
+    console.error(`Failed to generate cert for ${domain}:`, error.message);
+    return null;
+  }
+}
+
+module.exports = { generateCert, getCertForDomain };