n9router 0.3.93 → 0.3.95

package/.next/standalone/plans/tauri-app/05-delivery-phases.md

@@ -0,0 +1,171 @@
+# Delivery Phases
+
+## Phase 0: Setup
+
+Goals:
+
+- create app workspace structure
+- choose package manager and monorepo layout
+- define TypeScript, lint, and build conventions
+- define target OS matrix: macOS, Windows, Linux
+
+Tasks:
+
+- add `apps/desktop-shell`
+- add `apps/desktop-ui`
+- add `apps/desktop-backend`
+- add `packages/desktop-shared`
+- define ports, app data path, and env conventions
+- define platform support policy and supported Linux baseline
+
+Exit criteria:
+
+- all three apps boot locally in dev mode
+
+## Phase 1: Backend extraction
+
+Goals:
+
+- standalone local service without Next.js
+
+Tasks:
+
+- port `localDb`
+- port `usageDb`
+- add Express app and health endpoint
+- port Antigravity account service
+- port account import
+- port usage APIs
+
+Exit criteria:
+
+- backend can manage accounts and serve usage data from existing files
+
+## Phase 2: MITM service
+
+Goals:
+
+- functional Antigravity interception under backend control
+
+Tasks:
+
+- extract MITM server and manager logic
+- adapt internal usage and request detail ingestion
+- preserve host/path matching logic
+- preserve model alias routing for MITM if still required
+- separate platform-specific cert/DNS behavior from backend-owned MITM logic
+
+Exit criteria:
+
+- backend can start MITM and capture Antigravity usage
+
+## Phase 3: Native integration
+
+Goals:
+
+- move privileged operations into Tauri
+
+Tasks:
+
+- backend process supervision
+- cert trust command
+- DNS enable/disable command
+- secret storage integration
+- health plumbing between shell and backend
+- implement and verify flows on macOS, Windows, and Linux
+
+Exit criteria:
+
+- desktop app can control backend and OS operations from native commands
+- supported OS matrix passes smoke tests
+
+## Phase 4: UI MVP
+
+Goals:
+
+- first usable desktop product
+
+Tasks:
+
+- build accounts page
+- build MITM page
+- build token swap page
+- build usage page
+- add loading/error/status states
+
+Exit criteria:
+
+- user can operate the full Antigravity MITM flow from the desktop app
+
+## Phase 5: Hardening
+
+Goals:
+
+- make the app stable enough for daily use
+
+Tasks:
+
+- crash recovery
+- retry and restart policies
+- clearer error messaging
+- account pool edge-case handling
+- better logs and diagnostics
+- platform-specific QA and packaging fixes
+
+Exit criteria:
+
+- app survives common failures without manual cleanup
+
+## Suggested implementation order inside each phase
+
+1. extract minimal working path
+2. add tests for behavior already present in current app
+3. add UI affordances only after backend/native behavior is real
+4. avoid storage migration until feature parity is stable
+
+## Testing strategy
+
+### Automated
+
+- unit tests for token pool
+- unit tests for usage aggregation
+- integration tests for backend APIs
+- smoke tests for Tauri commands where feasible
+
+### Manual
+
+- connect one account and intercept traffic
+- connect multiple accounts and verify token rotation
+- exhaust one account and verify cooldown behavior
+- break cert/DNS state and verify UI diagnosis
+- repeat the same smoke flows on macOS, Windows, and Linux
+
+## OS matrix
+
+### Required for v1
+
+- macOS
+- Windows
+- Linux
+
+### Linux baseline
+
+- pick one supported baseline distro for v1, preferably Ubuntu LTS
+- document other distros as best effort until explicitly validated
+
+## Main project risks
+
+- OS privilege behavior
+- port 443 conflicts
+- cert trust differences by OS
+- race conditions in file-backed persistence
+- accidental coupling to old Next.js imports
+
+## Completion checklist
+
+- backend no longer depends on Next.js
+- desktop shell controls backend lifecycle
+- privileged actions no longer depend on React or browser APIs
+- Antigravity MITM works on supported OS targets
+- token swap and usage analyst are visible and operable in the desktop UI
+- macOS, Windows, and Linux each have validated first-run and normal-run flows

package/.next/standalone/plans/tauri-app/README.md

