n9router 0.3.89 → 0.3.91

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

@@ -8,8 +8,9 @@ const { TARGET_HOSTS, URL_PATTERNS, getToolForHost } = require("./config");
 const { DATA_DIR, MITM_DIR } = require("./paths");
 const { isTokenSwapEnabled, getAllActiveConnections, triggerRefreshIfNeeded,
         setCooldown, setModelCooldown, getTokenSwapStrategy,
-        parseQuotaCooldown, markAccountUsed } = require("./tokenPool");
+        parseQuotaCooldown, markAccountUsed, getConnectionLabel } = require("./tokenPool");
 const { getCertForDomain } = require("./cert/generate");
+const { buildInputOnlyRequestDetail, createTokenSwapUsageObserver, generateDetailId } = require("./usageTracker");
 
 const DB_FILE = path.join(DATA_DIR, "db.json");
 const LOCAL_PORT = 443;
@@ -180,15 +181,15 @@ async function passthrough(req, res, bodyBuffer, onResponse) {
 // Unlike passthrough(), this checks upstream statusCode BEFORE
 // piping to client — enabling auto-retry on 429/503.
 
-async function tokenSwapForward(req, res, bodyBuffer, connections, model, strategy) {
+async function tokenSwapForward(req, res, bodyBuffer, connections, model, strategy, provider, requestStartTime) {
   const targetHost = (req.headers.host || TARGET_HOSTS[0]).split(":")[0];
   const targetIP = await resolveTargetIP(targetHost);
 
   for (let i = 0; i < connections.length; i++) {
-    const conn = connections[i];
-    triggerRefreshIfNeeded(conn);
+    const originalConn = connections[i];
+    const conn = await triggerRefreshIfNeeded(originalConn);
 
-    const label = conn.name && conn.email ? `${conn.name} <${conn.email}>` : conn.name || conn.email || conn.id.slice(0, 8);
+    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}` : "";
@@ -245,12 +246,57 @@ async function tokenSwapForward(req, res, bodyBuffer, connections, model, strate
       }
 
       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}" → ${result.response.statusCode}${successModelTag}${successStrategyTag}`);
+      log(`✅ [token-swap] "${label}" → ${statusCode}${successModelTag}${successStrategyTag}`);
       markAccountUsed(conn.id);
-      res.writeHead(result.response.statusCode, result.response.headers);
-      result.response.pipe(res);
+      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}`);
@@ -283,20 +329,20 @@ const server = https.createServer(sslOptions, async (req, res) => {
 
     // Anti-loop: skip requests from 9Router
     if (req.headers[INTERNAL_REQUEST_HEADER.name] === INTERNAL_REQUEST_HEADER.value) {
-      log(`🔁 [request] anti-loop skip: ${host}${req.url}`);
+      // log(`🔁 [request] anti-loop skip: ${host}${req.url}`);
       return passthrough(req, res, bodyBuffer);
     }
 
     const tool = getToolForHost(req.headers.host);
     if (!tool) {
-      log(`⏩ [request] no tool for host="${host}", passthrough`);
+      // log(`⏩ [request] no tool for host="${host}", passthrough`);
       return passthrough(req, res, bodyBuffer);
     }
 
     const patterns = URL_PATTERNS[tool] || [];
     const isChat = patterns.some(p => req.url.includes(p));
     if (!isChat) {
-      log(`⏩ [request] url="${req.url}" not a chat pattern for tool=${tool}, passthrough`);
+      // log(`⏩ [request] url="${req.url}" not a chat pattern for tool=${tool}, passthrough`);
       return passthrough(req, res, bodyBuffer);
     }
 
@@ -312,7 +358,7 @@ const server = https.createServer(sslOptions, async (req, res) => {
       const poolConns = getAllActiveConnections(swapProvider, model);
       if (poolConns.length > 0) {
         log(`🔑 [${tool}] token-swap: ${poolConns.length} account(s) available (strategy=${strategy}${model ? `, model=${model}` : ""})`);
-        const handled = await tokenSwapForward(req, res, bodyBuffer, poolConns, model, strategy);
+        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`);
       } else {
@@ -333,7 +379,7 @@ const server = https.createServer(sslOptions, async (req, res) => {
 
     const mappedModel = getMappedModel(tool, model);
     if (!mappedModel) {
-      log(`⏩ passthrough | no mapping | ${tool} | ${model || "unknown"}`);
+      // log(`⏩ passthrough | no mapping | ${tool} | ${model || "unknown"}`);
       return passthrough(req, res, bodyBuffer);
     }
 

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

@@ -110,6 +110,52 @@ function getActiveConnections(provider) {
   } catch { return []; }
 }
 
+function getConnectionById(connId) {
+  try {
+    if (!fs.existsSync(DB_FILE)) return null;
+    const db = JSON.parse(fs.readFileSync(DB_FILE, "utf-8"));
+    const connections = db.providerConnections || [];
+    return connections.find(c => c.id === connId) || null;
+  } catch {
+    return null;
+  }
+}
+
+function maskEmail(email) {
+  if (!email || typeof email !== "string") return email;
+  const atIndex = email.indexOf("@");
+  if (atIndex <= 0 || atIndex === email.length - 1) return email;
+
+  const local = email.slice(0, atIndex);
+  const domain = email.slice(atIndex + 1);
+
+  if (local.length === 1) return `${local[0]}**@${domain}`;
+  if (local.length === 2) return `${local[0]}**${local[1]}@${domain}`;
+
+  return `${local[0]}**${local[local.length - 1]}@${domain}`;
+}
+
+function isAccountEmailMaskEnabled() {
+  try {
+    if (!fs.existsSync(DB_FILE)) return false;
+    const db = JSON.parse(fs.readFileSync(DB_FILE, "utf-8"));
+    return !!db.settings?.tokenSwapMaskEmails;
+  } catch {
+    return false;
+  }
+}
+
+function getConnectionLabel(connection) {
+  if (!connection) return "";
+
+  const shouldMask = isAccountEmailMaskEnabled();
+  const email = shouldMask ? maskEmail(connection.email) : connection.email;
+
+  if (connection.name && email) return `${connection.name} <${email}>`;
+  if (email) return email;
+  return connection.name || connection.id.slice(0, 8);
+}
+
 function isTokenSwapEnabled(provider) {
   try {
     if (!fs.existsSync(DB_FILE)) return false;
@@ -131,13 +177,13 @@ function getNextConnection(provider) {
   const connections = getActiveConnections(provider);
   if (connections.length === 0) return null;
   if (connections.length === 1) {
-    log(`🎯 [token-pool] selected: "${connections[0].name || connections[0].email || connections[0].id.slice(0, 8)}" (only account)`);
+    log(`🎯 [token-pool] selected: "${getConnectionLabel(connections[0])}" (only account)`);
     return connections[0];
   }
   const idx = (rrState[provider] || 0) % connections.length;
   rrState[provider] = idx + 1;
   const selected = connections[idx];
-  log(`🎯 [token-pool] round-robin[${idx}/${connections.length}]: "${selected.name || selected.email || selected.id.slice(0, 8)}"`);
+  log(`🎯 [token-pool] round-robin[${idx}/${connections.length}]: "${getConnectionLabel(selected)}"`);
   return selected;
 }
 
@@ -236,24 +282,38 @@ function markAccountUsed(connId) {
   }
 }
 
-// ── Token refresh trigger (fire-and-forget via HTTP) ─────────
+// ── Token refresh trigger (refresh + reload persisted token) ─
 // Calls 9Router's existing POST /api/providers/:id/test which
-// checks expiry and refreshes token automatically.
+// checks expiry, refreshes token automatically, then returns the
+// latest persisted connection snapshot for the current request.
 
-function triggerRefreshIfNeeded(connection) {
-  if (!connection.expiresAt) return;
+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;
-
-  log(`🔄 [token-pool] near-expiry refresh → ${(connection.name || connection.email || connection.id).slice(0, 20)}`);
-  try {
-    const req = http.request(
-      { hostname: "127.0.0.1", port: ROUTER_PORT, path: `/api/providers/${connection.id}/test`, method: "POST" },
-      () => {} // ignore response
-    );
-    req.on("error", () => {}); // swallow
-    req.end();
-  } catch { /* ignore */ }
+  if (Date.now() + TOKEN_EXPIRY_BUFFER_MS < expiresAt) return connection;
+
+  log(`🔄 [token-pool] near-expiry refresh → ${getConnectionLabel(connection).slice(0, 20)}`);
+  return await new Promise((resolve) => {
+    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("end", () => {
+            const refreshed = getConnectionById(connection.id);
+            if (refreshed?.accessToken && refreshed.accessToken !== connection.accessToken) {
+              log(`♻️ [token-pool] refreshed token applied → ${getConnectionLabel(connection).slice(0, 20)}`);
+            }
+            resolve(refreshed || connection);
+          });
+        }
+      );
+      req.on("error", () => resolve(connection));
+      req.end();
+    } catch {
+      resolve(connection);
+    }
+  });
 }
 
 module.exports = {
@@ -267,4 +327,6 @@ module.exports = {
   getTokenSwapStrategy,
   parseQuotaCooldown,
   markAccountUsed,
+  getConnectionLabel,
+  maskEmail,
 };