qwenproxy-cli 1.5.2 → 1.6.0

package/src/services/playwright.ts

@@ -512,6 +512,7 @@ const COOKIE_CACHE_TTL = 15 * 60 * 1000; // 15 minutes
 const cookieCaches = new Map<string, { cookie: string; timestamp: number }>();
 const lastAccountActivity = new Map<string, number>();
 const lastKeepAliveNavigation = new Map<string, number>();
+const lastProactiveTokenRefresh = new Map<string, number>();
 const profileResetQueue = new Map<string, Promise<void>>();
 let profileResetChain: Promise<void> = Promise.resolve();
 let closingAllPlaywright = false;
@@ -1228,6 +1229,11 @@ export async function getBasicHeaders(accountId: string): Promise<{
     throw new Error(`Playwright not initialized for account: ${accountId}`);
   }
 
+  const inFlightInit = inFlightAccountInits.get(accountId);
+  if (inFlightInit) {
+    await inFlightInit.catch(() => {});
+  }
+
   // Acquire mutex to prevent concurrent browser access
   const release = await acquireAccountMutex(
     accountId,
@@ -3068,6 +3074,12 @@ export async function captureQwenHeaders(
         const { saveAuthSession } = await import("../core/database.ts");
         const { parseJwtExpiry } = await import("../utils/jwt.ts");
         const tokenExpiry = parseJwtExpiry(capturedHeaders.cookie);
+        let rTok: string | undefined;
+        try {
+          rTok =
+            (await page.evaluate(() => localStorage.getItem("refresh_token") || "")).trim() ||
+            undefined;
+        } catch {}
         saveAuthSession(accountId, {
           cookie: capturedHeaders.cookie,
           userAgent: capturedHeaders["user-agent"],
@@ -3079,6 +3091,7 @@ export async function captureQwenHeaders(
           secChUaPlatform: capturedHeaders["sec-ch-ua-platform"],
           version: capturedHeaders["version"],
           tokenExpiresAt: tokenExpiry || undefined,
+          refreshToken: rTok,
           capturedAt: Date.now(),
         });
       } catch {}
@@ -3121,40 +3134,61 @@ export async function captureQwenHeaders(
       const isAuthUrl = currentUrl.includes("/auth") || currentUrl.includes("/login");
       const isSuspectedGuest = isAuthUrl || (attempt >= 2 && !(await isPageLoggedIn(page, 5000)));
       if (isSuspectedGuest) {
-        const { getAccountCredentials } = await import("../core/accounts.ts");
-        const creds = getAccountCredentials(accountId);
-        if (creds && creds.email && creds.password) {
-          console.warn(
-            `⚠️  [Playwright] Session expired or guest state detected during header capture for ${accountId}; re-authenticating...`,
+        // Try fast silent token refresh first using the 30-day refresh_token in-page (~200ms)
+        const silentRefresh = await refreshAccountToken(accountId);
+        if (silentRefresh.success) {
+          console.log(
+            `⚡ [Playwright] Token refreshed silently during header capture for ${accountId}`,
           );
-          armOverallDeadline();
-          const ok = await loginToQwen(accountId, creds.email, creds.password);
-          if (ok) {
-            // Re-login navigated; load the chat page and wait for hydration so
-            // the check below probes a live authenticated chat page.
+          if (isAuthUrl) {
             await page.goto(qwenUrl("/"), {
               waitUntil: "domcontentloaded",
               timeout: Math.min(config.timeouts.navigation, timeoutMs),
             });
-            await sleep(2000);
+            await sleep(1500);
           }
-          if (!ok || !(await isPageLoggedIn(page, 6000))) {
+          if (await isPageLoggedIn(page, 5000)) {
+            armOverallDeadline();
+          }
+        }
+
+        const stillSuspected = !silentRefresh.success || !(await isPageLoggedIn(page, 2000));
+        if (stillSuspected) {
+          const { getAccountCredentials } = await import("../core/accounts.ts");
+          const creds = getAccountCredentials(accountId);
+          if (creds && creds.email && creds.password) {
+            console.warn(
+              `⚠️  [Playwright] Session expired or guest state detected during header capture for ${accountId}; re-authenticating...`,
+            );
+            armOverallDeadline();
+            const ok = await loginToQwen(accountId, creds.email, creds.password);
+            if (ok) {
+              // Re-login navigated; load the chat page and wait for hydration so
+              // the check below probes a live authenticated chat page.
+              await page.goto(qwenUrl("/"), {
+                waitUntil: "domcontentloaded",
+                timeout: Math.min(config.timeouts.navigation, timeoutMs),
+              });
+              await sleep(2000);
+            }
+            if (!ok || !(await isPageLoggedIn(page, 6000))) {
+              settle(
+                new Error(
+                  `Header capture failed for ${accountId}: re-login after session expiry did not succeed`,
+                ),
+              );
+              return;
+            }
+            armOverallDeadline();
+            if (settled || page.isClosed()) return;
+          } else {
             settle(
               new Error(
-                `Header capture failed for ${accountId}: re-login after session expiry did not succeed`,
+                `Header capture failed for ${accountId}: session expired and no credentials available for re-login (run 'qpx login')`,
               ),
             );
             return;
           }
-          armOverallDeadline();
-          if (settled || page.isClosed()) return;
-        } else {
-          settle(
-            new Error(
-              `Header capture failed for ${accountId}: session expired and no credentials available for re-login (run 'qpx login')`,
-            ),
-          );
-          return;
         }
       }
 
@@ -3593,7 +3627,15 @@ async function refreshHeadersInternal(
             `[Playwright] Navigation check failed during refresh for ${accountId}:`,
             (navErr as Error).message,
           );
-          await executeReauth();
+          if (await isPageLoggedIn(page, 3000)) {
+            // Still authenticated despite navigation timeout; do not escalate to slow form re-auth
+          } else {
+            // Try silent in-page token refresh before executing full form login
+            const refreshed = await refreshAccountToken(accountId);
+            if (!refreshed.success) {
+              await executeReauth();
+            }
+          }
         }
       }
 
@@ -3610,6 +3652,12 @@ async function refreshHeadersInternal(
             const { saveAuthSession } = await import("../core/database.ts");
             const tokenCookie = liveCookies.find((c) => c.name === "token");
             const exp = tokenCookie ? parseJwtExpiry(tokenCookie.value) : undefined;
+            let rTok: string | undefined;
+            try {
+              rTok =
+                (await page.evaluate(() => localStorage.getItem("refresh_token") || "")).trim() ||
+                undefined;
+            } catch {}
             saveAuthSession(accountId, {
               cookie: cookieStr,
               userAgent: cache.headers["user-agent"] || "",
@@ -3621,6 +3669,7 @@ async function refreshHeadersInternal(
               secChUaPlatform: cache.headers["sec-ch-ua-platform"] || undefined,
               version: cache.headers["version"] || undefined,
               tokenExpiresAt: exp || undefined,
+              refreshToken: rTok,
               capturedAt: Date.now(),
             });
           } catch {}
@@ -4169,8 +4218,10 @@ export async function keepAlivePlaywrightAccount(
     const currentUrl = page.url();
 
     // Proactive session check: if token expires within 5 minutes, refresh in-page silently using refreshAccountToken
+    const lastRefreshAttempt = lastProactiveTokenRefresh.get(accountId) ?? 0;
     const cookie = await getCookies(accountId);
-    if (cookie && isTokenExpiringSoon(cookie, 5)) {
+    if (cookie && isTokenExpiringSoon(cookie, 5) && now - lastRefreshAttempt > 60_000) {
+      lastProactiveTokenRefresh.set(accountId, now);
       console.log(
         `💓 [SessionKeeper] Account ${accountId} access token expiring soon (<5m); silently refreshing...`,
       );
@@ -4233,6 +4284,7 @@ function cleanupPlaywrightAccountState(accountId: string): void {
   cookieCaches.delete(accountId);
   lastAccountActivity.delete(accountId);
   lastKeepAliveNavigation.delete(accountId);
+  lastProactiveTokenRefresh.delete(accountId);
   clearFingerprintCache(accountId);
   // The account's context died/closed — its captured headers are stale or the
   // page is gone, so it must not be selected by the rotation gate until a

package/src/services/qwen.ts

@@ -1540,6 +1540,12 @@ async function createQwenBrowserResponse(
   }
 }
 
+const inFlightPersonalizationSyncs = new Map<string, Promise<boolean>>();
+
+export function getInFlightPersonalizationCount(): number {
+  return inFlightPersonalizationSyncs.size;
+}
+
 export async function syncQwenRequestPersonalization(
   instruction: string,
   accountId?: string,
@@ -1552,15 +1558,67 @@ export async function syncQwenRequestPersonalization(
     forceSync?: boolean;
   } = {},
 ): Promise<boolean> {
-  if (isAuthMockEnabled()) {
-    // Test hook: force the sync to report "not applied" so the fail-fast
-    // contract (personalization-required suite) is exercisable in mock mode.
-    if (process.env.TEST_PERSONALIZATION_SYNC_FAIL === "true") return false;
-    return true;
+  const cacheKey = accountId || "global";
+  const sent = textSize(instruction);
+  const syncHash = sent.hash ? `${sent.hash}:${QWEN_SAFE_SETTINGS_HASH}` : null;
+  const inFlightKey = `${cacheKey}:${syncHash || "empty"}`;
+
+  const existingInFlight = inFlightPersonalizationSyncs.get(inFlightKey);
+  if (existingInFlight) {
+    logger.debug("[Qwen] Personalization sync already in flight, sharing promise", {
+      accountId: cacheKey,
+    });
+    return existingInFlight;
   }
-  // instruction pode ser vazia para limpar personalization
 
-  const cacheKey = accountId || "global";
+  let syncPromise!: Promise<boolean>;
+  syncPromise = (async () => {
+    await Promise.resolve();
+    try {
+      if (isAuthMockEnabled()) {
+        const delay = parseInt(process.env.TEST_PERSONALIZATION_DELAY_MS || "0", 10);
+        if (delay > 0) {
+          await sleep(delay);
+        }
+        // Test hook: force the sync to report "not applied" so the fail-fast
+        // contract (personalization-required suite) is exercisable in mock mode.
+        if (process.env.TEST_PERSONALIZATION_SYNC_FAIL === "true") return false;
+        return true;
+      }
+      return await syncQwenRequestPersonalizationInternal(
+        instruction,
+        accountId,
+        metadata,
+        cacheKey,
+        sent,
+        syncHash,
+      );
+    } finally {
+      if (inFlightPersonalizationSyncs.get(inFlightKey) === syncPromise) {
+        inFlightPersonalizationSyncs.delete(inFlightKey);
+      }
+    }
+  })();
+
+  inFlightPersonalizationSyncs.set(inFlightKey, syncPromise);
+  return syncPromise;
+}
+
+async function syncQwenRequestPersonalizationInternal(
+  instruction: string,
+  accountId: string | undefined,
+  metadata: {
+    model?: string;
+    toolsCount?: number;
+    sessionId?: string | null;
+    promptChars?: number;
+    forceSync?: boolean;
+  },
+  cacheKey: string,
+  sent: ReturnType<typeof textSize>,
+  syncHash: string | null,
+): Promise<boolean> {
+  // instruction pode ser vazia para limpar personalization
 
   // Proactive token renewal: refresh BEFORE attempting personalization
   // to avoid 401 errors that waste time on retry
@@ -1584,8 +1642,6 @@ export async function syncQwenRequestPersonalization(
   let currentSettings: any = null;
   let payload = buildQwenSettingsUpdatePayload(currentSettings, instruction);
 
-  const sent = textSize(instruction);
-  const syncHash = sent.hash ? `${sent.hash}:${QWEN_SAFE_SETTINGS_HASH}` : null;
   const bypassCache = metadata.forceSync === true;
 
   // 1. Check memory cache (skipped on forceSync)
@@ -2502,15 +2558,23 @@ function parseQwenJsonError(
 
   if (errorJson?.success === false) {
     const code = errorJson.data?.code || errorJson.code || "UpstreamError";
+    const detailsStr = typeof details === "string" ? details : "";
+    const codeStr = String(code).toLowerCase();
+    const detailsLower = detailsStr.toLowerCase();
 
-    if (
+    const isAuthExpired =
       status === 401 ||
-      code === "Unauthorized" ||
-      (typeof details === "string" &&
-        (details.includes("login") || details.includes("session")))
-    ) {
+      codeStr.includes("unauthorized") ||
+      detailsLower.includes("token has expired") ||
+      detailsLower.includes("log in") ||
+      detailsLower.includes("login") ||
+      detailsLower.includes("session") ||
+      detailsLower.includes("não autorizado") ||
+      detailsLower.includes("unauthorized");
+
+    if (isAuthExpired) {
       return new QwenSessionExpiredError(
-        `Session expired: ${details}`,
+        `Session expired: ${detailsStr || codeStr}`,
         accountId || "global",
       );
     }
@@ -3301,8 +3365,29 @@ async function createQwenStreamInternal(
           );
         }
 
+        const parsedJsonErr = parseQwenJsonError(errText, response.status, accountId);
+        if (
+          parsedJsonErr instanceof QwenSessionExpiredError &&
+          accountId &&
+          !retriedNonSseResponse
+        ) {
+          retriedNonSseResponse = true;
+          logger.warn(
+            "[Qwen] Token expired on completion fetch (200 JSON); refreshing session and retrying",
+            { accountId, chatId: chatSessionId ?? "new" },
+          );
+          const { refreshAccountToken } = await import("./playwright.ts");
+          const refreshed = await refreshAccountToken(accountId);
+          if (refreshed.success) {
+            const fresh = await getQwenHeaders(false, accountId);
+            activeHeaders = fresh.headers;
+            response = await fetchCompletion(activeHeaders);
+            continue;
+          }
+        }
+
         throw withCreatedChatMetadata(
-          parseQwenJsonError(errText, response.status, accountId) ??
+          parsedJsonErr ??
             new QwenUpstreamError(
               `Qwen returned non-stream JSON response: ${errText.substring(0, 300)}`,
               "NonStreamJsonResponse",
@@ -3378,6 +3463,35 @@ async function createQwenStreamInternal(
             response.status,
             accountId,
           );
+          if (
+            parsedError instanceof QwenSessionExpiredError &&
+            accountId &&
+            !retriedNonSseResponse
+          ) {
+            retriedNonSseResponse = true;
+            logger.warn(
+              "[Qwen] Token expired on completion fetch (!response.ok); refreshing session and retrying",
+              { accountId, chatId: chatSessionId ?? "new", status: response.status },
+            );
+            const { refreshAccountToken } = await import("./playwright.ts");
+            const refreshed = await refreshAccountToken(accountId);
+            if (refreshed.success) {
+              const fresh = await getQwenHeaders(false, accountId);
+              activeHeaders = fresh.headers;
+              response = await fetchCompletion(activeHeaders);
+              if (response.ok && response.body) {
+                return {
+                  stream: wrapUpstreamStream(response.body, controller),
+                  headers: activeHeaders,
+                  uiSessionId: chatSessionId || "",
+                  controller,
+                  accountId: accountId ?? "global",
+                  createdNewChat,
+                  tokenEstimationContext,
+                };
+              }
+            }
+          }
           if (parsedError) {
             throw withCreatedChatMetadata(parsedError);
           }

package/src/tui/proxy-client.ts

@@ -15,6 +15,10 @@ import { isPlaywrightInitialized } from "../services/playwright.ts";
 import { getAccountConcurrencySnapshot } from "../core/account-concurrency.ts";
 import { getRssUsageSnapshot } from "../core/memory-usage.ts";
 import { metrics } from "../core/metrics.ts";
+import {
+  getAllAccountsDailyUsage,
+  getPoolDailyUsageSummary,
+} from "../core/daily-usage.ts";
 import type { ProxyStatusSnapshot } from "./types.ts";
 
 export function maskAccountIdentifier(idOrEmail: string): string {
@@ -153,13 +157,18 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
     }
   } catch {}
 
-  // Attach concurrency to accounts
+  // Attach concurrency and daily usage to accounts
+  const dailyUsageMap = getAllAccountsDailyUsage();
   const accounts = cachedAccounts.map((acc) => {
     const concurrency = concurrencyMap.get(acc.id);
+    const daily = dailyUsageMap.get(acc.id);
     return {
       ...acc,
       activeStreams: concurrency?.active ?? 0,
       streamLimit: concurrency?.limit ?? config.concurrency.maxStreamsPerAccount,
+      dailyTokens: daily?.completionTokens ?? 0,
+      dailyUsagePercent: daily?.usagePercent ?? 0,
+      dailyTurns: daily?.turnsCount ?? 0,
     };
   });
   // RAM usage
@@ -220,6 +229,7 @@ export async function fetchProxyStatus(): Promise<ProxyStatusSnapshot> {
       cacheHitRatio,
       cacheBytesSaved,
     },
+    dailyUsage: getPoolDailyUsageSummary(cachedAccounts.map((a) => a.id)),
     accounts,
   };
 }

package/src/tui/types.ts

@@ -38,6 +38,14 @@ export interface ProxyStatusSnapshot {
     cacheHitRatio?: number;
     cacheBytesSaved?: number;
   };
+  dailyUsage?: {
+    poolUsagePercent: number;
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalTokens: number;
+    totalTurns: number;
+    poolCapacityTokens: number;
+  };
   accounts: Array<{
     id: string;
     emailOrName: string;
@@ -50,5 +58,8 @@ export interface ProxyStatusSnapshot {
     isInitialized?: boolean;
     activeStreams?: number;
     streamLimit?: number;
+    dailyTokens?: number;
+    dailyUsagePercent?: number;
+    dailyTurns?: number;
   }>;
 }

package/src/tui/views/accounts-view.ts

@@ -19,6 +19,7 @@ import {
 } from "../../core/accounts.ts";
 import { ServerManager } from "../server-manager.ts";
 import { config } from "../../core/config.ts";
+import { renderProgressBar } from "./status-view.ts";
 export function formatCooldownReason(reason?: string | null, maxLen = 28): string {
   if (!reason) return theme.yellow("Cooldown ativo");
   if (
@@ -938,9 +939,11 @@ export class AccountsView implements TuiView {
     }
 
     // Left Panel: Accounts List Table
+    const showUsageCol = leftW >= 48;
+    const headerUsage = showUsageCol ? "Uso%  " : "";
     const leftContent: string[] = [
       "",
-      `  ${theme.dim("#   Conta                 Status")}`,
+      `  ${theme.dim(`#   Conta                 ${headerUsage}Status`)}`,
       `  ${theme.dim("───────────────────────────────────────")}`,
     ];
 
@@ -997,7 +1000,14 @@ export class AccountsView implements TuiView {
             : theme.muted(`○ Standby     `);
         }
 
-        const line = `${pointer}${num}${name}${status}`;
+        const usagePct = acc.dailyUsagePercent ?? 0;
+        const usagePctStr = showUsageCol
+          ? (usagePct > 0
+              ? (usagePct >= 80 ? theme.red(pad(`${usagePct}%`, 5)) : usagePct >= 40 ? theme.yellow(pad(`${usagePct}%`, 5)) : theme.cyan(pad(`${usagePct}%`, 5)))
+              : theme.dim(pad("0%", 5))) + " "
+          : "";
+
+        const line = `${pointer}${num}${name}${usagePctStr}${status}`;
         if (isHovered) {
           leftContent.push(theme.bgHover(line));
         } else if (isFocused) {
@@ -1046,6 +1056,13 @@ export class AccountsView implements TuiView {
       rightContent.push(`  ${theme.bold("Sistema ID:")} ${theme.muted(selected.id.slice(0, 14))}`);
       rightContent.push(`  ${theme.bold("Nível:")}      ${selected.priority}`);
 
+      const usagePct = selected.dailyUsagePercent ?? 0;
+      const usageTokens = selected.dailyTokens ?? 0;
+      const usageTurns = selected.dailyTurns ?? 0;
+      const usageColor = usagePct >= 80 ? theme.red : usagePct >= 40 ? theme.yellow : theme.cyan;
+      const usageBar = renderProgressBar(usagePct, 6, usageColor);
+      rightContent.push(`  ${theme.bold("Cota Hoje:")}  [${usageBar}] ${usageColor(`${usagePct}%`)} ${theme.dim(`(~${Math.round(usageTokens / 1000)}k / ${usageTurns} reqs)`)}`);
+
       const cdStatus = selected.onCooldown
         ? theme.yellow(`[!] Cooldown ${Math.round(selected.remainingCooldownMs / 60000)}m`)
         : theme.green(`${glyphs.check} Disponível`);

package/src/tui/views/status-view.ts

@@ -846,12 +846,29 @@ export class StatusView implements TuiView {
     const poolPct = accounts.length > 0 ? Math.round((availableCount / accounts.length) * 100) : 0;
     const poolColor = poolPct >= 70 ? theme.green : poolPct >= 40 ? theme.yellow : theme.red;
     const poolBar = renderProgressBar(poolPct, 8, poolColor);
+    const poolDailyUsage = data?.dailyUsage;
+    const poolUsagePct = poolDailyUsage?.poolUsagePercent ?? 0;
+    const poolUsageColor = poolUsagePct >= 80 ? theme.red : poolUsagePct >= 40 ? theme.yellow : theme.cyan;
+    const poolUsageBar = renderProgressBar(poolUsagePct, 8, poolUsageColor);
     const innerRightW = Math.max(30, rightW - 2);
-    const emailWidth = Math.max(16, Math.min(20, innerRightW - 27));
+    const showUsageCol = innerRightW >= 52;
+    const emailWidth = showUsageCol
+      ? Math.max(14, Math.min(18, innerRightW - 33))
+      : Math.max(16, Math.min(20, innerRightW - 27));
+
     const rightContent: string[] = [
       `  ${theme.bold("Disponibilidade:")} [${poolBar}] ${poolColor(`${availableCount}/${accounts.length} (${poolPct}%)`)}`,
+      ...(poolDailyUsage
+        ? [
+            `  ${theme.bold("Cota Pool Hoje:")} [${poolUsageBar}] ${poolUsageColor(
+              `${poolUsagePct}%`,
+            )} ${theme.dim(
+              `(~${Math.round(poolDailyUsage.totalTokens / 1000)}k tok)`,
+            )}`,
+          ]
+        : []),
       `  ${theme.dim("─".repeat(Math.max(32, innerRightW - 2)))}`,
-      `  ${theme.dim(`#   ${pad("Conta", emailWidth)} Carga  Status`)}`,
+      `  ${theme.dim(`#   ${pad("Conta", emailWidth)} Carga  ${showUsageCol ? "Uso%  " : ""}Status`)}`,
       `  ${theme.dim("─".repeat(Math.max(32, innerRightW - 2)))}`,
     ];
 
@@ -864,7 +881,23 @@ export class StatusView implements TuiView {
         const name = pad(truncate(acc.emailOrName, emailWidth - 1), emailWidth);
         const active = acc.activeStreams || 0;
         const limit = acc.streamLimit || 1;
-        const loadBadge = active > 0 ? theme.yellow(`[${active}/${limit}]`) : theme.dim(`[0/${limit}]`);
+        const usagePct = acc.dailyUsagePercent ?? 0;
+
+        let loadBadge: string;
+        if (active > 0) {
+          loadBadge = theme.yellow(`[${active}/${limit}]`);
+        } else if (!showUsageCol && usagePct > 0) {
+          const pctColor = usagePct >= 80 ? theme.red : usagePct >= 40 ? theme.yellow : theme.cyan;
+          loadBadge = pctColor(pad(`[${usagePct}%]`, 5));
+        } else {
+          loadBadge = theme.dim(`[0/${limit}]`);
+        }
+
+        const usageCol = showUsageCol
+          ? (usagePct > 0
+              ? (usagePct >= 80 ? theme.red(pad(`${usagePct}%`, 5)) : usagePct >= 40 ? theme.yellow(pad(`${usagePct}%`, 5)) : theme.cyan(pad(`${usagePct}%`, 5)))
+              : theme.dim(pad("0%", 5))) + " "
+          : "";
 
         let status = theme.green(`${glyphs.bullet} Pronto`);
         if (active > 0 && !acc.onCooldown && acc.headersReady) {
@@ -888,7 +921,7 @@ export class StatusView implements TuiView {
             ? theme.yellow(`◐ Aquecendo...`)
             : theme.muted(`○ Standby`);
         }
-        rightContent.push(`  ${num}${name} ${loadBadge} ${status}`);
+        rightContent.push(`  ${num}${name} ${loadBadge} ${usageCol}${status}`);
       });
     }