@@ -0,0 +1,87 @@
+# Tauri App Implementation Plan
+
+This plan defines the desktop implementation target for a focused Antigravity tool, not a full 9Router port.
+
+Target desktop OS support for v1:
+
+- macOS
+- Windows
+- Linux
+
+## Product goal
+
+Build a desktop app with:
+
+- Antigravity account management
+- Antigravity MITM proxy
+- DNS/hosts toggling for Antigravity domains
+- multi-account token swap for Antigravity
+- usage analytics and request details for MITM traffic
+
+Out of scope for v1:
+
+- `/v1/chat/completions`
+- OpenAI-compatible routing
+- multi-provider routing gateway
+- combo/fallback model router
+- cloud worker and tunnel features
+- non-Antigravity MITM tools
+
+## Deliverables
+
+- `apps/desktop-shell`: Tauri app shell and native commands
+- `apps/desktop-ui`: React desktop UI
+- `apps/desktop-backend`: local Express service
+- `packages/desktop-shared`: shared types, constants, API contracts
+- migration docs and test plan
+
+## Recommended architecture
+
+- Tauri Rust:
+  - app lifecycle
+  - secure storage
+  - privilege escalation boundary
+  - cert trust/untrust
+  - DNS/hosts mutation
+  - process supervision for backend/MITM
+- React UI:
+  - accounts screen
+  - MITM/DNS screen
+  - token swap screen
+  - usage and request details screens
+- Express backend:
+  - Antigravity OAuth/import
+  - persistence
+  - token pool logic
+  - MITM HTTPS server
+  - usage ingestion and query APIs
+
+## Why this split
+
+The hardest domain logic already exists in JS and should be preserved first:
+
+- MITM server: `src/mitm/server.js`
+- token pool: `src/mitm/tokenPool.js`
+- usage capture: `src/mitm/usageTracker.js`
+- Antigravity OAuth: `src/lib/oauth/services/antigravity.js`
+- local persistence: `src/lib/localDb.js`, `src/lib/usageDb.js`
+
+The native-only work is OS integration, not request routing. Rewriting MITM/token swap in Rust first would add risk without product value.
+
+## Plan set
+
+- [01-scope-and-architecture.md](/Users/cuongquach/projects/vibe/n9router/plans/tauri-app/01-scope-and-architecture.md)
+- [02-backend-plan.md](/Users/cuongquach/projects/vibe/n9router/plans/tauri-app/02-backend-plan.md)
+- [03-tauri-native-plan.md](/Users/cuongquach/projects/vibe/n9router/plans/tauri-app/03-tauri-native-plan.md)
+- [04-react-ui-plan.md](/Users/cuongquach/projects/vibe/n9router/plans/tauri-app/04-react-ui-plan.md)
+- [05-delivery-phases.md](/Users/cuongquach/projects/vibe/n9router/plans/tauri-app/05-delivery-phases.md)
+
+## Success criteria
+
+- user can connect one or more Antigravity accounts
+- app can trust local cert and toggle Antigravity DNS entries
+- MITM can intercept Antigravity traffic reliably
+- token swap rotates accounts and handles quota/auth cooldowns
+- usage screens show recent requests, token usage, and request details
+- desktop app can be packaged and started without Next.js
+- the same core flows work on macOS, Windows, and Linux with platform-appropriate elevation and diagnostics

package/.next/standalone/src/mitm/server.js

@@ -7,8 +7,8 @@ const { log, err } = require("./logger");
 const { TARGET_HOSTS, URL_PATTERNS, getToolForHost } = require("./config");
 const { DATA_DIR, MITM_DIR } = require("./paths");
 const { isTokenSwapEnabled, getAllActiveConnections, triggerRefreshIfNeeded,
-        setCooldown, setModelCooldown, getTokenSwapStrategy,
-        parseQuotaCooldown, markAccountUsed, getConnectionLabel } = require("./tokenPool");
+        forceRefreshConnection, setCooldown, setAuthCooldown, setModelCooldown, getTokenSwapStrategy,
+        parseQuotaCooldown, markAccountUsed, getConnectionLabel, getTokenSwapAvailabilitySummary } = require("./tokenPool");
 const { getCertForDomain } = require("./cert/generate");
 const { buildInputOnlyRequestDetail, createTokenSwapUsageObserver, generateDetailId } = require("./usageTracker");
 
