qwenproxy-cli 1.6.2 → 1.6.4

package/dist/clean-cache.js

@@ -14,6 +14,25 @@ var __export = (target, all) => {
 };
 
 // src/core/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  ensureDataDirs: () => ensureDataDirs,
+  getAccountPriorityPath: () => getAccountPriorityPath,
+  getAccountProfilePath: () => getAccountProfilePath,
+  getDataDir: () => getDataDir,
+  getDbDir: () => getDbDir,
+  getDbPath: () => getDbPath,
+  getEncryptionKeyPath: () => getEncryptionKeyPath,
+  getEnvFilePath: () => getEnvFilePath,
+  getLogsDir: () => getLogsDir,
+  getOsGlobalDataDir: () => getOsGlobalDataDir,
+  getProfilesDir: () => getProfilesDir,
+  getServerLogFilePath: () => getServerLogFilePath,
+  getSyncStatePath: () => getSyncStatePath,
+  getTuiSettingsPath: () => getTuiSettingsPath,
+  isRunningUnderNodeTest: () => isRunningUnderNodeTest,
+  resolveDataDir: () => resolveDataDir
+});
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -78,6 +97,12 @@ function getAccountProfilePath(accountId, customDataDir) {
 function getAccountPriorityPath(customDataDir) {
   return path.join(customDataDir || getDataDir(), "account-priority.json");
 }
+function getSyncStatePath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "sync-state.json");
+}
+function getTuiSettingsPath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "tui-settings.json");
+}
 function getEnvFilePath(customDataDir) {
   if (isRunningUnderNodeTest()) {
     return path.join(customDataDir || getDataDir(), ".env");
@@ -88,6 +113,26 @@ function getEnvFilePath(customDataDir) {
   }
   return path.join(customDataDir || getDataDir(), ".env");
 }
+function getLogsDir(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "logs");
+}
+function getServerLogFilePath(customDataDir) {
+  return path.join(getLogsDir(customDataDir), "server.log");
+}
+function ensureDataDirs(targetDataDir) {
+  const root = targetDataDir || getDataDir();
+  const dbDir = getDbDir(root);
+  const profilesDir = getProfilesDir(root);
+  const logsDir = getLogsDir(root);
+  try {
+    if (!fs.existsSync(root)) fs.mkdirSync(root, { recursive: true });
+    if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+    if (!fs.existsSync(profilesDir)) fs.mkdirSync(profilesDir, { recursive: true });
+    if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
+  } catch (err) {
+    console.error(`[Paths] Error ensuring data directories at ${root}:`, err?.message || String(err));
+  }
+}
 var init_paths = __esm({
   "src/core/paths.ts"() {
     "use strict";
@@ -2796,9 +2841,10 @@ function getAccountMutex(accountId) {
 async function recoverStuckAccountMutex(accountId, mutex, key) {
   if (accountMutexes.get(accountId) !== mutex) return;
   const lockState = mutex.state();
-  if (lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS || lockState.heldBy.startsWith("init:") || isAccountServingStream(accountId)) {
+  const minLockTimeout = Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers);
+  if (lockState.heldForMs < minLockTimeout || lockState.heldBy.startsWith("init:") || lockState.heldBy.startsWith("headers:") || lockState.heldBy.startsWith("refresh:") || lockState.heldBy.startsWith("profile-reset:") || isAccountServingStream(accountId)) {
     logger.warn(
-      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${minLockTimeout}ms | servingStream=${isAccountServingStream(accountId)}`
     );
     return;
   }
@@ -4470,7 +4516,24 @@ async function refreshAccountToken(accountId) {
   return { success: false, error: "Could not refresh or re-authenticate token" };
 }
 async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.timeouts.headers, triggerGraceMs = HEADER_CAPTURE_TRIGGER_GRACE_MS) {
-  const page = pageOverride ?? accountPages.get(accountId);
+  let page = pageOverride ?? accountPages.get(accountId);
+  if (!page || page.isClosed()) {
+    const { isRunningUnderNodeTest: isRunningUnderNodeTest3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+    if (!isRunningUnderNodeTest3()) {
+      const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+      const creds = getAccountCredentials2(accountId);
+      if (creds) {
+        await initPlaywrightForAccount(
+          creds,
+          config.playwright.headless,
+          config.playwright.browser,
+          { skipHeaderCapture: true }
+        ).catch(() => {
+        });
+        page = accountPages.get(accountId);
+      }
+    }
+  }
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for header capture: ${accountId}`);
   }
@@ -5171,8 +5234,10 @@ async function evictIdlePlaywrightContextsToLimit() {
   if (accountPages.size <= max) return 0;
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
+      if (isAccountServingStream(accountId)) return false;
+      if (isAccountRecentlyActive(accountId, 3e4)) return false;
       const mutex = accountMutexes.get(accountId);
-      return mutex?.isIdle() && !isAccountServingStream(accountId);
+      return mutex?.isIdle();
     })
   ).map((accountId) => ({
     accountId,
@@ -5285,6 +5350,10 @@ async function closePlaywrightForAccount(accountId) {
     release();
   }
 }
+function isAccountRecentlyActive(accountId, maxIdleMs = 3e5) {
+  const last = lastAccountActivity.get(accountId) ?? 0;
+  return last > 0 && Date.now() - last < maxIdleMs;
+}
 var requireLocal, contextInitHooks, ACCOUNT_MUTEX_MAX_HOLD_MS, accountMutexes, accountContexts, accountPages, inFlightAccountInits, headerCaches, HEADER_CACHE_TTL, COOKIE_CACHE_TTL, cookieCaches, lastAccountActivity, lastKeepAliveNavigation, lastProactiveTokenRefresh, profileResetQueue, profileResetChain, closingAllPlaywright, sleep2, HEADER_CAPTURE_SETTLE_MS, PLAYWRIGHT_MUTEX_WAIT_MS, ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, SESSION_PROBE_NAVIGATION_TIMEOUT_MS, HEADER_CAPTURE_TRIGGER_GRACE_MS, FIRST_TRIGGER_GRACE_MS, HEADER_CAPTURE_TRIGGER_ATTEMPTS, CHAT_INPUT_APPEAR_TIMEOUT_MS, CHAT_INPUT_ACTION_TIMEOUT_MS, PROFILE_RESET_TIMEOUT_MS;
 var init_playwright = __esm({
   "src/services/playwright.ts"() {

package/dist/delete-chats.js

@@ -52,6 +52,25 @@ var init_process_guard = __esm({
 });
 
 // src/core/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  ensureDataDirs: () => ensureDataDirs,
+  getAccountPriorityPath: () => getAccountPriorityPath,
+  getAccountProfilePath: () => getAccountProfilePath,
+  getDataDir: () => getDataDir,
+  getDbDir: () => getDbDir,
+  getDbPath: () => getDbPath,
+  getEncryptionKeyPath: () => getEncryptionKeyPath,
+  getEnvFilePath: () => getEnvFilePath,
+  getLogsDir: () => getLogsDir,
+  getOsGlobalDataDir: () => getOsGlobalDataDir,
+  getProfilesDir: () => getProfilesDir,
+  getServerLogFilePath: () => getServerLogFilePath,
+  getSyncStatePath: () => getSyncStatePath,
+  getTuiSettingsPath: () => getTuiSettingsPath,
+  isRunningUnderNodeTest: () => isRunningUnderNodeTest,
+  resolveDataDir: () => resolveDataDir
+});
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -116,6 +135,12 @@ function getAccountProfilePath(accountId, customDataDir) {
 function getAccountPriorityPath(customDataDir) {
   return path.join(customDataDir || getDataDir(), "account-priority.json");
 }
+function getSyncStatePath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "sync-state.json");
+}
+function getTuiSettingsPath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "tui-settings.json");
+}
 function getEnvFilePath(customDataDir) {
   if (isRunningUnderNodeTest()) {
     return path.join(customDataDir || getDataDir(), ".env");
@@ -126,6 +151,26 @@ function getEnvFilePath(customDataDir) {
   }
   return path.join(customDataDir || getDataDir(), ".env");
 }
+function getLogsDir(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "logs");
+}
+function getServerLogFilePath(customDataDir) {
+  return path.join(getLogsDir(customDataDir), "server.log");
+}
+function ensureDataDirs(targetDataDir) {
+  const root = targetDataDir || getDataDir();
+  const dbDir = getDbDir(root);
+  const profilesDir = getProfilesDir(root);
+  const logsDir = getLogsDir(root);
+  try {
+    if (!fs.existsSync(root)) fs.mkdirSync(root, { recursive: true });
+    if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+    if (!fs.existsSync(profilesDir)) fs.mkdirSync(profilesDir, { recursive: true });
+    if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
+  } catch (err) {
+    console.error(`[Paths] Error ensuring data directories at ${root}:`, err?.message || String(err));
+  }
+}
 var init_paths = __esm({
   "src/core/paths.ts"() {
     "use strict";
@@ -3168,6 +3213,7 @@ __export(playwright_exports, {
   closeIdlePlaywrightAccounts: () => closeIdlePlaywrightAccounts,
   closePlaywrightForAccount: () => closePlaywrightForAccount,
   evictIdlePlaywrightContextsToLimit: () => evictIdlePlaywrightContextsToLimit,
+  getAccountMutex: () => getAccountMutex,
   getActivePlaywrightAccountIds: () => getActivePlaywrightAccountIds,
   getBasicHeaders: () => getBasicHeaders,
   getCookies: () => getCookies,
@@ -3317,9 +3363,10 @@ function getAccountMutex(accountId) {
 async function recoverStuckAccountMutex(accountId, mutex, key) {
   if (accountMutexes.get(accountId) !== mutex) return;
   const lockState = mutex.state();
-  if (lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS || lockState.heldBy.startsWith("init:") || isAccountServingStream(accountId)) {
+  const minLockTimeout = Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers);
+  if (lockState.heldForMs < minLockTimeout || lockState.heldBy.startsWith("init:") || lockState.heldBy.startsWith("headers:") || lockState.heldBy.startsWith("refresh:") || lockState.heldBy.startsWith("profile-reset:") || isAccountServingStream(accountId)) {
     logger.warn(
-      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${minLockTimeout}ms | servingStream=${isAccountServingStream(accountId)}`
     );
     return;
   }
@@ -4121,7 +4168,8 @@ async function getBasicHeaders(accountId) {
   }
   const release = await acquireAccountMutex(
     accountId,
-    `headers:${accountId.substring(0, 12)}`
+    `headers:${accountId.substring(0, 12)}`,
+    Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers + 3e4)
   );
   try {
     touchAccountActivity(accountId);
@@ -4214,8 +4262,10 @@ async function getBasicHeaders(accountId) {
         return { cookie: cookie2, userAgent, bxV: bxV2, bxUa: bxUa2, bxUmidtoken: bxUmidtoken2, ...clientHints };
       }
     }
+    let refreshedInThisCall = false;
     if (headersAge > HEADER_CACHE_TTL && !cache.refreshInProgress) {
       try {
+        refreshedInThisCall = true;
         await refreshHeadersInternal(accountId);
       } catch (error) {
         if (!hadUsableHeaders) throw error;
@@ -4284,7 +4334,7 @@ async function getBasicHeaders(accountId) {
       } catch {
       }
     }
-    if (!hasRequiredQwenHeaders(cache.headers)) {
+    if (!hasRequiredQwenHeaders(cache.headers) && !refreshedInThisCall) {
       console.log(
         `\u{1F504} [Playwright] Missing required anti-bot headers for ${accountId}, triggering header interception...`
       );
@@ -5727,7 +5777,24 @@ async function refreshAccountToken(accountId) {
   return { success: false, error: "Could not refresh or re-authenticate token" };
 }
 async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.timeouts.headers, triggerGraceMs = HEADER_CAPTURE_TRIGGER_GRACE_MS) {
-  const page = pageOverride ?? accountPages.get(accountId);
+  let page = pageOverride ?? accountPages.get(accountId);
+  if (!page || page.isClosed()) {
+    const { isRunningUnderNodeTest: isRunningUnderNodeTest4 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+    if (!isRunningUnderNodeTest4()) {
+      const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+      const creds = getAccountCredentials2(accountId);
+      if (creds) {
+        await initPlaywrightForAccount(
+          creds,
+          config.playwright.headless,
+          config.playwright.browser,
+          { skipHeaderCapture: true }
+        ).catch(() => {
+        });
+        page = accountPages.get(accountId);
+      }
+    }
+  }
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for header capture: ${accountId}`);
   }
@@ -6370,16 +6437,38 @@ async function refreshHeaders(accountId, timeoutMs = config.timeouts.headers, fo
     release();
   }
 }
-async function withAccountPage(accountId, fn, timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS, recoverOnTimeout = true) {
+async function ensureAccountPageAvailable(accountId) {
   const inFlightInit = inFlightAccountInits.get(accountId);
   if (inFlightInit) {
     await inFlightInit.catch(() => {
     });
   }
-  const page = accountPages.get(accountId);
+  let page = accountPages.get(accountId);
+  if (page && !page.isClosed()) {
+    return page;
+  }
+  const { isRunningUnderNodeTest: isRunningUnderNodeTest4 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+  if (isRunningUnderNodeTest4()) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+  const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+  const creds = getAccountCredentials2(accountId);
+  if (!creds) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+  await initPlaywrightForAccount(
+    creds,
+    config.playwright.headless,
+    config.playwright.browser
+  );
+  page = accountPages.get(accountId);
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for account: ${accountId}`);
   }
+  return page;
+}
+async function withAccountPage(accountId, fn, timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS, recoverOnTimeout = true) {
+  const page = await ensureAccountPageAvailable(accountId);
   const release = await acquireAccountMutex(
     accountId,
     `page:${accountId.substring(0, 12)}`,
@@ -6680,8 +6769,10 @@ async function evictIdlePlaywrightContextsToLimit() {
   if (accountPages.size <= max) return 0;
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
+      if (isAccountServingStream(accountId)) return false;
+      if (isAccountRecentlyActive(accountId, 3e4)) return false;
       const mutex = accountMutexes.get(accountId);
-      return mutex?.isIdle() && !isAccountServingStream(accountId);
+      return mutex?.isIdle();
     })
   ).map((accountId) => ({
     accountId,
@@ -8771,7 +8862,7 @@ async function withQwenBrowserPage(accountId, fn, targetPath, operationTimeoutMs
       return fn(page);
     },
     operationTimeoutMs,
-    Math.min(config.timeouts.page, 3e4),
+    Math.max(6e4, operationTimeoutMs),
     recoverOnTimeout
   );
 }

package/dist/index.js

@@ -4323,6 +4323,7 @@ __export(playwright_exports, {
   closeIdlePlaywrightAccounts: () => closeIdlePlaywrightAccounts,
   closePlaywrightForAccount: () => closePlaywrightForAccount,
   evictIdlePlaywrightContextsToLimit: () => evictIdlePlaywrightContextsToLimit,
+  getAccountMutex: () => getAccountMutex,
   getActivePlaywrightAccountIds: () => getActivePlaywrightAccountIds,
   getBasicHeaders: () => getBasicHeaders,
   getCookies: () => getCookies,
@@ -4472,9 +4473,10 @@ function getAccountMutex(accountId) {
 async function recoverStuckAccountMutex(accountId, mutex, key) {
   if (accountMutexes.get(accountId) !== mutex) return;
   const lockState = mutex.state();
-  if (lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS || lockState.heldBy.startsWith("init:") || isAccountServingStream(accountId)) {
+  const minLockTimeout = Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers);
+  if (lockState.heldForMs < minLockTimeout || lockState.heldBy.startsWith("init:") || lockState.heldBy.startsWith("headers:") || lockState.heldBy.startsWith("refresh:") || lockState.heldBy.startsWith("profile-reset:") || isAccountServingStream(accountId)) {
     logger.warn(
-      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${minLockTimeout}ms | servingStream=${isAccountServingStream(accountId)}`
     );
     return;
   }
@@ -5276,7 +5278,8 @@ async function getBasicHeaders(accountId) {
   }
   const release = await acquireAccountMutex(
     accountId,
-    `headers:${accountId.substring(0, 12)}`
+    `headers:${accountId.substring(0, 12)}`,
+    Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers + 3e4)
   );
   try {
     touchAccountActivity(accountId);
@@ -5369,8 +5372,10 @@ async function getBasicHeaders(accountId) {
         return { cookie: cookie2, userAgent, bxV: bxV2, bxUa: bxUa2, bxUmidtoken: bxUmidtoken2, ...clientHints };
       }
     }
+    let refreshedInThisCall = false;
     if (headersAge > HEADER_CACHE_TTL && !cache3.refreshInProgress) {
       try {
+        refreshedInThisCall = true;
         await refreshHeadersInternal(accountId);
       } catch (error) {
         if (!hadUsableHeaders) throw error;
@@ -5439,7 +5444,7 @@ async function getBasicHeaders(accountId) {
       } catch {
       }
     }
-    if (!hasRequiredQwenHeaders(cache3.headers)) {
+    if (!hasRequiredQwenHeaders(cache3.headers) && !refreshedInThisCall) {
       console.log(
         `\u{1F504} [Playwright] Missing required anti-bot headers for ${accountId}, triggering header interception...`
       );
@@ -6882,7 +6887,24 @@ async function refreshAccountToken(accountId) {
   return { success: false, error: "Could not refresh or re-authenticate token" };
 }
 async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.timeouts.headers, triggerGraceMs = HEADER_CAPTURE_TRIGGER_GRACE_MS) {
-  const page = pageOverride ?? accountPages.get(accountId);
+  let page = pageOverride ?? accountPages.get(accountId);
+  if (!page || page.isClosed()) {
+    const { isRunningUnderNodeTest: isRunningUnderNodeTest4 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+    if (!isRunningUnderNodeTest4()) {
+      const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+      const creds = getAccountCredentials2(accountId);
+      if (creds) {
+        await initPlaywrightForAccount(
+          creds,
+          config.playwright.headless,
+          config.playwright.browser,
+          { skipHeaderCapture: true }
+        ).catch(() => {
+        });
+        page = accountPages.get(accountId);
+      }
+    }
+  }
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for header capture: ${accountId}`);
   }
@@ -7525,16 +7547,38 @@ async function refreshHeaders(accountId, timeoutMs = config.timeouts.headers, fo
     release();
   }
 }
-async function withAccountPage(accountId, fn, timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS, recoverOnTimeout = true) {
+async function ensureAccountPageAvailable(accountId) {
   const inFlightInit = inFlightAccountInits.get(accountId);
   if (inFlightInit) {
     await inFlightInit.catch(() => {
     });
   }
-  const page = accountPages.get(accountId);
+  let page = accountPages.get(accountId);
+  if (page && !page.isClosed()) {
+    return page;
+  }
+  const { isRunningUnderNodeTest: isRunningUnderNodeTest4 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+  if (isRunningUnderNodeTest4()) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+  const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+  const creds = getAccountCredentials2(accountId);
+  if (!creds) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+  await initPlaywrightForAccount(
+    creds,
+    config.playwright.headless,
+    config.playwright.browser
+  );
+  page = accountPages.get(accountId);
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for account: ${accountId}`);
   }
+  return page;
+}
+async function withAccountPage(accountId, fn, timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS, recoverOnTimeout = true) {
+  const page = await ensureAccountPageAvailable(accountId);
   const release = await acquireAccountMutex(
     accountId,
     `page:${accountId.substring(0, 12)}`,
@@ -7835,8 +7879,10 @@ async function evictIdlePlaywrightContextsToLimit() {
   if (accountPages.size <= max) return 0;
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
+      if (isAccountServingStream(accountId)) return false;
+      if (isAccountRecentlyActive(accountId, 3e4)) return false;
       const mutex = accountMutexes.get(accountId);
-      return mutex?.isIdle() && !isAccountServingStream(accountId);
+      return mutex?.isIdle();
     })
   ).map((accountId) => ({
     accountId,
@@ -9784,7 +9830,7 @@ function isModelNotFoundError(err) {
 function isNetworkLikeError(err) {
   if (err instanceof QwenNetworkError) return true;
   const message = errMessage(err).toLowerCase();
-  return message === "network error" || message.includes("failed to fetch") || message.includes("fetch failed") || message.includes("network connection was lost") || message.includes("connection reset") || message.includes("connection closed") || message.includes("socket hang up") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("etimedout");
+  return message === "network error" || message.includes("failed to fetch") || message.includes("fetch failed") || message.includes("network connection was lost") || message.includes("connection reset") || message.includes("connection closed") || message.includes("socket hang up") || message.includes("econnreset") || message.includes("econnrefused") || message.includes("etimedout") || message.includes("stream ended before response headers") || message.includes("timed out waiting for response headers");
 }
 function isCorruptedChatHistoryError(err) {
   const message = errMessage(err).toLowerCase();
@@ -9827,6 +9873,15 @@ function classifyRetryAction(err, options) {
   if (isTerminalLocalError(err)) {
     return makeRetryAction("terminal_local", { retryable: false });
   }
+  if (err instanceof PersonalizationSyncError) {
+    return makeRetryAction("personalization_sync_failed", {
+      switchAccount: true,
+      forceNewChat: true,
+      retryAfterMs: baseDelayMs,
+      accountCooldownMs: 0,
+      accountCooldownReason: "PersonalizationFailed"
+    });
+  }
   const message = errMessage(err).toLowerCase();
   const code = errCode(err).toLowerCase();
   if (isAccountInitializationError(err)) {
@@ -9843,15 +9898,6 @@ function classifyRetryAction(err, options) {
       retryAfterMs: Math.min(baseDelayMs, 1e3)
     });
   }
-  if (err instanceof PersonalizationSyncError) {
-    return makeRetryAction("personalization_sync_failed", {
-      switchAccount: true,
-      forceNewChat: true,
-      retryAfterMs: baseDelayMs,
-      accountCooldownMs: 0,
-      accountCooldownReason: "PersonalizationFailed"
-    });
-  }
   if (code === "createchatinvalidresponse" || code === "createchatfailed" || code === "unauthorized" || message.includes("401 n\xE3o autorizado") || message.includes("n\xE3o tem permiss\xE3o para acessar") || message.includes("401 unauthorized") || message.includes('"code":"unauthorized"') || message.includes('"code": "unauthorized"') || message.includes("token has expired")) {
     return makeRetryAction("account_initialization_failed", {
       switchAccount: true,
@@ -12006,7 +12052,7 @@ async function withQwenBrowserPage(accountId, fn, targetPath, operationTimeoutMs
       return fn(page);
     },
     operationTimeoutMs,
-    Math.min(config.timeouts.page, 3e4),
+    Math.max(6e4, operationTimeoutMs),
     recoverOnTimeout
   );
 }
@@ -26782,7 +26828,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.6.2";
+  cachedVersion = "v1.6.4";
   return cachedVersion;
 }
 var cachedVersion;

package/dist/login.js

@@ -3190,6 +3190,7 @@ __export(playwright_exports, {
   closeIdlePlaywrightAccounts: () => closeIdlePlaywrightAccounts,
   closePlaywrightForAccount: () => closePlaywrightForAccount,
   evictIdlePlaywrightContextsToLimit: () => evictIdlePlaywrightContextsToLimit,
+  getAccountMutex: () => getAccountMutex,
   getActivePlaywrightAccountIds: () => getActivePlaywrightAccountIds,
   getBasicHeaders: () => getBasicHeaders,
   getCookies: () => getCookies,
@@ -3339,9 +3340,10 @@ function getAccountMutex(accountId) {
 async function recoverStuckAccountMutex(accountId, mutex, key) {
   if (accountMutexes.get(accountId) !== mutex) return;
   const lockState = mutex.state();
-  if (lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS || lockState.heldBy.startsWith("init:") || isAccountServingStream(accountId)) {
+  const minLockTimeout = Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers);
+  if (lockState.heldForMs < minLockTimeout || lockState.heldBy.startsWith("init:") || lockState.heldBy.startsWith("headers:") || lockState.heldBy.startsWith("refresh:") || lockState.heldBy.startsWith("profile-reset:") || isAccountServingStream(accountId)) {
     logger.warn(
-      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${minLockTimeout}ms | servingStream=${isAccountServingStream(accountId)}`
     );
     return;
   }
@@ -4143,7 +4145,8 @@ async function getBasicHeaders(accountId) {
   }
   const release = await acquireAccountMutex(
     accountId,
-    `headers:${accountId.substring(0, 12)}`
+    `headers:${accountId.substring(0, 12)}`,
+    Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers + 3e4)
   );
   try {
     touchAccountActivity(accountId);
@@ -4236,8 +4239,10 @@ async function getBasicHeaders(accountId) {
         return { cookie: cookie2, userAgent, bxV: bxV2, bxUa: bxUa2, bxUmidtoken: bxUmidtoken2, ...clientHints };
       }
     }
+    let refreshedInThisCall = false;
     if (headersAge > HEADER_CACHE_TTL && !cache.refreshInProgress) {
       try {
+        refreshedInThisCall = true;
         await refreshHeadersInternal(accountId);
       } catch (error) {
         if (!hadUsableHeaders) throw error;
@@ -4306,7 +4311,7 @@ async function getBasicHeaders(accountId) {
       } catch {
       }
     }
-    if (!hasRequiredQwenHeaders(cache.headers)) {
+    if (!hasRequiredQwenHeaders(cache.headers) && !refreshedInThisCall) {
       console.log(
         `\u{1F504} [Playwright] Missing required anti-bot headers for ${accountId}, triggering header interception...`
       );
@@ -5749,7 +5754,24 @@ async function refreshAccountToken(accountId) {
   return { success: false, error: "Could not refresh or re-authenticate token" };
 }
 async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.timeouts.headers, triggerGraceMs = HEADER_CAPTURE_TRIGGER_GRACE_MS) {
-  const page = pageOverride ?? accountPages.get(accountId);
+  let page = pageOverride ?? accountPages.get(accountId);
+  if (!page || page.isClosed()) {
+    const { isRunningUnderNodeTest: isRunningUnderNodeTest3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+    if (!isRunningUnderNodeTest3()) {
+      const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+      const creds = getAccountCredentials2(accountId);
+      if (creds) {
+        await initPlaywrightForAccount(
+          creds,
+          config.playwright.headless,
+          config.playwright.browser,
+          { skipHeaderCapture: true }
+        ).catch(() => {
+        });
+        page = accountPages.get(accountId);
+      }
+    }
+  }
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for header capture: ${accountId}`);
   }
@@ -6392,16 +6414,38 @@ async function refreshHeaders(accountId, timeoutMs = config.timeouts.headers, fo
     release();
   }
 }
-async function withAccountPage(accountId, fn, timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS, recoverOnTimeout = true) {
+async function ensureAccountPageAvailable(accountId) {
   const inFlightInit = inFlightAccountInits.get(accountId);
   if (inFlightInit) {
     await inFlightInit.catch(() => {
     });
   }
-  const page = accountPages.get(accountId);
+  let page = accountPages.get(accountId);
+  if (page && !page.isClosed()) {
+    return page;
+  }
+  const { isRunningUnderNodeTest: isRunningUnderNodeTest3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+  if (isRunningUnderNodeTest3()) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+  const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+  const creds = getAccountCredentials2(accountId);
+  if (!creds) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+  await initPlaywrightForAccount(
+    creds,
+    config.playwright.headless,
+    config.playwright.browser
+  );
+  page = accountPages.get(accountId);
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for account: ${accountId}`);
   }
+  return page;
+}
+async function withAccountPage(accountId, fn, timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS, recoverOnTimeout = true) {
+  const page = await ensureAccountPageAvailable(accountId);
   const release = await acquireAccountMutex(
     accountId,
     `page:${accountId.substring(0, 12)}`,
@@ -6702,8 +6746,10 @@ async function evictIdlePlaywrightContextsToLimit() {
   if (accountPages.size <= max) return 0;
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
+      if (isAccountServingStream(accountId)) return false;
+      if (isAccountRecentlyActive(accountId, 3e4)) return false;
       const mutex = accountMutexes.get(accountId);
-      return mutex?.isIdle() && !isAccountServingStream(accountId);
+      return mutex?.isIdle();
     })
   ).map((accountId) => ({
     accountId,

package/dist/reset-cooldowns.js

@@ -14,6 +14,25 @@ var __export = (target, all) => {
 };
 
 // src/core/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  ensureDataDirs: () => ensureDataDirs,
+  getAccountPriorityPath: () => getAccountPriorityPath,
+  getAccountProfilePath: () => getAccountProfilePath,
+  getDataDir: () => getDataDir,
+  getDbDir: () => getDbDir,
+  getDbPath: () => getDbPath,
+  getEncryptionKeyPath: () => getEncryptionKeyPath,
+  getEnvFilePath: () => getEnvFilePath,
+  getLogsDir: () => getLogsDir,
+  getOsGlobalDataDir: () => getOsGlobalDataDir,
+  getProfilesDir: () => getProfilesDir,
+  getServerLogFilePath: () => getServerLogFilePath,
+  getSyncStatePath: () => getSyncStatePath,
+  getTuiSettingsPath: () => getTuiSettingsPath,
+  isRunningUnderNodeTest: () => isRunningUnderNodeTest,
+  resolveDataDir: () => resolveDataDir
+});
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -78,6 +97,12 @@ function getAccountProfilePath(accountId, customDataDir) {
 function getAccountPriorityPath(customDataDir) {
   return path.join(customDataDir || getDataDir(), "account-priority.json");
 }
+function getSyncStatePath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "sync-state.json");
+}
+function getTuiSettingsPath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "tui-settings.json");
+}
 function getEnvFilePath(customDataDir) {
   if (isRunningUnderNodeTest()) {
     return path.join(customDataDir || getDataDir(), ".env");
@@ -88,6 +113,26 @@ function getEnvFilePath(customDataDir) {
   }
   return path.join(customDataDir || getDataDir(), ".env");
 }
+function getLogsDir(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "logs");
+}
+function getServerLogFilePath(customDataDir) {
+  return path.join(getLogsDir(customDataDir), "server.log");
+}
+function ensureDataDirs(targetDataDir) {
+  const root = targetDataDir || getDataDir();
+  const dbDir = getDbDir(root);
+  const profilesDir = getProfilesDir(root);
+  const logsDir = getLogsDir(root);
+  try {
+    if (!fs.existsSync(root)) fs.mkdirSync(root, { recursive: true });
+    if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+    if (!fs.existsSync(profilesDir)) fs.mkdirSync(profilesDir, { recursive: true });
+    if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
+  } catch (err) {
+    console.error(`[Paths] Error ensuring data directories at ${root}:`, err?.message || String(err));
+  }
+}
 var init_paths = __esm({
   "src/core/paths.ts"() {
     "use strict";
@@ -3059,9 +3104,10 @@ function getAccountMutex(accountId) {
 async function recoverStuckAccountMutex(accountId, mutex, key) {
   if (accountMutexes.get(accountId) !== mutex) return;
   const lockState = mutex.state();
-  if (lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS || lockState.heldBy.startsWith("init:") || isAccountServingStream(accountId)) {
+  const minLockTimeout = Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers);
+  if (lockState.heldForMs < minLockTimeout || lockState.heldBy.startsWith("init:") || lockState.heldBy.startsWith("headers:") || lockState.heldBy.startsWith("refresh:") || lockState.heldBy.startsWith("profile-reset:") || isAccountServingStream(accountId)) {
     logger.warn(
-      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${minLockTimeout}ms | servingStream=${isAccountServingStream(accountId)}`
     );
     return;
   }
@@ -4733,7 +4779,24 @@ async function refreshAccountToken(accountId) {
   return { success: false, error: "Could not refresh or re-authenticate token" };
 }
 async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.timeouts.headers, triggerGraceMs = HEADER_CAPTURE_TRIGGER_GRACE_MS) {
-  const page = pageOverride ?? accountPages.get(accountId);
+  let page = pageOverride ?? accountPages.get(accountId);
+  if (!page || page.isClosed()) {
+    const { isRunningUnderNodeTest: isRunningUnderNodeTest3 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+    if (!isRunningUnderNodeTest3()) {
+      const { getAccountCredentials: getAccountCredentials2 } = await Promise.resolve().then(() => (init_accounts(), accounts_exports));
+      const creds = getAccountCredentials2(accountId);
+      if (creds) {
+        await initPlaywrightForAccount(
+          creds,
+          config.playwright.headless,
+          config.playwright.browser,
+          { skipHeaderCapture: true }
+        ).catch(() => {
+        });
+        page = accountPages.get(accountId);
+      }
+    }
+  }
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for header capture: ${accountId}`);
   }
@@ -5434,8 +5497,10 @@ async function evictIdlePlaywrightContextsToLimit() {
   if (accountPages.size <= max) return 0;
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
+      if (isAccountServingStream(accountId)) return false;
+      if (isAccountRecentlyActive(accountId, 3e4)) return false;
       const mutex = accountMutexes.get(accountId);
-      return mutex?.isIdle() && !isAccountServingStream(accountId);
+      return mutex?.isIdle();
     })
   ).map((accountId) => ({
     accountId,
@@ -5548,6 +5613,10 @@ async function closePlaywrightForAccount(accountId) {
     release();
   }
 }
+function isAccountRecentlyActive(accountId, maxIdleMs = 3e5) {
+  const last = lastAccountActivity.get(accountId) ?? 0;
+  return last > 0 && Date.now() - last < maxIdleMs;
+}
 var requireLocal, contextInitHooks, ACCOUNT_MUTEX_MAX_HOLD_MS, accountMutexes, accountContexts, accountPages, inFlightAccountInits, headerCaches, HEADER_CACHE_TTL, COOKIE_CACHE_TTL, cookieCaches, lastAccountActivity, lastKeepAliveNavigation, lastProactiveTokenRefresh, profileResetQueue, profileResetChain, closingAllPlaywright, sleep2, HEADER_CAPTURE_SETTLE_MS, PLAYWRIGHT_MUTEX_WAIT_MS, ACCOUNT_PAGE_OPERATION_TIMEOUT_MS, SESSION_PROBE_NAVIGATION_TIMEOUT_MS, HEADER_CAPTURE_TRIGGER_GRACE_MS, FIRST_TRIGGER_GRACE_MS, HEADER_CAPTURE_TRIGGER_ATTEMPTS, CHAT_INPUT_APPEAR_TIMEOUT_MS, CHAT_INPUT_ACTION_TIMEOUT_MS, PROFILE_RESET_TIMEOUT_MS;
 var init_playwright = __esm({
   "src/services/playwright.ts"() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "description": "High-performance OpenAI & Anthropic compatible API gateway for Qwen with multi-account rotation, interactive TUI, and resilient tool calling.",
   "main": "src/index.ts",
   "bin": {

package/src/core/version.ts

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

package/src/routes/chat/retry-policy.ts

@@ -390,7 +390,9 @@ export function isNetworkLikeError(err: unknown): boolean {
     message.includes("socket hang up") ||
     message.includes("econnreset") ||
     message.includes("econnrefused") ||
-    message.includes("etimedout")
+    message.includes("etimedout") ||
+    message.includes("stream ended before response headers") ||
+    message.includes("timed out waiting for response headers")
   );
 }
 
@@ -499,6 +501,21 @@ export function classifyRetryAction(
     return makeRetryAction("terminal_local", { retryable: false });
   }
 
+  // Agent instructions ride ONLY the account-level personalization. An
+  // unconfirmed sync means this account cannot serve the request as-is —
+  // rotate to another account (each attempt re-syncs on its own account).
+  // Do NOT park the account with a 300s cooldown: rotation across accounts
+  // is already guarded by triedAccounts, preventing pool collapse.
+  if (err instanceof PersonalizationSyncError) {
+    return makeRetryAction("personalization_sync_failed", {
+      switchAccount: true,
+      forceNewChat: true,
+      retryAfterMs: baseDelayMs,
+      accountCooldownMs: 0,
+      accountCooldownReason: "PersonalizationFailed",
+    });
+  }
+
   const message = errMessage(err).toLowerCase();
   const code = errCode(err).toLowerCase();
   if (isAccountInitializationError(err)) {
@@ -521,21 +538,6 @@ export function classifyRetryAction(
     });
   }
 
-  // Agent instructions ride ONLY the account-level personalization. An
-  // unconfirmed sync means this account cannot serve the request as-is —
-  // rotate to another account (each attempt re-syncs on its own account).
-  // Do NOT park the account with a 300s cooldown: rotation across accounts
-  // is already guarded by triedAccounts, preventing pool collapse.
-  if (err instanceof PersonalizationSyncError) {
-    return makeRetryAction("personalization_sync_failed", {
-      switchAccount: true,
-      forceNewChat: true,
-      retryAfterMs: baseDelayMs,
-      accountCooldownMs: 0,
-      accountCooldownReason: "PersonalizationFailed",
-    });
-  }
-
   // Upstream 401 / Unauthorized on chat creation or API requests:
   // Access token expired (15m window). Rotate without locking into a 300s cooldown
   // so the account can immediately be renewed via refresh_token.

package/src/services/playwright.ts

@@ -166,7 +166,7 @@ export function buildChromiumLaunchArgs(viewport: {
 const ACCOUNT_MUTEX_MAX_HOLD_MS = 180_000;
 const accountMutexes = new Map<string, Mutex>();
 
-function getAccountMutex(accountId: string): Mutex {
+export function getAccountMutex(accountId: string): Mutex {
   let mutex = accountMutexes.get(accountId);
   if (!mutex) {
     mutex = new Mutex(`playwright:${accountId.substring(0, 8)}`, ACCOUNT_MUTEX_MAX_HOLD_MS);
@@ -189,15 +189,20 @@ async function recoverStuckAccountMutex(
   const lockState = mutex.state();
   // A lock is only considered stuck if it has been held for at least PLAYWRIGHT_MUTEX_WAIT_MS (60s).
   // A waiter with a short timeout (e.g. 5s) timing out does NOT mean the lock holder is stuck!
-  // Furthermore, never nuke an account while it is initializing (init: takes 20-30s)
-  // or while it is actively serving a stream to a user.
+  // Furthermore, never nuke an account while it is initializing (init: takes 20-30s),
+  // capturing/refreshing headers (headers/refresh can take up to HEADERS_TIMEOUT),
+  // running page operations, or while it is actively serving a stream to a user.
+  const minLockTimeout = Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers);
   if (
-    lockState.heldForMs < PLAYWRIGHT_MUTEX_WAIT_MS ||
+    lockState.heldForMs < minLockTimeout ||
     lockState.heldBy.startsWith("init:") ||
+    lockState.heldBy.startsWith("headers:") ||
+    lockState.heldBy.startsWith("refresh:") ||
+    lockState.heldBy.startsWith("profile-reset:") ||
     isAccountServingStream(accountId)
   ) {
     logger.warn(
-      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${PLAYWRIGHT_MUTEX_WAIT_MS}ms | servingStream=${isAccountServingStream(accountId)}`,
+      `[Playwright] Skipping destructive mutex recovery | account=${accountId} | heldBy=${lockState.heldBy} | heldFor=${lockState.heldForMs}ms | limit=${minLockTimeout}ms | servingStream=${isAccountServingStream(accountId)}`,
     );
     return;
   }
@@ -1246,6 +1251,7 @@ export async function getBasicHeaders(accountId: string): Promise<{
   const release = await acquireAccountMutex(
     accountId,
     `headers:${accountId.substring(0, 12)}`,
+    Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, config.timeouts.headers + 30_000),
   );
   try {
     touchAccountActivity(accountId);
@@ -1369,8 +1375,10 @@ export async function getBasicHeaders(accountId: string): Promise<{
 
     // Refresh headers if stale. A valid cached set remains usable when a
     // browser recapture transiently fails; a cold/partial cache must fail.
+    let refreshedInThisCall = false;
     if (headersAge > HEADER_CACHE_TTL && !cache.refreshInProgress) {
       try {
+        refreshedInThisCall = true;
         await refreshHeadersInternal(accountId);
       } catch (error) {
         if (!hadUsableHeaders) throw error;
@@ -1443,7 +1451,7 @@ export async function getBasicHeaders(accountId: string): Promise<{
       } catch {}
     }
 
-    if (!hasRequiredQwenHeaders(cache.headers)) {
+    if (!hasRequiredQwenHeaders(cache.headers) && !refreshedInThisCall) {
       console.log(
         `🔄 [Playwright] Missing required anti-bot headers for ${accountId}, triggering header interception...`,
       );
@@ -3242,7 +3250,24 @@ export async function captureQwenHeaders(
   timeoutMs = config.timeouts.headers,
   triggerGraceMs = HEADER_CAPTURE_TRIGGER_GRACE_MS,
 ): Promise<void> {
-  const page = pageOverride ?? accountPages.get(accountId);
+  let page = pageOverride ?? accountPages.get(accountId);
+  if (!page || page.isClosed()) {
+    const { isRunningUnderNodeTest } = await import("../core/paths.ts");
+    if (!isRunningUnderNodeTest()) {
+      const { getAccountCredentials } = await import("../core/accounts.ts");
+      const creds = getAccountCredentials(accountId);
+      if (creds) {
+        await initPlaywrightForAccount(
+          creds,
+          config.playwright.headless,
+          config.playwright.browser,
+          { skipHeaderCapture: true },
+        ).catch(() => {});
+        page = accountPages.get(accountId);
+      }
+    }
+  }
+
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for header capture: ${accountId}`);
   }
@@ -4100,22 +4125,51 @@ export async function refreshHeaders(
  * Run work against the account Playwright page under the per-account mutex.
  * Used by captcha recovery so it cannot race header capture / login.
  */
-export async function withAccountPage<T>(
-  accountId: string,
-  fn: (page: Page) => Promise<T>,
-  timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS,
-  mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS,
-  recoverOnTimeout = true,
-): Promise<T> {
+async function ensureAccountPageAvailable(accountId: string): Promise<Page> {
   const inFlightInit = inFlightAccountInits.get(accountId);
   if (inFlightInit) {
     await inFlightInit.catch(() => {});
   }
 
-  const page = accountPages.get(accountId);
+  let page = accountPages.get(accountId);
+  if (page && !page.isClosed()) {
+    return page;
+  }
+
+  // Under Node.js test suites, preserve strict mock failure contract
+  const { isRunningUnderNodeTest } = await import("../core/paths.ts");
+  if (isRunningUnderNodeTest()) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+
+  // Lazy boot / recovery: if the account was evicted or in standby, initialize it transparently on demand
+  const { getAccountCredentials } = await import("../core/accounts.ts");
+  const creds = getAccountCredentials(accountId);
+  if (!creds) {
+    throw new Error(`Playwright page unavailable for account: ${accountId}`);
+  }
+
+  await initPlaywrightForAccount(
+    creds,
+    config.playwright.headless,
+    config.playwright.browser,
+  );
+
+  page = accountPages.get(accountId);
   if (!page || page.isClosed()) {
     throw new Error(`Playwright page unavailable for account: ${accountId}`);
   }
+  return page;
+}
+
+export async function withAccountPage<T>(
+  accountId: string,
+  fn: (page: Page) => Promise<T>,
+  timeoutMs = ACCOUNT_PAGE_OPERATION_TIMEOUT_MS,
+  mutexTimeoutMs = PLAYWRIGHT_MUTEX_WAIT_MS,
+  recoverOnTimeout = true,
+): Promise<T> {
+  const page = await ensureAccountPageAvailable(accountId);
   const release = await acquireAccountMutex(
     accountId,
     `page:${accountId.substring(0, 12)}`,
@@ -4542,8 +4596,10 @@ export async function evictIdlePlaywrightContextsToLimit(): Promise<number> {
 
   const candidates = priorityOrderForEviction(
     Array.from(accountPages.keys()).filter((accountId) => {
+      if (isAccountServingStream(accountId)) return false;
+      if (isAccountRecentlyActive(accountId, 30_000)) return false;
       const mutex = accountMutexes.get(accountId);
-      return mutex?.isIdle() && !isAccountServingStream(accountId);
+      return mutex?.isIdle();
     }),
   ).map((accountId) => ({
     accountId,

package/src/services/qwen.ts

@@ -818,7 +818,7 @@ async function withQwenBrowserPage<T>(
       return fn(page);
     },
     operationTimeoutMs,
-    Math.min(config.timeouts.page, 30_000),
+    Math.max(60_000, operationTimeoutMs),
     recoverOnTimeout,
   );
 }