n9router 0.3.89 → 0.3.90

package/.next/standalone/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,
 };

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

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

package/.next/standalone/package.json

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

package/.next/standalone/src/app/(dashboard)/dashboard/cli-tools/components/TokenSwapPoolCard.js

@@ -1,9 +1,9 @@
 "use client";
 
 import { useState, useEffect, useCallback, useRef } from "react";
-import { Card, Badge } from "@/shared/components";
+import { Card, Badge, Toggle } from "@/shared/components";
 import Link from "next/link";
-import { parseQuotaData } from "@/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils";
+import { parseQuotaData, formatResetTime } from "@/app/(dashboard)/dashboard/usage/components/ProviderLimits/utils";
 
 // Model to highlight in the quota summary
 const HIGHLIGHT_MODEL = "claude-sonnet-4-6";
@@ -26,14 +26,103 @@ function getQuotaBg(pct) {
   return "bg-red-500";
 }
 
+function formatResetTimeDisplay(resetTime) {
+  if (!resetTime) return null;
+
+  try {
+    const resetDate = new Date(resetTime);
+    const now = new Date();
+    const isToday = resetDate.toDateString() === now.toDateString();
+    const isTomorrow = resetDate.toDateString() === new Date(now.getTime() + 86400000).toDateString();
+
+    const timeStr = resetDate.toLocaleTimeString(undefined, {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: true,
+    });
+
+    if (isToday) return `Today, ${timeStr}`;
+    if (isTomorrow) return `Tomorrow, ${timeStr}`;
+
+    return resetDate.toLocaleString(undefined, {
+      month: "short",
+      day: "numeric",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: true,
+    });
+  } 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 getAccountDisplay(acc, maskEmails) {
+  if (acc.email) return maskEmails ? maskEmail(acc.email) : acc.email;
+  return acc.name || acc.id.slice(0, 16);
+}
+
+function getStickyLimitForTool(tool) {
+  return tool?.stickyRoundRobinLimit || 3;
+}
+
+function getPreferredAccountId(accounts, strategy, stickyLimit) {
+  if (!accounts || accounts.length === 0) return null;
+  if (accounts.length === 1) return accounts[0].id;
+
+  const byNewest = [...accounts].sort((a, b) => {
+    if (!a.lastUsedAt && !b.lastUsedAt) return (a.priority || 999) - (b.priority || 999);
+    if (!a.lastUsedAt) return 1;
+    if (!b.lastUsedAt) return -1;
+    return new Date(b.lastUsedAt) - new Date(a.lastUsedAt);
+  });
+
+  if (strategy === "sticky") {
+    return byNewest[0]?.id || null;
+  }
+
+  const current = byNewest[0];
+  const currentCount = current?.consecutiveUseCount || 0;
+  if (current?.lastUsedAt && currentCount < stickyLimit) {
+    return current.id;
+  }
+
+  const byOldest = [...accounts].sort((a, b) => {
+    if (!a.lastUsedAt && !b.lastUsedAt) return (a.priority || 999) - (b.priority || 999);
+    if (!a.lastUsedAt) return -1;
+    if (!b.lastUsedAt) return 1;
+    return new Date(a.lastUsedAt) - new Date(b.lastUsedAt);
+  });
+
+  return byOldest[0]?.id || null;
+}
+
 /**
  * Token Swap Pool Card — standalone card for token rotation mode.
  */
-export default function TokenSwapPoolCard({ tool, connections = [], serverRunning, dnsActive, onToggle }) {
+export default function TokenSwapPoolCard({ tool, connections = [], serverRunning, dnsActive, onToggle, onRefreshConnections }) {
   const [enabled, setEnabled] = useState(false);
   const [toggling, setToggling] = useState(false);
   const [strategy, setStrategy] = useState("round-robin"); // "round-robin" | "sticky"
   const [togglingStrategy, setTogglingStrategy] = useState(false);
+  const [maskEmails, setMaskEmails] = useState(false);
+  const [togglingMaskEmails, setTogglingMaskEmails] = useState(false);
+  const [togglingAccountId, setTogglingAccountId] = useState(null);
+  const [resettingAccountId, setResettingAccountId] = useState(null);
+  const [resettingAll, setResettingAll] = useState(false);
   const [quotas, setQuotas] = useState({}); // { [connId]: { quotas: [], error: string|null, loading: bool } }
   const quotaCacheRef = useRef({}); // { [connId]: { data: parsed, error, ts: number } }
 
@@ -44,6 +133,7 @@ export default function TokenSwapPoolCard({ tool, connections = [], serverRunnin
         const data = await res.json();
         setEnabled(!!data.tokenSwapEnabled);
         setStrategy(data.tokenSwapStrategy || "round-robin");
+        setMaskEmails(!!data.tokenSwapMaskEmails);
       }
     } catch { /* ignore */ }
   }, []);
@@ -149,18 +239,39 @@ export default function TokenSwapPoolCard({ tool, connections = [], serverRunnin
     setTogglingStrategy(false);
   };
 
-  const poolAccounts = connections.filter(
-    (c) => c.provider === tool.tokenSwapProvider && c.isActive !== false
+  const toggleMaskEmails = async () => {
+    if (togglingMaskEmails) return;
+    setTogglingMaskEmails(true);
+    const newVal = !maskEmails;
+    try {
+      const res = await fetch("/api/settings", {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tokenSwapMaskEmails: newVal }),
+      });
+      if (res.ok) setMaskEmails(newVal);
+    } catch { /* ignore */ }
+    setTogglingMaskEmails(false);
+  };
+
+  const providerAccounts = connections.filter(
+    (c) => c.provider === tool.tokenSwapProvider
   );
-  const activeCount = poolAccounts.length;
+  const activeAccounts = providerAccounts.filter(
+    (c) => c.isActive !== false
+  );
+  const activeCount = activeAccounts.length;
+  const activeAccountsKey = activeAccounts.map((acc) => acc.id).join("|");
+  const stickyLimit = getStickyLimitForTool(tool);
+  const preferredAccountId = getPreferredAccountId(activeAccounts, strategy, stickyLimit);
 
   // Auto-fetch quotas when enabled and accounts available
   // eslint-disable-next-line react-hooks/rules-of-hooks
   useEffect(() => {
     if (enabled && activeCount > 0) {
-      fetchQuotas(poolAccounts);
+      fetchQuotas(activeAccounts);
     }
-  }, [enabled, activeCount]); // eslint-disable-line react-hooks/exhaustive-deps
+  }, [enabled, activeCount, activeAccountsKey, fetchQuotas]); // eslint-disable-line react-hooks/exhaustive-deps
 
   // Prerequisites check
   const prereqsMet = serverRunning && dnsActive;