@@ -187,120 +187,144 @@ async function tokenSwapForward(req, res, bodyBuffer, connections, model, strate
 
   for (let i = 0; i < connections.length; i++) {
     const originalConn = connections[i];
-    const conn = await triggerRefreshIfNeeded(originalConn);
-
-    const label = getConnectionLabel(conn);
-    const modelTag = model ? ` model=${model}` : "";
-    const posTag = connections.length > 1 ? ` [${i + 1}/${connections.length}]` : "";
-    const useTag = conn.consecutiveUseCount > 1 ? ` uses=${conn.consecutiveUseCount}` : "";
-    log(`🔑 [token-swap]${posTag} trying "${label}"${modelTag}${useTag}`);
-
-    const swappedHeaders = {
-      ...req.headers,
-      host: targetHost,
-      authorization: `Bearer ${conn.accessToken}`
-    };
-
-    try {
-      const result = await new Promise((resolve, reject) => {
-        const forwardReq = https.request({
-          hostname: targetIP,
-          port: 443,
-          path: req.url,
-          method: req.method,
-          headers: swappedHeaders,
-          servername: targetHost,
-          rejectUnauthorized: false
-        }, (forwardRes) => {
-          if (forwardRes.statusCode === 429 || forwardRes.statusCode === 503) {
-            // Buffer the short error body to parse cooldown duration
-            const chunks = [];
-            forwardRes.on("data", c => chunks.push(c));
-            forwardRes.on("end", () => {
-              const body = Buffer.concat(chunks).toString();
-              resolve({ retry: true, body, statusCode: forwardRes.statusCode });
-            });
+    let conn = await triggerRefreshIfNeeded(originalConn);
+    let authRefreshAttempted = false;
+
+    while (true) {
+      const label = getConnectionLabel(conn);
+      const modelTag = model ? ` model=${model}` : "";
+      const posTag = connections.length > 1 ? ` [${i + 1}/${connections.length}]` : "";
+      const useTag = conn.consecutiveUseCount > 1 ? ` uses=${conn.consecutiveUseCount}` : "";
+      log(`🔑 [token-swap]${posTag} trying "${label}"${modelTag}${useTag}`);
+
+      const swappedHeaders = {
+        ...req.headers,
+        host: targetHost,
+        authorization: `Bearer ${conn.accessToken}`
+      };
+
+      try {
+        const result = await new Promise((resolve, reject) => {
+          const forwardReq = https.request({
+            hostname: targetIP,
+            port: 443,
+            path: req.url,
+            method: req.method,
+            headers: swappedHeaders,
+            servername: targetHost,
+            rejectUnauthorized: false
+          }, (forwardRes) => {
+            if (forwardRes.statusCode === 429 || forwardRes.statusCode === 503 || forwardRes.statusCode === 401) {
+              const chunks = [];
+              forwardRes.on("data", c => chunks.push(c));
+              forwardRes.on("end", () => {
+                const body = Buffer.concat(chunks).toString();
+                const retryType = forwardRes.statusCode === 401 ? "auth" : "quota";
+                resolve({ retry: true, retryType, body, headers: forwardRes.headers, statusCode: forwardRes.statusCode });
+              });
+            } else {
+              resolve({ retry: false, response: forwardRes });
+            }
+          });
+          forwardReq.on("error", reject);
+          if (bodyBuffer.length > 0) forwardReq.write(bodyBuffer);
+          forwardReq.end();
+        });
+
+        if (result.retry && result.retryType === "quota") {
+          const cooldownMs = parseQuotaCooldown(result.body);
+          const cdLabel = cooldownMs ? ` cooldown=${Math.ceil(cooldownMs / 60000)}m` : "";
+          if (strategy === "sticky" && model) {
+            setModelCooldown(conn.id, model, cooldownMs);
+            log(`⚠️ [token-swap] "${label}" → ${result.statusCode} model=${model} quota exhausted${cdLabel}, trying next...`);
           } else {
-            // Success or non-quota error → pipe to client
-            resolve({ retry: false, response: forwardRes });
+            setCooldown(conn.id, cooldownMs);
+            log(`⚠️ [token-swap] "${label}" → ${result.statusCode} account quota exhausted${cdLabel}, trying next...`);
           }
-        });
-        forwardReq.on("error", reject);
-        if (bodyBuffer.length > 0) forwardReq.write(bodyBuffer);
-        forwardReq.end();
-      });
-
-      if (result.retry) {
-        const cooldownMs = parseQuotaCooldown(result.body);
-        const cdLabel = cooldownMs ? ` cooldown=${Math.ceil(cooldownMs / 60000)}m` : "";
-        if (strategy === "sticky" && model) {
-          // Sticky: mark only this account+model as exhausted, not the whole account
-          setModelCooldown(conn.id, model, cooldownMs);
-          log(`⚠️ [token-swap] "${label}" → ${result.statusCode} model=${model} quota exhausted${cdLabel}, trying next...`);
-        } else {
-          // Round-robin: put whole account on cooldown
-          setCooldown(conn.id, cooldownMs);
-          log(`⚠️ [token-swap] "${label}" → ${result.statusCode} account quota exhausted${cdLabel}, trying next...`);
+          break;
         }
-        continue;
-      }
 
-      const newCount = (conn.consecutiveUseCount || 0) + 1;
-      const statusCode = result.response.statusCode || 0;
-      const successModelTag = model ? ` model=${model}` : "";
-      const successStrategyTag = strategy === "sticky" ? ` sticky(use #${newCount})` : ` rr`;
-      log(`✅ [token-swap] "${label}" → ${statusCode}${successModelTag}${successStrategyTag}`);
-      markAccountUsed(conn.id);
-      res.writeHead(statusCode, result.response.headers);
-
-      const detailId = generateDetailId(model);
-      const inputOnlyDetail = buildInputOnlyRequestDetail({
-        detailId,
-        provider,
-        model,
-        connectionId: conn.id,
-        bodyBuffer
-      });
-      fetch("http://127.0.0.1:20128/api/internal/request-detail", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          [INTERNAL_REQUEST_HEADER.name]: INTERNAL_REQUEST_HEADER.value
-        },
-        body: JSON.stringify(inputOnlyDetail)
-      }).catch((detailError) => {
-        err(`[token-swap] failed to create request detail for "${label}": ${detailError.message}`);
-      });
-
-      const usageObserver = createTokenSwapUsageObserver({
-        provider,
-        model,
-        connectionId: conn.id,
-        accountLabel: label,
-        bodyBuffer,
-        contentType: result.response.headers["content-type"] || "",
-        contentEncoding: result.response.headers["content-encoding"] || "",
-        statusCode,
-        detailRecord: inputOnlyDetail,
-        requestStartTime
-      });
-
-      result.response.on("data", (chunk) => {
-        usageObserver.onChunk(chunk);
-        res.write(chunk);
-      });
-      result.response.on("end", () => {
-        res.end();
-        usageObserver.onEnd().catch(() => {});
-      });
-      result.response.on("error", (streamError) => {
-        err(`[token-swap] upstream stream error for "${label}": ${streamError.message}`);
-        if (!res.writableEnded) res.end();
-      });
-      return true;
-    } catch (e) {
-      err(`[token-swap] error for "${label}": ${e.message}`);
-      continue;
+        if (result.retry && result.retryType === "auth") {
+          const retryableAuth = isRetryableAuthFailure(result.statusCode, result.headers, result.body);
+          if (!retryableAuth) {
+            res.writeHead(result.statusCode, result.headers);
+            res.end(result.body);
+            return true;
+          }
+
+          if (!authRefreshAttempted && conn.refreshToken) {
+            authRefreshAttempted = true;
+            log(`⚠️ [token-swap] "${label}" → 401 invalid_token, forcing refresh...`);
+            const refreshResult = await forceRefreshConnection(conn);
+            conn = refreshResult.connection || conn;
+            if (refreshResult.refreshed) {
+              log(`↻ [token-swap] "${label}" refreshed, retrying same account...`);
+              continue;
+            }
+          }
+
+          setAuthCooldown(conn.id);
+          log(`⚠️ [token-swap] "${label}" → 401 invalid_token, trying next...`);
+          break;
+        }
+
+        const newCount = (conn.consecutiveUseCount || 0) + 1;
+        const statusCode = result.response.statusCode || 0;
+        const successModelTag = model ? ` model=${model}` : "";
+        const successStrategyTag = strategy === "sticky" ? ` sticky(use #${newCount})` : ` rr`;
+        log(`✅ [token-swap] "${label}" → ${statusCode}${successModelTag}${successStrategyTag}`);
+        markAccountUsed(conn.id);
+        res.writeHead(statusCode, result.response.headers);
+
+        const detailId = generateDetailId(model);
+        const inputOnlyDetail = buildInputOnlyRequestDetail({
+          detailId,
+          provider,
+          model,
+          connectionId: conn.id,
+          bodyBuffer
+        });
+        fetch("http://127.0.0.1:20128/api/internal/request-detail", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            [INTERNAL_REQUEST_HEADER.name]: INTERNAL_REQUEST_HEADER.value
+          },
+          body: JSON.stringify(inputOnlyDetail)
+        }).catch((detailError) => {
+          err(`[token-swap] failed to create request detail for "${label}": ${detailError.message}`);
+        });
+
+        const usageObserver = createTokenSwapUsageObserver({
+          provider,
+          model,
+          connectionId: conn.id,
+          accountLabel: label,
+          bodyBuffer,
+          contentType: result.response.headers["content-type"] || "",
+          contentEncoding: result.response.headers["content-encoding"] || "",
+          statusCode,
+          detailRecord: inputOnlyDetail,
+          requestStartTime
+        });
+
+        result.response.on("data", (chunk) => {
+          usageObserver.onChunk(chunk);
+          res.write(chunk);
+        });
+        result.response.on("end", () => {
+          res.end();
+          usageObserver.onEnd().catch(() => {});
+        });
+        result.response.on("error", (streamError) => {
+          err(`[token-swap] upstream stream error for "${label}": ${streamError.message}`);
+          if (!res.writableEnded) res.end();
+        });
+        return true;
+      } catch (e) {
+        err(`[token-swap] error for "${label}": ${e.message}`);
+        break;
+      }
     }
   }
 
