n9router 0.3.93 → 0.3.95

package/.next/standalone/mitm/tokenPool.js

@@ -14,9 +14,11 @@ const DB_FILE = path.join(DATA_DIR, "db.json");
 const TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1000; // refresh 5min before expiry
 const ROUTER_PORT = process.env.PORT || 20128;
 const DEFAULT_COOLDOWN_MS = 5 * 60 * 1000;
+const DEFAULT_AUTH_COOLDOWN_MS = 10 * 60 * 1000;
 
 // ── In-memory state ──────────────────────────────────────────
-const cooldownMap = {};        // { [connectionId]: expiresTimestamp }
+const cooldownMap = {};        // { [connectionId]: expiresTimestamp } quota/general cooldown
+const authCooldownMap = {};    // { [connectionId]: expiresTimestamp } invalid_token/auth cooldown
 const modelCooldownMap = {};   // { [connectionId]: { [model]: expiresTimestamp } }
 const rrState = {};            // { [provider]: roundRobinIndex }
 
@@ -28,13 +30,33 @@ function setCooldown(connId, durationMs) {
   log(`⏸ [token-pool] cooldown: ${connId.slice(0, 8)}… for ${Math.ceil(ms / 60000)}m`);
 }
 
-function isInCooldown(connId) {
-  if (!cooldownMap[connId]) return false;
-  if (Date.now() > cooldownMap[connId]) {
-    delete cooldownMap[connId];
-    return false;
+function setAuthCooldown(connId, durationMs) {
+  const ms = durationMs || DEFAULT_AUTH_COOLDOWN_MS;
+  authCooldownMap[connId] = Date.now() + ms;
+  log(`🔒 [token-pool] auth-cooldown: ${connId.slice(0, 8)}… for ${Math.ceil(ms / 60000)}m`);
+}
+
+function getMapExpiry(map, connId) {
+  if (!map[connId]) return 0;
+  if (Date.now() > map[connId]) {
+    delete map[connId];
+    return 0;
   }
-  return true;
+  return map[connId];
+}
+
+function getCooldownState(connId) {
+  const authExpiry = getMapExpiry(authCooldownMap, connId);
+  if (authExpiry) return { type: "auth", expiresAt: authExpiry };
+
+  const quotaExpiry = getMapExpiry(cooldownMap, connId);
+  if (quotaExpiry) return { type: "quota", expiresAt: quotaExpiry };
+
+  return null;
+}
+
+function isInCooldown(connId) {
+  return !!getCooldownState(connId);
 }
 
 // ── Per-model cooldown management ────────────────────────────
@@ -110,6 +132,90 @@ function getActiveConnections(provider) {
   } catch { return []; }
 }
 
+function getTokenSwapAvailabilitySummary(provider, model) {
+  try {
+    if (!fs.existsSync(DB_FILE)) {
+      return {
+        total: 0,
+        eligible: 0,
+        skipped: 0,
+        reasons: {},
+        summaryText: "0/0 account(s) eligible"
+      };
+    }
+
+    const db = JSON.parse(fs.readFileSync(DB_FILE, "utf-8"));
+    const connections = (db.providerConnections || []).filter(c => c.provider === provider);
+    const now = Date.now();
+    const strategy = getTokenSwapStrategy();
+    const reasons = {
+      inactive: 0,
+      noToken: 0,
+      expiredNoRefresh: 0,
+      quotaCooldown: 0,
+      authCooldown: 0,
+      modelCooldown: 0,
+    };
+
+    let eligible = 0;
+
+    for (const connection of connections) {
+      if (connection.isActive === false) {
+        reasons.inactive += 1;
+        continue;
+      }
+      if (!connection.accessToken) {
+        reasons.noToken += 1;
+        continue;
+      }
+      if (connection.expiresAt && new Date(connection.expiresAt).getTime() < now && !connection.refreshToken) {
+        reasons.expiredNoRefresh += 1;
+        continue;
+      }
+
+      const cooldownState = getCooldownState(connection.id);
+      if (cooldownState?.type === "auth") {
+        reasons.authCooldown += 1;
+        continue;
+      }
+      if (cooldownState?.type === "quota") {
+        reasons.quotaCooldown += 1;
+        continue;
+      }
+
+      if (strategy === "sticky" && model && isModelExhausted(connection.id, model)) {
+        reasons.modelCooldown += 1;
+        continue;
+      }
+
+      eligible += 1;
+    }
+
+    const skipped = connections.length - eligible;
+    const reasonParts = [];
+    if (reasons.quotaCooldown) reasonParts.push(`${reasons.quotaCooldown} quota cooldown`);
+    if (reasons.authCooldown) reasonParts.push(`${reasons.authCooldown} auth cooldown`);
+    if (reasons.modelCooldown) reasonParts.push(`${reasons.modelCooldown} model cooldown`);
+    if (reasons.inactive) reasonParts.push(`${reasons.inactive} inactive`);
+    if (reasons.noToken) reasonParts.push(`${reasons.noToken} missing token`);
+    if (reasons.expiredNoRefresh) reasonParts.push(`${reasons.expiredNoRefresh} expired-no-refresh`);
+
+    const summaryText = skipped > 0
+      ? `${eligible}/${connections.length} account(s) eligible, skipped ${skipped} (${reasonParts.join(", ")})`
+      : `${eligible}/${connections.length} account(s) eligible`;
+
+    return { total: connections.length, eligible, skipped, reasons, summaryText };
+  } catch {
+    return {
+      total: 0,
+      eligible: 0,
+      skipped: 0,
+      reasons: {},
+      summaryText: "0/0 account(s) eligible"
+    };
+  }
+}
+
 function getConnectionById(connId) {
   try {
     if (!fs.existsSync(DB_FILE)) return null;
@@ -287,41 +393,82 @@ function markAccountUsed(connId) {
 // checks expiry, refreshes token automatically, then returns the
 // latest persisted connection snapshot for the current request.
 
-async function triggerRefreshIfNeeded(connection) {
-  if (!connection?.expiresAt || !connection?.refreshToken) return connection;
-  const expiresAt = new Date(connection.expiresAt).getTime();
-  if (Date.now() + TOKEN_EXPIRY_BUFFER_MS < expiresAt) return connection;
-
-  log(`🔄 [token-pool] near-expiry refresh → ${getConnectionLabel(connection).slice(0, 20)}`);
+async function runConnectionTest(connection) {
   return await new Promise((resolve) => {
+    if (!connection?.id) {
+      resolve({ connection, refreshed: false, valid: false });
+      return;
+    }
+
+    let responseBody = "";
+
     try {
       const req = http.request(
         { hostname: "127.0.0.1", port: ROUTER_PORT, path: `/api/providers/${connection.id}/test`, method: "POST" },
         (res) => {
-          res.on("data", () => {});
+          res.on("data", (chunk) => {
+            responseBody += chunk.toString();
+          });
           res.on("end", () => {
-            const refreshed = getConnectionById(connection.id);
-            if (refreshed?.accessToken && refreshed.accessToken !== connection.accessToken) {
-              log(`♻️ [token-pool] refreshed token applied → ${getConnectionLabel(connection).slice(0, 20)}`);
+            let payload = {};
+            try {
+              payload = JSON.parse(responseBody || "{}");
+            } catch {
+              payload = {};
             }
-            resolve(refreshed || connection);
+
+            const refreshedConnection = getConnectionById(connection.id);
+            const tokenChanged = !!(refreshedConnection?.accessToken && refreshedConnection.accessToken !== connection.accessToken);
+            resolve({
+              connection: refreshedConnection || connection,
+              refreshed: !!payload.refreshed || tokenChanged,
+              valid: !!payload.valid,
+            });
           });
         }
       );
-      req.on("error", () => resolve(connection));
+      req.on("error", () => resolve({ connection, refreshed: false, valid: false }));
       req.end();
     } catch {
-      resolve(connection);
+      resolve({ connection, refreshed: false, valid: false });
     }
   });
 }
 
+async function triggerRefreshIfNeeded(connection) {
+  if (!connection?.expiresAt || !connection?.refreshToken) return connection;
+  const expiresAt = new Date(connection.expiresAt).getTime();
+  if (Date.now() + TOKEN_EXPIRY_BUFFER_MS < expiresAt) return connection;
+
+  log(`🔄 [token-pool] near-expiry refresh → ${getConnectionLabel(connection).slice(0, 20)}`);
+  const result = await runConnectionTest(connection);
+  if (result.refreshed) {
+    log(`♻️ [token-pool] refreshed token applied → ${getConnectionLabel(connection).slice(0, 20)}`);
+  }
+  return result.connection || connection;
+}
+
+async function forceRefreshConnection(connection) {
+  if (!connection?.refreshToken) {
+    return { connection, refreshed: false, valid: false };
+  }
+
+  log(`🔄 [token-pool] auth refresh → ${getConnectionLabel(connection).slice(0, 20)}`);
+  const result = await runConnectionTest(connection);
+  if (result.refreshed) {
+    log(`♻️ [token-pool] refreshed token applied → ${getConnectionLabel(connection).slice(0, 20)}`);
+  }
+  return result;
+}
+
 module.exports = {
   isTokenSwapEnabled,
   getNextConnection,
   getAllActiveConnections,
   triggerRefreshIfNeeded,
+  forceRefreshConnection,
   setCooldown,
+  setAuthCooldown,
   setModelCooldown,
   isModelExhausted,
   getTokenSwapStrategy,
@@ -329,4 +476,5 @@ module.exports = {
   markAccountUsed,
   getConnectionLabel,
   maskEmail,
+  getTokenSwapAvailabilitySummary,
 };

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "n9router",
-  "version": "0.3.93",
+  "version": "0.3.95",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "n9router",
-      "version": "0.3.93",
+      "version": "0.3.95",
       "license": "MIT",
       "dependencies": {
         "@monaco-editor/react": "^4.7.0",

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n9router",
-  "version": "0.3.93",
+  "version": "0.3.95",
   "description": "Self-hosted AI routing gateway — local proxy for Claude, Gemini, OpenAI and 40+ providers",
   "keywords": [
     "ai",

package/.next/standalone/plans/tauri-app/01-scope-and-architecture.md

@@ -0,0 +1,218 @@
+# Scope And Architecture
+
+## Scope
+
+### In scope
+
+- Antigravity OAuth and account import
+- project ID fetch/onboarding if needed by account validation or usage flows
+- MITM HTTPS server for Antigravity domains
+- DNS/hosts enable-disable for Antigravity
+- root certificate generation and trust flow
+- token swap across Antigravity accounts
+- usage persistence, logs, request detail capture
+- desktop-first UI for operating the above
+- cross-platform support for macOS, Windows, and Linux
+
+### Out of scope
+
+- generic AI router
+- upstream model aliasing outside MITM use case
+- generic provider CRUD for all existing providers
+- all `src/app/api/v1/*` compatibility APIs
+- cloud deployment and Workers support
+
+## Existing code to reuse
+
+### Core logic to preserve
+
+- Antigravity OAuth flow:
+  - `src/lib/oauth/services/antigravity.js`
+- MITM server:
+  - `src/mitm/server.js`
+  - `src/mitm/handlers/antigravity.js`
+  - `src/mitm/config.js`
+- token swap:
+  - `src/mitm/tokenPool.js`
+- usage capture:
+  - `src/mitm/usageTracker.js`
+  - `src/lib/usageDb.js`
+- settings and account persistence:
+  - `src/lib/localDb.js`
+- DNS and cert operations:
+  - `src/mitm/dns/dnsConfig.js`
+  - `src/mitm/cert/*`
+  - `src/mitm/manager.js`
+- account import from local Antigravity install:
+  - `src/app/api/antigravity-tools/import/route.js`
+
+### UI logic to mine and adapt
+
+- `src/app/(dashboard)/dashboard/mitm/MitmPageClient.js`
+- `src/app/(dashboard)/dashboard/usage/page.js`
+- `src/app/(dashboard)/dashboard/usage/components/RequestDetailsTab.js`
+- `src/app/(dashboard)/dashboard/usage/components/OverviewCards.js`
+- `src/shared/constants/cliTools.js`
+
+## Target workspace layout
+
+```text
+apps/
+  desktop-shell/        # Tauri
+  desktop-ui/           # React SPA
+  desktop-backend/      # Express service
+packages/
+  desktop-shared/       # API contracts, DTOs, constants
+plans/
+  tauri-app/
+```
+
+## Runtime boundaries
+
+### Tauri Rust owns
+
+- secure credential storage integration
+- privileged actions
+- backend process supervision
+- MITM sidecar process supervision if separate from backend
+- app data dir resolution
+- native menu, tray, startup behavior
+- platform adaptation for macOS, Windows, and Linux behaviors
+
+### Express backend owns
+
+- account storage
+- OAuth callback server or callback handling
+- account import and validation
+- MITM routing logic
+- token swap state machine
+- usage writes and reads
+- internal APIs called by usage observer
+
+### React UI owns
+
+- control plane only
+- polling/subscribing to backend status
+- visualization of pool state and usage data
+- no direct filesystem or privileged OS operations
+
+## Critical design decisions
+
+### 1. Keep MITM logic in JS for v1
+
+Reason:
+
+- existing behavior is already implemented
+- request interception and stream parsing are sensitive
+- product value comes from shipping the desktop app, not from rewriting stable logic
+
+### 2. Move OS privilege work out of Node
+
+Reason:
+
+- current Node code handles passwords and host mutations directly
+- desktop app should centralize privileged operations in Tauri
+- Tauri offers a cleaner UX for elevation prompts and secret handling
+
+### 3. Keep JSON persistence first
+
+Reason:
+
+- current code already uses `db.json`, `usage.json`, and `log.txt`
+- enough for a desktop MVP
+- storage migration to SQLite is a separate concern and should not block v1
+
+### 4. Design for cross-platform from day one
+
+Reason:
+
+- DNS and certificate flows are different on each OS
+- port 443 and elevation behavior differ across OSes
+- retrofitting Windows and Linux after a macOS-first implementation will create avoidable rework
+
+## Platform support requirements
+
+### Shared
+
+- same user-facing feature set on macOS, Windows, and Linux
+- same backend API contract across all OSes
+- same persistence format across all OSes
+- same token swap semantics across all OSes
+
+### macOS
+
+- support hosts-file mutation
+- support certificate trust flow
+- support DNS cache flush
+
+### Windows
+
+- support hosts-file mutation under elevated privileges
+- support certificate trust flow using Windows certificate store
+- support UAC-based elevation flow without requiring terminal usage
+
+### Linux
+
+- support hosts-file mutation on major desktop distros
+- support root certificate installation at least for the app-documented path
+- support DNS cache flush with distro-safe fallbacks
+- gracefully handle environments without `sudo`
+
+## Architecture diagram
+
+```mermaid
+flowchart LR
+  UI["React Desktop UI"] --> API["Local Express Backend"]
+  UI --> TAURI["Tauri Commands"]
+  TAURI --> OS["OS Cert / DNS / Secure Store"]
+  TAURI --> API
+  API --> DB["db.json / usage.json / log.txt"]
+  API --> MITM["MITM HTTPS Server"]
+  MITM --> AG["Antigravity Domains"]
+  MITM --> API
+```
+
+## MVP feature map
+
+### Accounts
+
+- list accounts
+- connect via browser OAuth
+- import from `~/.antigravity_tools`
+- enable/disable account
+- show token expiry and refresh availability
+
+### MITM
+
+- cert exists
+- cert trusted
+- server running
+- DNS active
+- health status
+- start/stop controls
+- platform-specific remediation text when a native action fails
+
+### Token swap
+
+- enable/disable
+- strategy selection
+- account pool table
+- cooldown visibility
+- auth failure visibility
+- last-used rotation indicator
+
+### Usage analyst
+
+- totals
+- recent requests
+- token totals
+- estimated cost
+- request details drawer
+- account-level and model-level filtering
+
+## Cross-platform acceptance criteria
+
+- the app can be packaged and launched on macOS, Windows, and Linux
+- backend startup path is identical from the UI perspective on all OSes
+- cert/DNS/MITM state is surfaced consistently on all OSes
+- platform-specific failure messages are understandable and actionable