@@ -169,31 +280,19 @@ export default function TokenSwapPoolCard({ tool, connections = [], serverRunnin
   /**
    * Render inline quota info for a single account
    */
-  const renderAccountQuota = (accId) => {
+  const getAccountQuotaMeta = (accId) => {
     const q = quotas[accId];
-    if (!q) return null;
-    if (q.loading) {
-      return (
-        <span className="text-[10px] text-text-muted animate-pulse shrink-0">loading…</span>
-      );
-    }
-    if (q.error) {
-      return (
-        <span className="text-[10px] text-red-400 shrink-0" title={q.error}>⛔ bad account</span>
-      );
-    }
-    if (!q.quotas || q.quotas.length === 0) {
-      return (
-        <span className="text-[10px] text-text-muted shrink-0">no quota data</span>
-      );
-    }
+    if (!q) return { state: "empty" };
+    if (q.loading) return { state: "loading" };
+    if (q.error) return { state: "error", error: q.error };
+    if (!q.quotas || q.quotas.length === 0) return { state: "no-data" };
 
     // Find highlight model, fallback to first quota with data
     const highlight = q.quotas.find(m =>
       m.modelKey?.includes(HIGHLIGHT_MODEL) || m.name?.toLowerCase().includes("opus")
     ) || q.quotas[0];
 
-    if (!highlight) return null;
+    if (!highlight) return { state: "no-data" };
 
     const pct = highlight.remainingPercentage !== undefined
       ? Math.round(highlight.remainingPercentage)
@@ -201,19 +300,113 @@ export default function TokenSwapPoolCard({ tool, connections = [], serverRunnin
         ? Math.round(((highlight.total - highlight.used) / highlight.total) * 100)
         : null;
 
-    if (pct === null) return null;
+    const nextResetAt = [...q.quotas]
+      .map((quota) => quota.resetAt)
+      .filter(Boolean)
+      .filter((resetAt) => new Date(resetAt).getTime() > Date.now())
+      .sort((a, b) => new Date(a).getTime() - new Date(b).getTime())[0] || highlight.resetAt || null;
+
+    return {
+      state: pct === null ? "no-data" : "ready",
+      highlight,
+      pct,
+      nextResetAt,
+      resetCountdown: formatResetTime(nextResetAt),
+      resetDisplay: formatResetTimeDisplay(nextResetAt),
+    };
+  };
 
+  const renderAccountQuota = (accId) => {
+    const meta = getAccountQuotaMeta(accId);
+    if (!meta || meta.state === "empty") {
+      return <span className="text-[10px] text-text-muted">Enable to load quota data</span>;
+    }
+    if (meta.state === "loading") {
+      return <span className="text-[10px] text-text-muted animate-pulse">Loading quota…</span>;
+    }
+    if (meta.state === "error") {
+      return <span className="text-[10px] text-red-400" title={meta.error}>Quota unavailable</span>;
+    }
+    if (meta.state === "no-data") {
+      return <span className="text-[10px] text-text-muted">No quota data</span>;
+    }
+
+    const { highlight, pct, resetCountdown, resetDisplay } = meta;
     return (
-      <div className="flex items-center gap-1.5 shrink-0">
-        <span className="text-[10px] text-text-muted truncate max-w-[80px]">{highlight.name}</span>
-        <div className="w-12 h-1.5 rounded-full bg-surface-alt overflow-hidden shrink-0">
-          <div className={`h-full rounded-full ${getQuotaBg(pct)}`} style={{ width: `${Math.min(pct, 100)}%` }} />
+      <div className="flex flex-col gap-1.5 min-w-0">
+        <div className="flex items-center gap-2 min-w-0">
+          <span className="text-[10px] text-text-muted truncate">{highlight.name}</span>
+          <div className="flex-1 h-1.5 rounded-full bg-surface-alt overflow-hidden min-w-[56px]">
+            <div className={`h-full rounded-full ${getQuotaBg(pct)}`} style={{ width: `${Math.min(pct, 100)}%` }} />
+          </div>
+          <span className={`text-[10px] font-medium shrink-0 ${getQuotaColor(pct)}`}>{pct}%</span>
         </div>
-        <span className={`text-[10px] font-medium shrink-0 ${getQuotaColor(pct)}`}>{pct}%</span>
+        {resetCountdown !== "-" && resetDisplay ? (
+          <div className="text-[10px] text-text-muted">
+            Reset in <span className="text-text-main">{resetCountdown}</span>
+            <span className="text-text-muted/70"> • {resetDisplay}</span>
+          </div>
+        ) : (
+          <div className="text-[10px] text-text-muted">Reset time unavailable</div>
+        )}
       </div>
     );
   };
 
+  const toggleAccountActive = async (accountId, nextActive) => {
+    if (!accountId || togglingAccountId || resettingAll || resettingAccountId) return;
+    setTogglingAccountId(accountId);
+    try {
+      const res = await fetch(`/api/providers/${accountId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ isActive: nextActive }),
+      });
+      if (res.ok) {
+        await onRefreshConnections?.();
+      }
+    } catch { /* ignore */ }
+    setTogglingAccountId(null);
+  };
+
+  const resetAccountStreak = async (accountId) => {
+    if (!accountId || resettingAccountId || resettingAll || togglingAccountId) return;
+    setResettingAccountId(accountId);
+    try {
+      const res = await fetch(`/api/providers/${accountId}`, {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          lastUsedAt: null,
+          consecutiveUseCount: 0,
+        }),
+      });
+      if (res.ok) {
+        await onRefreshConnections?.();
+      }
+    } catch { /* ignore */ }
+    setResettingAccountId(null);
+  };
+
+  const resetAllStreaks = async () => {
+    if (resettingAll || resettingAccountId || togglingAccountId || providerAccounts.length === 0) return;
+    setResettingAll(true);
+    try {
+      await Promise.all(providerAccounts.map((acc) => (
+        fetch(`/api/providers/${acc.id}`, {
+          method: "PUT",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            lastUsedAt: null,
+            consecutiveUseCount: 0,
+          }),
+        })
+      )));
+      await onRefreshConnections?.();
+    } catch { /* ignore */ }
+    setResettingAll(false);
+  };
+
   return (
     <Card padding="xs" className="overflow-hidden">
       {/* ── Header ────────────────────────────────── */}
@@ -334,7 +527,7 @@ export default function TokenSwapPoolCard({ tool, connections = [], serverRunnin
               <div className="flex items-center gap-2">
                 <p className="text-[10px] uppercase tracking-wider text-text-muted font-semibold">Pool Accounts</p>
                 <span className="text-[10px] text-text-muted">
-                  {activeCount > 0 ? `${activeCount} active` : "none"}
+                  {providerAccounts.length > 0 ? `${activeCount}/${providerAccounts.length} active` : "none"}
                 </span>
                 {activeCount > 1 && (
                   <span className="text-[9px] text-text-muted bg-surface border border-border px-1 py-0.5 rounded">
@@ -342,26 +535,114 @@ export default function TokenSwapPoolCard({ tool, connections = [], serverRunnin
                   </span>
                 )}
               </div>
-              {activeCount > 0 && (
-                <button
-                  onClick={() => fetchQuotas(poolAccounts, true)}
-                  className="text-[10px] text-text-muted hover:text-primary flex items-center gap-0.5 transition-colors"
-                  title="Refresh quotas"
-                >
-                  <span className="material-symbols-outlined text-[12px]">refresh</span>
-                </button>
-              )}
+              <div className="flex items-center gap-2">
+                {activeCount > 0 && (
+                  <button
+                    onClick={() => fetchQuotas(activeAccounts, true)}
+                    className="text-[10px] text-text-muted hover:text-primary flex items-center gap-0.5 transition-colors"
+                    title="Refresh quotas"
+                  >
+                    <span className="material-symbols-outlined text-[12px]">refresh</span>
+                  </button>
+                )}
+                {providerAccounts.length > 0 && (
+                  <button
+                    onClick={resetAllStreaks}
+                    disabled={resettingAll || !!resettingAccountId}
+                    className="text-[10px] text-text-muted hover:text-primary disabled:opacity-50 flex items-center gap-0.5 transition-colors"
+                    title="Reset all streak counts"
+                  >
+                    <span className="material-symbols-outlined text-[12px]">restart_alt</span>
+                    Reset all
+                  </button>
+                )}
+              </div>
+            </div>
+            <p className="text-[10px] text-text-muted px-0.5">
+              Sticky round robin keeps the current account until its streak reaches {stickyLimit}, then rotates to the least recently used account.
+            </p>
+            <div className="flex items-center justify-between gap-3 px-2 py-2 rounded-lg border border-border bg-surface-alt/40">
+              <div className="min-w-0">
+                <p className="text-[11px] font-medium text-text-main">Mask account emails</p>
+                <p className="text-[10px] text-text-muted">
+                  Hide pool account emails in token swap logs and this panel. Example: {maskEmail("email@gmail.com")}
+                </p>
+              </div>
+              <button
+                onClick={toggleMaskEmails}
+                disabled={togglingMaskEmails}
+                className={`relative inline-flex h-5 w-9 items-center rounded-full transition-colors shrink-0 ${
+                  maskEmails ? "bg-violet-500" : "bg-surface border border-border"
+                } ${togglingMaskEmails ? "opacity-50" : "cursor-pointer"}`}
+                title={maskEmails ? "Disable email masking" : "Enable email masking"}
+              >
+                <span
+                  className={`inline-block h-3.5 w-3.5 transform rounded-full bg-white transition-transform shadow-sm ${
+                    maskEmails ? "translate-x-4" : "translate-x-0.5"
+                  }`}
+                />
+              </button>
             </div>
 
-            {activeCount > 0 ? (
+            {providerAccounts.length > 0 ? (
               <>
-                {poolAccounts.map((acc) => (
-                  <div key={acc.id} className="flex items-center gap-2 px-1 py-1 rounded hover:bg-surface-alt/50 transition-colors">
-                    <span className="material-symbols-outlined text-[14px] shrink-0 text-green-500">check_circle</span>
-                    <span className="flex-1 text-xs text-text-main truncate min-w-0">
-                      {acc.email || acc.name || acc.id.slice(0, 16)}
-                    </span>
-                    {renderAccountQuota(acc.id)}
+                {providerAccounts.map((acc) => (
+                  <div
+                    key={acc.id}
+                    className={`rounded-xl border border-border bg-surface-alt/30 px-3 py-2.5 transition-colors ${
+                      acc.isActive === false ? "opacity-65" : "hover:bg-surface-alt/50"
+                    }`}
+                  >
+                    <div className="flex items-start justify-between gap-3">
+                      <div className="min-w-0 flex-1">
+                        <div className="flex items-center gap-2 min-w-0">
+                          <span className={`material-symbols-outlined text-[14px] shrink-0 ${acc.isActive === false ? "text-text-muted" : "text-green-500"}`}>
+                            {acc.isActive === false ? "pause_circle" : "check_circle"}
+                          </span>
+                          <span className="text-xs font-medium text-text-main truncate">
+                            {getAccountDisplay(acc, maskEmails)}
+                          </span>
+                          {preferredAccountId === acc.id && acc.isActive !== false && (
+                            <span className="text-[9px] text-violet-300 bg-violet-500/10 border border-violet-500/20 px-1 py-0.5 rounded shrink-0">
+                              next
+                            </span>
+                          )}
+                          <Badge variant={acc.isActive === false ? "default" : "success"} size="sm">
+                            {acc.isActive === false ? "disabled" : "active"}
+                          </Badge>
+                        </div>
+                        <div className="mt-1 flex items-center gap-2 flex-wrap text-[10px] text-text-muted">
+                          <span>Priority #{acc.priority ?? "-"}</span>
+                          <span>Streak {acc.consecutiveUseCount || 0}/{stickyLimit}</span>
+                          {acc.lastUsedAt && <span>Last used {new Date(acc.lastUsedAt).toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" })}</span>}
+                        </div>
+                      </div>
+                      <div className="flex items-center gap-3 shrink-0">
+                        <button
+                          onClick={() => resetAccountStreak(acc.id)}
+                          disabled={resettingAll || togglingAccountId === acc.id || resettingAccountId === acc.id}
+                          className="text-[10px] text-text-muted hover:text-primary disabled:opacity-50 transition-colors"
+                          title="Reset this account streak"
+                        >
+                          {resettingAccountId === acc.id ? "..." : "Reset Streak"}
+                        </button>
+                        <Toggle
+                          size="sm"
+                          checked={acc.isActive !== false}
+                          disabled={resettingAll || resettingAccountId === acc.id || togglingAccountId === acc.id}
+                          onChange={(nextChecked) => toggleAccountActive(acc.id, nextChecked)}
+                        />
+                      </div>
+                    </div>
+                    <div className="mt-2 pl-6">
+                      {acc.isActive === false ? (
+                        <div className="text-[10px] text-text-muted">
+                          Enable this account to include it in token rotation and load quota reset info.
+                        </div>
+                      ) : (
+                        renderAccountQuota(acc.id)
+                      )}
+                    </div>
                   </div>
                 ))}
                 <Link

package/.next/standalone/src/app/(dashboard)/dashboard/mitm/MitmPageClient.js

@@ -57,10 +57,16 @@ export default function MitmPageClient() {
   };
 
   useEffect(() => {
-    fetchConnections();
-    fetchApiKeys();
-    fetchAliases();
-    fetchCloudSettings();
+    const loadInitialData = async () => {
+      await Promise.all([
+        fetchConnections(),
+        fetchApiKeys(),
+        fetchAliases(),
+        fetchCloudSettings(),
+      ]);
+    };
+
+    loadInitialData();
   }, []);
 
   const getActiveProviders = () => connections.filter(c => c.isActive !== false);
@@ -111,6 +117,7 @@ export default function MitmPageClient() {
                 serverRunning={mitmStatus.running}
                 dnsActive={mitmStatus.dnsStatus?.[toolId] || false}
                 onToggle={(val) => setTokenSwapActive(val)}
+                onRefreshConnections={fetchConnections}
               />
             )}
           </Fragment>

package/.next/standalone/src/app/api/providers/[id]/route.js

@@ -98,6 +98,8 @@ export async function PUT(request, { params }) {
       testStatus,
       lastError,
       lastErrorAt,
+      lastUsedAt,
+      consecutiveUseCount,
       providerSpecificData
     } = body;
 
@@ -126,6 +128,8 @@ export async function PUT(request, { params }) {
     if (testStatus !== undefined) updateData.testStatus = testStatus;
     if (lastError !== undefined) updateData.lastError = lastError;
     if (lastErrorAt !== undefined) updateData.lastErrorAt = lastErrorAt;
+    if (lastUsedAt !== undefined) updateData.lastUsedAt = lastUsedAt;
+    if (consecutiveUseCount !== undefined) updateData.consecutiveUseCount = consecutiveUseCount;
 
     if (
       shouldMergeProviderSpecificData(