@@ -308,6 +332,36 @@ async function tokenSwapForward(req, res, bodyBuffer, connections, model, strate
   return false;
 }
 
+function getHeaderValue(headers, name) {
+  const value = headers?.[String(name).toLowerCase()];
+  if (Array.isArray(value)) return value.join(", ");
+  return typeof value === "string" ? value : "";
+}
+
+function isRetryableAuthFailure(statusCode, headers, body) {
+  if (statusCode !== 401) return false;
+
+  const authHeader = getHeaderValue(headers, "www-authenticate").toLowerCase();
+  if (authHeader.includes("invalid_token")) return true;
+
+  try {
+    const parsed = JSON.parse(body || "{}");
+    const status = String(parsed?.error?.status || parsed?.status || "").toUpperCase();
+    const message = String(parsed?.error?.message || parsed?.message || "").toLowerCase();
+    if (status === "UNAUTHENTICATED") return true;
+    if (message.includes("invalid authentication credentials")) return true;
+    if (message.includes("invalid token")) return true;
+    if (message.includes("unauthenticated")) return true;
+  } catch {
+    const fallback = String(body || "").toLowerCase();
+    if (fallback.includes("invalid authentication credentials")) return true;
+    if (fallback.includes("invalid token")) return true;
+    if (fallback.includes("unauthenticated")) return true;
+  }
+
+  return false;
+}
+
 // ── Request handler ───────────────────────────────────────────
 
 const server = https.createServer(sslOptions, async (req, res) => {
@@ -357,7 +411,8 @@ const server = https.createServer(sslOptions, async (req, res) => {
       const strategy = getTokenSwapStrategy();
       const poolConns = getAllActiveConnections(swapProvider, model);
       if (poolConns.length > 0) {
-        log(`🔑 [${tool}] token-swap: ${poolConns.length} account(s) available (strategy=${strategy}${model ? `, model=${model}` : ""})`);
+        const availability = getTokenSwapAvailabilitySummary(swapProvider, model);
+        log(`🔑 [${tool}] token-swap: ${availability.summaryText} (strategy=${strategy}${model ? `, model=${model}` : ""})`);
         const handled = await tokenSwapForward(req, res, bodyBuffer, poolConns, model, strategy, swapProvider, bodyCollectStart);
         if (handled) return;
         log(`⚠️ [${tool}] token-swap: all accounts exhausted, falling through to original token`);