qwenproxy-cli 1.6.10 → 1.6.12

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,
@@ -992,7 +1006,7 @@ export async function requestQwenTextInBrowser(
 
   const evaluateRequest = (page: Page) =>
     page.evaluate(
-      async ({ url, method, headers, body, referrer, timeoutMs, tz }: {
+      async ({ url, method, headers, body, referrer, timeoutMs, tz, version }: {
         url: string;
         method: "GET" | "POST" | "DELETE";
         headers: Record<string, string>;
@@ -1000,6 +1014,7 @@ export async function requestQwenTextInBrowser(
         referrer?: string;
         timeoutMs: number;
         tz: string;
+        version: string;
       }): Promise<BrowserTextResponse> => {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
@@ -1024,7 +1039,7 @@ export async function requestQwenTextInBrowser(
                   headers: {
                     accept: "application/json, text/plain, */*",
                     source: "web",
-                    version: "0.3.11",
+                    version,
                     "x-request-origin": "https://chat.qwen.ai",
                     timezone: tz,
                     authorization: `Bearer ${rTok}`,
@@ -1073,6 +1088,7 @@ export async function requestQwenTextInBrowser(
         referrer: options.referrer,
         timeoutMs: options.timeoutMs ?? Math.min(config.timeouts.page, 20_000),
         tz: formatAsciiTimezone(),
+        version: getQwenWebVersion(),
       },
     );
   const recoverOnTimeout = !options.noMutexRecovery;
@@ -1364,12 +1380,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 +1419,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 {}
           };
         }
@@ -2369,7 +2397,7 @@ export async function deleteSingleQwenChat(
 
   const requestHeaders: Record<string, string> = {
     source: "web",
-    version: getQwenWebVersion() || "0.3.26",
+    version: getQwenWebVersion(),
     timezone: formatAsciiTimezone(),
     "x-request-id": crypto.randomUUID(),
     Referer: qwenUrl(`/c/${encodeURIComponent(chatId)}`),
@@ -2422,7 +2450,7 @@ export async function fetchRemoteQwenChats(
   }
 
   const requestHeaders: Record<string, string> = {
-    version: getQwenWebVersion() || "0.3.26",
+    version: getQwenWebVersion(),
     timezone: formatAsciiTimezone(),
     "x-request-id": crypto.randomUUID(),
     Referer: qwenUrl("/settings/chats"),

package/src/services/session-keeper.ts

@@ -13,6 +13,55 @@ let running = false;
 let intervalId: ReturnType<typeof setInterval> | null = null;
 let cycleInProgress = false;
 
+/**
+ * A keep-alive failure (navigation timeout, transient WAF, closed context
+ * that is not yet reported as closed) must not retry on every cycle: it would
+ * hammer the same broken page and bury the logs. Back off per account with the
+ * usual exponential schedule, capped at five minutes.
+ */
+const KEEP_ALIVE_BACKOFF_BASE_MS = 2_000;
+const KEEP_ALIVE_BACKOFF_MAX_MS = 5 * 60_000;
+
+interface KeepAliveRetryState {
+  failures: number;
+  nextAttemptAt: number;
+}
+
+const keepAliveRetries = new Map<string, KeepAliveRetryState>();
+
+export function computeSessionKeeperBackoffMs(failures: number): number {
+  const exponent = Math.max(0, Math.min(failures - 1, 8));
+  return Math.min(
+    KEEP_ALIVE_BACKOFF_MAX_MS,
+    KEEP_ALIVE_BACKOFF_BASE_MS * 2 ** exponent,
+  );
+}
+
+function isKeepAliveBackedOff(accountId: string): boolean {
+  const state = keepAliveRetries.get(accountId);
+  return Boolean(state && Date.now() < state.nextAttemptAt);
+}
+
+function recordKeepAliveFailure(accountId: string): number {
+  const state = keepAliveRetries.get(accountId) ?? {
+    failures: 0,
+    nextAttemptAt: 0,
+  };
+  state.failures += 1;
+  const backoffMs = computeSessionKeeperBackoffMs(state.failures);
+  state.nextAttemptAt = Date.now() + backoffMs;
+  keepAliveRetries.set(accountId, state);
+  return backoffMs;
+}
+
+export function resetSessionKeeperRetryStateForTests(): void {
+  keepAliveRetries.clear();
+}
+
+export function isSessionKeeperAccountBackedOff(accountId: string): boolean {
+  return isKeepAliveBackedOff(accountId);
+}
+
 export function isSessionKeeperRunning(): boolean {
   return running;
 }
@@ -24,19 +73,31 @@ async function runKeepAliveCycle(): Promise<void> {
     if (config.sessionKeeper.enabled) {
       const accountIds = getActivePlaywrightAccountIds();
       for (const accountId of accountIds) {
-        await keepAlivePlaywrightAccount(accountId).catch((error) => {
+        if (isKeepAliveBackedOff(accountId)) {
+          continue;
+        }
+        try {
+          const keptAlive = await keepAlivePlaywrightAccount(accountId);
+          if (keptAlive) {
+            keepAliveRetries.delete(accountId);
+          }
+        } catch (error) {
           // Shutdown/eviction closes contexts while a cycle is in flight; the
           // resulting "already closed" rejection is benign. The old substring
           // filter ("Target closed"/"Page is closed") missed Playwright's real
           // message ("Target page, context or browser has been closed") and
           // leaked a warning on every Ctrl+C.
-          if (isPlaywrightAlreadyClosedError(error)) return;
-          const message =
-            error instanceof Error ? error.message : String(error);
-          console.warn(
-            `[SessionKeeper] Keep-alive failed for ${accountId}: ${message}`,
-          );
-        });
+          if (isPlaywrightAlreadyClosedError(error)) {
+            keepAliveRetries.delete(accountId);
+          } else {
+            const message =
+              error instanceof Error ? error.message : String(error);
+            const backoffMs = recordKeepAliveFailure(accountId);
+            console.warn(
+              `[SessionKeeper] Keep-alive failed for ${accountId}: ${message} (retry in ${Math.round(backoffMs / 1000)}s)`,
+            );
+          }
+        }
         await sleep(humanDelay(250, 900));
       }
     }
@@ -81,6 +142,7 @@ export function stopSessionKeeper(): void {
     intervalId = null;
   }
   cycleInProgress = false;
+  keepAliveRetries.clear();
 }
 
 export async function runSessionKeeperOnceForTesting(): Promise<void> {