qwenproxy-cli 1.6.10 → 1.6.11

package/src/core/version.ts

@@ -17,6 +17,6 @@ export function getAppVersion(): string {
       }
     }
   } catch {}
-  cachedVersion = "v1.6.10";
+  cachedVersion = "v1.6.11";
   return cachedVersion;
 }

package/src/core/watchdog.ts

@@ -148,14 +148,15 @@ export class Watchdog extends EventEmitter {
     // (idle mutex, no active stream, preserves the max-active-context minimum)
     // so the next health check sees the freed RSS.
     try {
-      const { closeIdlePlaywrightAccounts } = await import(
+      const { closeIdlePlaywrightAccounts, evictIdlePlaywrightContextsToLimit } = await import(
         "../services/playwright.js"
       );
+      const evicted = await evictIdlePlaywrightContextsToLimit(1);
       const closed = await closeIdlePlaywrightAccounts(
         config.sessionKeeper.idleMs,
       );
-      if (closed > 0) {
-        this.emit("recovery:ram:contexts-closed", closed);
+      if (evicted + closed > 0) {
+        this.emit("recovery:ram:contexts-closed", evicted + closed);
       }
     } catch {
       // Playwright may not be initialized (mock mode / pre-start); RSS relief

package/src/routes/chat/account.ts

@@ -8,6 +8,7 @@ import {
 } from "../../core/account-manager.ts";
 import { markAccountSuccessful, markAccountFailed, getAccountsByPriority } from "../../core/account-priority.ts";
 import { recordWafHardBlock, noteWafRecovery } from "../../core/waf-isolation.ts";
+import { isCaptchaRecoveryInBackoff } from "../../services/captcha-coordinator.ts";
 import { loadAccounts, type QwenAccount } from "../../core/accounts.ts";
 import { config, type ChatMode } from "../../core/config.ts";
 import { ClientAbortedError, UpstreamRateLimit, ValidationError } from "../../core/errors.ts";
@@ -1615,6 +1616,17 @@ async function tryCreateStreamWithRetry(
 			invalidateLogicalThreadParent(params.sessionId);
 		}
 
+		// If captcha recovery on this account already failed and is in its 30s
+		// backoff window, same-account retries will only hit `recovery_skipped`
+		// and waste time/RAM re-sending large payloads. Exit immediately so the
+		// outer loop quarantines this account and switches to a fresh one.
+		if (
+			policy.reason === "anti_bot" &&
+			isCaptchaRecoveryInBackoff(currentAccountId)
+		) {
+			return { success: false, error: err };
+		}
+
 		// A generic invalid_input is often a stale/corrupted upstream chat rather
 		// than an account failure. Rebuild it once on the same account first. If the
 		// fresh chat fails again, the normal policy is allowed to rotate.

package/src/routes/chat/streaming.ts

@@ -1259,8 +1259,8 @@ export async function processStreamingResponse(
       };
 
       const emitAnswerText = async (textChunk: string) => {
-        if (textChunk) emittedModelOutput = true;
         if (!toolParser) {
+          if (textChunk) emittedModelOutput = true;
           finalContent += textChunk;
           writeDeltaEvent({ content: textChunk });
           return;
@@ -1777,6 +1777,23 @@ export async function processStreamingResponse(
               .replace(/\\\\/g, "\\");
 
             if (unescaped) {
+              if (!emittedModelOutput && isOverloadMessage(unescaped)) {
+                const overloadErr = toRetryableStreamError(
+                  "server_overloaded",
+                  unescaped,
+                  {
+                    switchAccount: true,
+                    forceNewChat: true,
+                    reason: "server_busy",
+                    accountCooldownMs: OVERLOAD_COOLDOWN_MS,
+                    accountCooldownReason: "ServerOverloaded",
+                  },
+                );
+                if (await recoverFromStreamError(overloadErr)) {
+                  break;
+                }
+                throw overloadErr;
+              }
               const result = getIncrementalDelta(
                 lastRawContent,
                 unescaped,
@@ -1942,7 +1959,6 @@ export async function processStreamingResponse(
               if (vStr === "FINISHED") continue;
 
               if (isThinkingChunk) {
-                emittedModelOutput = true;
                 reasoningBuffer += vStr;
                 writeDeltaEvent({ reasoning_content: vStr });
               } else {

package/src/services/captcha-coordinator.ts

@@ -92,6 +92,12 @@ export async function solveChallengeOnPage(
  * a punish document that is never rendered; opening that document in the page
  * is what gives the solver a slider to drive.
  */
+export function isCaptchaRecoveryInBackoff(accountId: string | undefined): boolean {
+  if (!accountId) return false;
+  const lastFailure = lastFailedRecoveryAt.get(accountId) ?? 0;
+  return Date.now() - lastFailure < FAILED_RECOVERY_BACKOFF_MS;
+}
+
 export async function recoverBaxiaCaptcha(
   accountId: string | undefined,
   label: string,
@@ -126,19 +132,41 @@ export async function recoverBaxiaCaptcha(
 
   activeCaptchaRecoveries.add(accountId);
   try {
-    const { abortActiveBrowserStreamsForAccount } = await import("./qwen.ts");
-    abortActiveBrowserStreamsForAccount(
-      accountId,
-      "Account stream interrupted by captcha challenge recovery",
-    );
-  } catch {}
-  try {
+    const { hasActiveBrowserStreamsForAccount } = await import("./qwen.ts");
+    const hasConcurrentStream = hasActiveBrowserStreamsForAccount(accountId);
+
     // recoverOnTimeout: false ensures that if the captcha solve times out,
     // withAccountPage does NOT destructively kill the browser context, which
     // previously caused "Target page, context or browser has been closed" mid-slider.
     const solved = await withAccountPage(
       accountId,
-      (page) => solveChallengeOnPage(page, challengeUrl),
+      async (page) => {
+        // If another stream is actively running on this account's primary page,
+        // NEVER navigate `page` away (which would unload its DOM and kill the stream).
+        // Instead, try in-place modal solve first, or open an ephemeral tab in the
+        // same BrowserContext so cookies/x5sec are solved without touching `page`.
+        if (hasConcurrentStream) {
+          const solverOptions = {
+            maxAttempts: config.captcha.maxAttempts,
+            retryDelayMs: config.captcha.retryDelayMs,
+            settleMs: config.captcha.settleMs,
+          };
+          if (await solveBaxiaCaptcha(page, { ...solverOptions, waitForMs: 0 })) {
+            return true;
+          }
+          const ctx = typeof page.context === "function" ? page.context() : null;
+          if (ctx && typeof ctx.newPage === "function") {
+            const tempPage = await ctx.newPage();
+            try {
+              return await solveChallengeOnPage(tempPage, challengeUrl);
+            } finally {
+              await tempPage.close({ runBeforeUnload: false }).catch(() => {});
+            }
+          }
+          return false;
+        }
+        return await solveChallengeOnPage(page, challengeUrl);
+      },
       solverOperationTimeoutMs,
       solverOperationTimeoutMs,
       false,

package/src/services/chat-cleanup.ts

@@ -79,7 +79,15 @@ export async function deleteChatsForAccountId(accountId: string): Promise<boolea
   if (!credentials) {
     throw new Error(`Credenciais da conta ${account.email} não encontradas.`);
   }
-  return deleteChatsForAccount(credentials);
+  const wasInitialized = isPlaywrightInitialized(account.id);
+  try {
+    return await deleteChatsForAccount(credentials);
+  } finally {
+    if (!wasInitialized && !isAuthMockEnabled()) {
+      const { closePlaywrightForAccount } = await import("./playwright.ts");
+      await closePlaywrightForAccount(account.id).catch(() => {});
+    }
+  }
 }
 
 export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false): Promise<DeleteChatsResult> {
@@ -100,6 +108,7 @@ export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false):
       const account = accounts[i];
       const currentIdx = i + 1;
       const totalCount = accounts.length;
+      const wasInitialized = isPlaywrightInitialized(account.id);
       try {
         const ok = await deleteChatsForAccount(account, currentIdx, totalCount);
         if (ok) succeeded++;
@@ -109,7 +118,7 @@ export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false):
           error instanceof Error ? error.message : String(error),
         );
       } finally {
-        if (!keepBrowserOpen) {
+        if ((!keepBrowserOpen || !wasInitialized) && !isAuthMockEnabled()) {
           const { closePlaywrightForAccount } = await import("./playwright.ts");
           await closePlaywrightForAccount(account.id).catch(() => {});
         }

package/src/services/playwright.ts

@@ -68,6 +68,7 @@ import {
   unmarkAccountHeadersReady,
   isAccountHeadersReady,
   markAccountRateLimited,
+  getAccountCooldownInfo,
 } from "../core/account-manager.ts";
 import { getAccountsByPriority } from "../core/account-priority.ts";
 import {
@@ -1408,18 +1409,19 @@ export async function getBasicHeaders(accountId: string): Promise<{
     } else if (
       hadUsableHeaders &&
       headersAge > HEADER_CACHE_TTL * HEADER_REFRESH_THRESHOLD &&
-      !cache.refreshInProgress
+      !cache.refreshInProgress &&
+      // Header capture types into the chat input and sends a probe message on
+      // the account's page. Doing that while the account is serving a stream
+      // would mutate the live conversation (and can navigate the SPA), so the
+      // proactive refresh waits until the account has no active lease.
+      !hasActiveAccountLease(accountId)
     ) {
       // Background refresh at 70% TTL: keep headers fresh without blocking
-      cache.refreshInProgress = true;
       refreshHeadersInternal(accountId)
         .catch((error) => {
           console.warn(
             `⚠️  [Playwright] Background header refresh failed for ${accountId}: ${getErrorMessage(error)}`,
           );
-        })
-        .finally(() => {
-          cache.refreshInProgress = false;
         });
     }
 
@@ -1569,8 +1571,13 @@ export async function initPlaywrightForAccount(
         return;
       }
 
-    // If a context limit is configured, make room by closing idle contexts.
-    await evictIdlePlaywrightContextsToLimit().catch(() => {});
+    // If a context limit is configured, make room BEFORE launching by evicting down to (max - 1)
+    // so the new context brings total active contexts to at most max.
+    if (config.playwright.maxActiveContexts > 0) {
+      await evictIdlePlaywrightContextsToLimit(
+        Math.max(1, config.playwright.maxActiveContexts - 1),
+      ).catch(() => {});
+    }
 
     const profilePath = getAccountProfilePath(account.id);
     const fingerprint = getFingerprintProfile(account.id);
@@ -1882,12 +1889,17 @@ export async function initPlaywrightForAccount(
         await captureQwenHeaders(account.id);
       }
 
-      // Header capture may leave the UI on a generated chat page. Return the
-      // primary tab to the canonical chat home.
+      // Header capture may leave the UI on a punish or auth page. Return the
+      // primary tab to the canonical chat home only when not already on a clean Qwen page.
       if (!acctPage.isClosed()) {
         try {
           const currentUrl = new URL(acctPage.url());
-          if (currentUrl.origin !== qwenOrigin() || currentUrl.pathname !== "/") {
+          if (
+            currentUrl.origin !== qwenOrigin() ||
+            currentUrl.pathname.includes("/auth") ||
+            currentUrl.pathname.includes("/login") ||
+            currentUrl.pathname.includes("_____tmd_____")
+          ) {
             await acctPage.goto(qwenUrl("/"), {
               waitUntil: "domcontentloaded",
               timeout: config.timeouts.navigation,
@@ -1907,6 +1919,7 @@ export async function initPlaywrightForAccount(
     } finally {
       release();
     }
+    await evictIdlePlaywrightContextsToLimit().catch(() => {});
   })();
 
   try {
@@ -4171,19 +4184,32 @@ async function refreshHeadersInternal(
         await executeReauth();
       } else {
         try {
-          await page.goto(qwenUrl("/"), {
-            waitUntil: "domcontentloaded",
-            timeout: Math.min(
-              config.timeouts.navigation,
-              boundedTimeoutMs,
-              SESSION_PROBE_NAVIGATION_TIMEOUT_MS,
-            ),
-          });
-          await sleep(2000);
-          const url = page.url();
+          const currentUrl = typeof page.url === "function" ? page.url() : "";
+          const needsNavigation =
+            !currentUrl.startsWith(qwenOrigin()) ||
+            currentUrl.includes("/auth") ||
+            currentUrl.includes("/login") ||
+            currentUrl.includes("_____tmd_____");
+
+          if (needsNavigation) {
+            await page.goto(qwenUrl("/"), {
+              waitUntil: "domcontentloaded",
+              timeout: Math.min(
+                config.timeouts.navigation,
+                boundedTimeoutMs,
+                SESSION_PROBE_NAVIGATION_TIMEOUT_MS,
+              ),
+            });
+            await sleep(2000);
+          }
+
+          const url = typeof page.url === "function" ? page.url() : "";
           const isAuthUrl = url.includes("auth") || url.includes("login");
           if (isAuthUrl) {
-            await executeReauth();
+            const refreshed = await refreshAccountToken(accountId);
+            if (!refreshed.success) {
+              await executeReauth();
+            }
           }
         } catch (navErr) {
           console.warn(
@@ -4243,12 +4269,18 @@ async function refreshHeadersInternal(
 
     await captureQwenHeaders(accountId, undefined, boundedTimeoutMs);
 
-    // Best-effort restore: header capture can leave the tab on a chat page.
+    // Best-effort restore: if header capture left the tab on a punish/auth URL,
+    // return to the canonical chat home without reloading an already-clean Qwen page.
     const capturedPage = accountPages.get(accountId);
     if (capturedPage && !capturedPage.isClosed()) {
       try {
         const currentUrl = new URL(capturedPage.url());
-        if (currentUrl.origin !== qwenOrigin() || currentUrl.pathname !== "/") {
+        if (
+          currentUrl.origin !== qwenOrigin() ||
+          currentUrl.pathname.includes("/auth") ||
+          currentUrl.pathname.includes("/login") ||
+          currentUrl.pathname.includes("_____tmd_____")
+        ) {
           await capturedPage.goto(qwenUrl("/"), {
             waitUntil: "domcontentloaded",
             timeout: Math.min(config.timeouts.navigation, boundedTimeoutMs),
@@ -4693,7 +4725,13 @@ function priorityOrderForEviction(accountIds: string[]): string[] {
   const ranked = getAccountsByPriority(accountIds.map((id) => ({ id })));
   const rank = new Map<string, number>();
   for (const [index, account] of ranked.entries()) {
-    rank.set(account.id, index);
+    // Accounts currently on cooldown (RateLimited / MembershipLimit / WafChallenge)
+    // cannot serve traffic and must be evicted before any healthy warm account.
+    if (getAccountCooldownInfo(account.id)) {
+      rank.set(account.id, Number.MAX_SAFE_INTEGER);
+    } else {
+      rank.set(account.id, index);
+    }
   }
   return orderContextsForEviction(
     accountIds,
@@ -4750,15 +4788,21 @@ export async function closeIdlePlaywrightAccounts(
  * PLAYWRIGHT_MAX_ACTIVE_CONTEXTS. Never closes a context whose account mutex
  * is busy, so active streams are preserved.
  */
-export async function evictIdlePlaywrightContextsToLimit(): Promise<number> {
-  const max = config.playwright.maxActiveContexts;
-  if (max <= 0) return 0;
+export async function evictIdlePlaywrightContextsToLimit(
+  targetLimit?: number,
+): Promise<number> {
+  const configuredMax = config.playwright.maxActiveContexts;
+  if (configuredMax <= 0) return 0;
+  const max = targetLimit !== undefined ? Math.max(0, targetLimit) : configuredMax;
   if (accountPages.size <= max) return 0;
 
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
       if (isAccountServingStream(accountId)) return false;
-      if (isAccountRecentlyActive(accountId, 30_000)) return false;
+      // A request may hold a stream lease while still acquiring the page mutex
+      // (pre-stream setup). Closing that context would fail the request even
+      // though the mutex still looks idle, so treat any lease as "in use".
+      if (hasActiveAccountLease(accountId)) return false;
       const mutex = accountMutexes.get(accountId);
       return mutex?.isIdle();
     }),
@@ -4772,6 +4816,7 @@ export async function evictIdlePlaywrightContextsToLimit(): Promise<number> {
   for (const candidate of candidates) {
     if (accountPages.size <= max) break;
     if (isAccountServingStream(candidate.accountId)) continue;
+    if (hasActiveAccountLease(candidate.accountId)) continue;
     const mutex = accountMutexes.get(candidate.accountId);
     if (!mutex?.isIdle()) continue;
 

package/src/services/qwen.ts

@@ -129,6 +129,20 @@ const browserStreamStates = new Map<string, BrowserStreamState>();
 const browserStreamBindingPages = new WeakSet<object>();
 const browserStreamBindingContexts = new WeakSet<object>();
 
+/**
+ * Whether the account currently has an in-flight browser stream. Captcha
+ * recovery uses this to avoid navigating the page that is feeding a live
+ * stream (it opens an ephemeral tab instead).
+ */
+export function hasActiveBrowserStreamsForAccount(accountId: string): boolean {
+  for (const state of browserStreamStates.values()) {
+    if (state.accountId === accountId && !state.done) {
+      return true;
+    }
+  }
+  return false;
+}
+
 /**
  * Abort all active browser streams for an account immediately.
  * Called when an account page is navigated by captcha recovery, closed, or reset,
@@ -1364,12 +1378,22 @@ async function createQwenBrowserResponse(
         await ensureBrowserStreamBinding(page);
         if (typeof (page as any).on === "function") {
           const onFrameNavigated = (frame: any) => {
-            if (!settled && typeof (page as any).mainFrame === "function" && frame === (page as any).mainFrame()) {
-              const url = typeof frame.url === "function" ? frame.url() : String(frame.url || "");
-              // Safe SPA in-app routing within Qwen Web (e.g. /c/<id>, /#) must NEVER abort active streams
+            if (
+              !settled &&
+              typeof (page as any).mainFrame === "function" &&
+              frame === (page as any).mainFrame()
+            ) {
+              const url =
+                typeof frame.url === "function"
+                  ? frame.url()
+                  : String(frame.url || "");
+              // Same-origin SPA routing within Qwen Web (e.g. /c/<id>, /#) keeps
+              // the live DOM and MUST NOT abort the stream. Only a genuine
+              // unload (auth, Baxia punish, or another origin) kills the fetch.
               if (
                 url.startsWith(qwenOrigin()) &&
                 !url.includes("/auth") &&
+                !url.includes("/login") &&
                 !url.includes("_____tmd_____") &&
                 !url.includes("/punish")
               ) {
@@ -1393,10 +1417,12 @@ async function createQwenBrowserResponse(
           };
           (page as any).on("framenavigated", onFrameNavigated);
           (page as any).on("close", onPageClosed);
+          (page as any).on("crash", onPageClosed);
           pageCleanup = () => {
             try {
               (page as any).off?.("framenavigated", onFrameNavigated);
               (page as any).off?.("close", onPageClosed);
+              (page as any).off?.("crash", onPageClosed);
             } catch {}
           };
         }