qwenproxy-cli 1.6.10 → 1.6.12

package/dist/clean-cache.js

@@ -997,7 +997,7 @@ var init_config = __esm({
       // Version header on Qwen API requests = the deployed web bundle version
       // (fallback when dynamic DOM detection is not yet completed).
       // Override via env when Qwen ships a new bundle.
-      QWEN_WEB_VERSION: z.string().default("0.3.26"),
+      QWEN_WEB_VERSION: z.string().default("0.3.43"),
       // Controls bx-ua/bx-umidtoken injection on the GENERAL API paths
       // (chats/new, settings): those work without them (live-probed). The
       // completions path is the exception — the 0.2.86 HAR shows the real
@@ -1040,6 +1040,7 @@ var init_config = __esm({
       CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
       CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
       CAPTCHA_SOLVER_TIMEOUT_MS: z.string().default("15000"),
+      CAPTCHA_SLIDER_TIMEOUT_MS: z.string().default("8000"),
       CAPTCHA_SOLVER_RETRY_DELAY_MS: z.string().default("1000"),
       CAPTCHA_SOLVER_SETTLE_MS: z.string().default("2000"),
       CAPTCHA_ACCOUNT_COOLDOWN_MS: z.string().default("120000"),
@@ -1191,6 +1192,8 @@ var init_config = __esm({
         enabled: env.CAPTCHA_SOLVER_ENABLED === "true",
         maxAttempts: Math.max(1, Math.min(5, parseInt(env.CAPTCHA_SOLVER_MAX_ATTEMPTS))),
         timeoutMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_TIMEOUT_MS)),
+        /** Max wait for a challenge slider to become visible (slow WAF renders). */
+        sliderTimeoutMs: Math.max(500, parseInt(env.CAPTCHA_SLIDER_TIMEOUT_MS)),
         retryDelayMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_RETRY_DELAY_MS)),
         settleMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_SETTLE_MS)),
         /** Rest an account whose challenge could not be cleared before reusing it. */
@@ -2035,6 +2038,26 @@ function clearAccountCooldown(accountId) {
     }
   }
 }
+function getAccountCooldownInfo(accountId) {
+  const entry = cooldowns.get(accountId);
+  if (!entry) return null;
+  const remaining = entry.until - Date.now();
+  if (remaining <= 0) {
+    cooldowns.delete(accountId);
+    if (accountId !== "global") {
+      try {
+        updateAccountCooldown(accountId, 0, null);
+      } catch (err) {
+        console.error(
+          `\u274C [AccountManager] Failed to clear expired cooldown in DB:`,
+          err.message
+        );
+      }
+    }
+    return null;
+  }
+  return { onCooldown: true, remainingMs: remaining, reason: entry.reason };
+}
 function markAccountHeadersReady(accountId) {
   if (!accountId || accountId === "global") return;
   headersReadyAccounts.add(accountId);
@@ -2348,6 +2371,294 @@ function logBaxiaCaptcha(event, fields = {}, important = false) {
     console.log(line);
   }
 }
+async function findVisibleLocatorWithin(page, selectors, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (true) {
+    const found = await findVisibleLocator(page, selectors);
+    if (found) return found;
+    if (Date.now() >= deadline) return null;
+    await sleep(Math.min(150, Math.max(1, deadline - Date.now())));
+  }
+}
+async function waitForHidden(locator, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (true) {
+    if (!await isVisible(locator)) return true;
+    if (Date.now() >= deadline) return false;
+    await sleep(Math.min(100, Math.max(1, deadline - Date.now())));
+  }
+}
+async function computeAliyunPuzzleOffset(page) {
+  return page.evaluate(() => {
+    const background = document.querySelector(
+      "#aliyunCaptcha-img"
+    );
+    const piece = document.querySelector(
+      "#aliyunCaptcha-puzzle"
+    );
+    if (!background || !piece) {
+      return Promise.resolve({ ok: false, reason: "missing puzzle images" });
+    }
+    const compute = () => {
+      try {
+        const width = background.naturalWidth;
+        const height = background.naturalHeight;
+        const pieceWidth = piece.naturalWidth;
+        const pieceHeight = piece.naturalHeight;
+        if (!width || !height || !pieceWidth || !pieceHeight) {
+          return { ok: false, reason: "image dimensions unavailable" };
+        }
+        const backgroundCanvas = document.createElement("canvas");
+        backgroundCanvas.id = "captcha-solver-canvas";
+        backgroundCanvas.width = width;
+        backgroundCanvas.height = height;
+        const backgroundContext = backgroundCanvas.getContext("2d");
+        if (!backgroundContext) {
+          return { ok: false, reason: "no background context" };
+        }
+        const pieceCanvas = document.createElement("canvas");
+        pieceCanvas.id = "captcha-solver-canvas";
+        pieceCanvas.width = pieceWidth;
+        pieceCanvas.height = pieceHeight;
+        const pieceContext = pieceCanvas.getContext("2d");
+        if (!pieceContext) {
+          return { ok: false, reason: "no piece context" };
+        }
+        try {
+          backgroundContext.drawImage(background, 0, 0);
+        } catch {
+          return { ok: false, reason: "background canvas tainted" };
+        }
+        try {
+          pieceContext.drawImage(piece, 0, 0);
+        } catch {
+          return { ok: false, reason: "puzzle canvas tainted" };
+        }
+        const backgroundData = backgroundContext.getImageData(
+          0,
+          0,
+          width,
+          height
+        ).data;
+        const pieceData = pieceContext.getImageData(
+          0,
+          0,
+          pieceWidth,
+          pieceHeight
+        ).data;
+        let pieceMinX = pieceWidth;
+        let pieceMaxX = -1;
+        let pieceMinY = pieceHeight;
+        let pieceMaxY = -1;
+        for (let y = 0; y < pieceHeight; y++) {
+          for (let x = 0; x < pieceWidth; x++) {
+            if (pieceData[(y * pieceWidth + x) * 4 + 3] > 100) {
+              if (x < pieceMinX) pieceMinX = x;
+              if (x > pieceMaxX) pieceMaxX = x;
+              if (y < pieceMinY) pieceMinY = y;
+              if (y > pieceMaxY) pieceMaxY = y;
+            }
+          }
+        }
+        const puzzleWidth = pieceMaxX - pieceMinX + 1;
+        if (puzzleWidth <= 0) {
+          return { ok: false, reason: "empty puzzle piece" };
+        }
+        const yStart = Math.max(1, Math.min(height - 2, pieceMinY + 5));
+        const yEnd = Math.max(
+          yStart,
+          Math.min(height - 2, pieceMaxY - 5)
+        );
+        const columnGradients = new Float32Array(width);
+        for (let x = 1; x < width - 1; x++) {
+          let gradient = 0;
+          for (let y = yStart; y <= yEnd; y++) {
+            const left = (y * width + x - 1) * 4;
+            const right = (y * width + x + 1) * 4;
+            gradient += Math.abs(backgroundData[right] - backgroundData[left]) + Math.abs(backgroundData[right + 1] - backgroundData[left + 1]) + Math.abs(backgroundData[right + 2] - backgroundData[left + 2]);
+          }
+          columnGradients[x] = gradient;
+        }
+        let bestX = 0;
+        let bestScore = 0;
+        const minCandidateX = 30;
+        const maxCandidateX = width - puzzleWidth - 20;
+        for (let candidateX = minCandidateX; candidateX <= maxCandidateX; candidateX++) {
+          let leftMax = 0;
+          for (let dx = -2; dx <= 2; dx++) {
+            const value = columnGradients[candidateX + pieceMinX + dx] || 0;
+            if (value > leftMax) leftMax = value;
+          }
+          let rightMax = 0;
+          for (let dx = -3; dx <= 1; dx++) {
+            const value = columnGradients[candidateX + pieceMaxX + dx] || 0;
+            if (value > rightMax) rightMax = value;
+          }
+          const score = Math.sqrt(leftMax * rightMax);
+          if (score > bestScore) {
+            bestScore = score;
+            bestX = candidateX;
+          }
+        }
+        if (bestScore <= 0) {
+          return { ok: false, reason: "no matching hole edge" };
+        }
+        return {
+          ok: true,
+          offsetX: bestX - pieceMinX,
+          naturalWidth: width
+        };
+      } catch (error) {
+        return {
+          ok: false,
+          reason: error instanceof Error ? error.message : String(error)
+        };
+      }
+    };
+    return new Promise((resolve) => {
+      if (background.complete && piece.complete) {
+        resolve(compute());
+        return;
+      }
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        resolve(compute());
+      };
+      const fail = () => {
+        if (settled) return;
+        settled = true;
+        resolve({ ok: false, reason: "puzzle image load error" });
+      };
+      background.addEventListener("load", finish, { once: true });
+      piece.addEventListener("load", finish, { once: true });
+      background.addEventListener("error", fail, { once: true });
+      piece.addEventListener("error", fail, { once: true });
+      setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        resolve({ ok: false, reason: "puzzle image load timeout" });
+      }, 2e3);
+    });
+  });
+}
+async function solveAliyunWafCaptcha(page, options = {}) {
+  const waitForMs = Math.max(0, options.waitForMs ?? 0);
+  const maxAttempts = Math.max(
+    1,
+    Math.min(5, options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)
+  );
+  const retryDelayMs = Math.max(
+    0,
+    options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS
+  );
+  const settleMs = Math.max(0, options.settleMs ?? DEFAULT_SETTLE_MS);
+  const sliderTimeoutMs = Math.max(
+    500,
+    options.sliderTimeoutMs ?? DEFAULT_SLIDER_TIMEOUT_MS
+  );
+  const detected = await findVisibleLocatorWithin(
+    page,
+    ALIYUN_WAF_BLOCK_SELECTORS,
+    waitForMs
+  );
+  if (!detected) return false;
+  return withCaptchaMouseLock(async () => {
+    const block = detected.locator;
+    if (!await isVisible(block)) return false;
+    logBaxiaCaptcha("aliyun_detected", { selector: detected.selector });
+    let lastReason = "unknown";
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const offset = await computeAliyunPuzzleOffset(page);
+        if (!offset.ok || typeof offset.offsetX !== "number" || typeof offset.naturalWidth !== "number" || offset.naturalWidth <= 0) {
+          lastReason = offset.reason || "offset_unavailable";
+          logBaxiaCaptcha("aliyun_offset_failed", {
+            attempt,
+            reason: lastReason
+          });
+        } else {
+          const slider = page.locator(ALIYUN_PUZZLE_SLIDER_SELECTOR).first();
+          const track = page.locator(ALIYUN_PUZZLE_TRACK_SELECTOR).first();
+          await slider.waitFor({ state: "visible", timeout: sliderTimeoutMs });
+          const [sliderBox, trackBox] = await Promise.all([
+            slider.boundingBox(),
+            track.boundingBox()
+          ]);
+          if (!sliderBox || !trackBox || trackBox.width <= 0) {
+            lastReason = "bounds_unavailable";
+            logBaxiaCaptcha("aliyun_offset_failed", {
+              attempt,
+              reason: lastReason
+            });
+          } else {
+            const scale = trackBox.width / offset.naturalWidth;
+            const dragDistance = Math.round(offset.offsetX * scale);
+            logBaxiaCaptcha("aliyun_geometry", {
+              attempt,
+              offset: offset.offsetX,
+              scale: Number(scale.toFixed(2)),
+              distance: dragDistance
+            });
+            if (dragDistance <= 0) {
+              lastReason = "non_positive_distance";
+            } else {
+              const startX = sliderBox.x + sliderBox.width / 2;
+              const startY = sliderBox.y + sliderBox.height / 2;
+              await humanDrag(
+                page,
+                startX,
+                startY,
+                startX + dragDistance,
+                startY
+              );
+              if (await waitForHidden(block, settleMs)) {
+                logBaxiaCaptcha(
+                  "aliyun_solve_succeeded",
+                  { attempt, distance: dragDistance },
+                  true
+                );
+                return true;
+              }
+              lastReason = "not_solved";
+            }
+          }
+        }
+      } catch (error) {
+        lastReason = error instanceof Error ? error.name : "UnknownError";
+        logBaxiaCaptcha("aliyun_offset_failed", {
+          attempt,
+          error: lastReason,
+          detail: sanitizeCaptchaErrorDetail(error)
+        });
+      }
+      if (attempt < maxAttempts && retryDelayMs > 0) {
+        await sleep(retryDelayMs);
+      }
+    }
+    logBaxiaCaptcha(
+      "aliyun_solve_failed",
+      { attempts: maxAttempts, reason: lastReason },
+      true
+    );
+    return false;
+  });
+}
+async function solveVisibleCaptcha(page, options = {}) {
+  if (typeof page.isClosed === "function" && page.isClosed()) return false;
+  const totalWaitMs = Math.max(0, options.waitForMs ?? 0);
+  const aliyunWaitMs = Math.min(totalWaitMs, ALIYUN_PROBE_MAX_WAIT_MS);
+  const startedAt = Date.now();
+  if (await solveAliyunWafCaptcha(page, { ...options, waitForMs: aliyunWaitMs })) {
+    return true;
+  }
+  const remainingWaitMs = Math.max(
+    0,
+    totalWaitMs - (Date.now() - startedAt)
+  );
+  return solveBaxiaCaptcha(page, { ...options, waitForMs: remainingWaitMs });
+}
 async function isVisible(locator) {
   return locator.isVisible().catch(() => false);
 }
@@ -2590,7 +2901,7 @@ async function solveBaxiaCaptchaUnlocked(page, options = {}) {
   );
   return false;
 }
-var BAXIA_DIALOG_SELECTOR, BAXIA_CONTENT_SELECTOR, CAPTCHA_EVENT_EMOJI, captchaDebugEnabled, BAXIA_IFRAME_SELECTORS, BAXIA_DOCUMENT_SELECTORS, BAXIA_IFRAME_SELECTOR, BAXIA_SLIDER_SELECTOR, BAXIA_TRACK_SELECTOR, BAXIA_SUCCESS_SELECTOR, BAXIA_RELOAD_SELECTOR, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_DELAY_MS, DEFAULT_SETTLE_MS, DEFAULT_SLIDER_TIMEOUT_MS, captchaMouseLock;
+var BAXIA_DIALOG_SELECTOR, BAXIA_CONTENT_SELECTOR, CAPTCHA_EVENT_EMOJI, captchaDebugEnabled, BAXIA_IFRAME_SELECTORS, BAXIA_DOCUMENT_SELECTORS, BAXIA_IFRAME_SELECTOR, BAXIA_SLIDER_SELECTOR, BAXIA_TRACK_SELECTOR, BAXIA_SUCCESS_SELECTOR, BAXIA_RELOAD_SELECTOR, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_DELAY_MS, DEFAULT_SETTLE_MS, DEFAULT_SLIDER_TIMEOUT_MS, ALIYUN_WAF_CAPTCHA_SELECTOR, ALIYUN_WAF_CAPTCHA_WIDGET, ALIYUN_WAF_BLOCK_SELECTORS, ALIYUN_PUZZLE_SLIDER_SELECTOR, ALIYUN_PUZZLE_TRACK_SELECTOR, ALIYUN_PROBE_MAX_WAIT_MS, captchaMouseLock;
 var init_captcha_solver = __esm({
   "src/services/captcha-solver.ts"() {
     "use strict";
@@ -2616,14 +2927,20 @@ var init_captcha_solver = __esm({
       solve_failed: "\u274C",
       recovery_succeeded: "\u2705",
       recovery_not_solved: "\u26A0\uFE0F",
-      recovery_failed: "\u274C"
+      recovery_failed: "\u274C",
+      aliyun_detected: "\u{1F9E9}",
+      aliyun_offset_failed: "\u{1F4D0}",
+      aliyun_geometry: "\u{1F4D0}",
+      aliyun_solve_succeeded: "\u2705",
+      aliyun_solve_failed: "\u274C"
     };
     captchaDebugEnabled = process.env.CAPTCHA_DEBUG === "true";
     BAXIA_IFRAME_SELECTORS = [
       `${BAXIA_DIALOG_SELECTOR} ${BAXIA_CONTENT_SELECTOR} iframe`,
       `${BAXIA_CONTENT_SELECTOR} iframe`,
       "iframe#baxia-dialog-content",
-      'iframe[src*="_____tmd_____/punish"]'
+      'iframe[src*="_____tmd_____/punish"]',
+      'iframe[src*="nocaptcha"]'
     ];
     BAXIA_DOCUMENT_SELECTORS = [
       "#nocaptcha",
@@ -2631,14 +2948,23 @@ var init_captcha_solver = __esm({
       "#baxia-punish"
     ];
     BAXIA_IFRAME_SELECTOR = BAXIA_IFRAME_SELECTORS.join(", ");
-    BAXIA_SLIDER_SELECTOR = "#nc_1_n1z, .nc_1_n1z, .btn_slide, .nc_wrapper .btn_slide, ._nc .btn_slide, .nc-container .btn_slide";
-    BAXIA_TRACK_SELECTOR = "#nc_1_n1t, .nc_scale, .nc_wrapper .nc_scale, ._nc .nc_scale, .nc-container .nc_scale";
+    BAXIA_SLIDER_SELECTOR = '#nc_1_n1z, .nc_1_n1z, .btn_slide, .nc_iconfont.btn_slide, span[id*="_n1z"], .nc_wrapper .btn_slide, ._nc .btn_slide, .nc-container .btn_slide';
+    BAXIA_TRACK_SELECTOR = '#nc_1_n1t, .nc_scale, span[id*="_n1t"], .nc_wrapper .nc_scale, ._nc .nc_scale, .nc-container .nc_scale';
     BAXIA_SUCCESS_SELECTOR = '.btn_ok, .nc_ok, .nc_success, .nc_result, .nc_wrapper.nc-success, .nc_wrapper.success, [data-nc-lang="SUCCESS"], [data-nc-lang="success"], #nc-loading-circle';
     BAXIA_RELOAD_SELECTOR = '#nc_1_refresh1, .errloading a, .nc-container .errloading a, .btn_refresh, .clickCaptcha_text .btn_refresh, [data-nc-lang="REFRESH"], a[id*="refresh"]';
     DEFAULT_MAX_ATTEMPTS = 3;
     DEFAULT_RETRY_DELAY_MS = 1e3;
     DEFAULT_SETTLE_MS = 2e3;
     DEFAULT_SLIDER_TIMEOUT_MS = 8e3;
+    ALIYUN_WAF_CAPTCHA_SELECTOR = "#waf_nc_block";
+    ALIYUN_WAF_CAPTCHA_WIDGET = "#aliyunCaptcha-window-embed";
+    ALIYUN_WAF_BLOCK_SELECTORS = [
+      ALIYUN_WAF_CAPTCHA_SELECTOR,
+      ALIYUN_WAF_CAPTCHA_WIDGET
+    ];
+    ALIYUN_PUZZLE_SLIDER_SELECTOR = "#aliyunCaptcha-sliding-slider";
+    ALIYUN_PUZZLE_TRACK_SELECTOR = "#aliyunCaptcha-sliding-body";
+    ALIYUN_PROBE_MAX_WAIT_MS = 2e3;
     captchaMouseLock = Promise.resolve();
   }
 });
@@ -2729,7 +3055,15 @@ function updateQwenWebVersion(version) {
 function getQwenWebVersion() {
   return dynamicWebVersion || config.qwen.webVersion;
 }
-var dynamicWebVersion, QWEN_WEB_VERSION, DEFAULT_QWEN_USER_AGENT, QWEN_TIMEZONE_HEADER;
+function updateQwenBxVersion(version) {
+  if (version && typeof version === "string" && /^\d+\.\d+\.\d+/.test(version)) {
+    dynamicBxVersion = version.trim();
+  }
+}
+function getQwenBxVersion() {
+  return dynamicBxVersion || config.auth.bxV;
+}
+var dynamicWebVersion, dynamicBxVersion, QWEN_WEB_VERSION, DEFAULT_QWEN_USER_AGENT, QWEN_TIMEZONE_HEADER;
 var init_qwen_headers = __esm({
   "src/services/qwen-headers.ts"() {
     "use strict";
@@ -2738,6 +3072,7 @@ var init_qwen_headers = __esm({
     init_fingerprint();
     init_timezone();
     dynamicWebVersion = null;
+    dynamicBxVersion = null;
     QWEN_WEB_VERSION = config.qwen.webVersion;
     DEFAULT_QWEN_USER_AGENT = getDefaultQwenUserAgent(151);
     QWEN_TIMEZONE_HEADER = (/* @__PURE__ */ new Date()).toString().split(" (")[0];
@@ -3054,11 +3389,12 @@ async function isPageLoggedIn(page, timeoutMs = SESSION_PROBE_NAVIGATION_TIMEOUT
 async function clearVisibleChallenge(page) {
   if (page.isClosed()) return;
   if (config.captcha.enabled) {
-    await solveBaxiaCaptcha(page, {
+    await solveVisibleCaptcha(page, {
       waitForMs: 0,
       maxAttempts: config.captcha.maxAttempts,
       retryDelayMs: config.captcha.retryDelayMs,
-      settleMs: config.captcha.settleMs
+      settleMs: config.captcha.settleMs,
+      sliderTimeoutMs: config.captcha.sliderTimeoutMs
     }).catch(() => false);
   }
   try {
@@ -3623,8 +3959,12 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
       if (accountPages.has(account.id)) {
         return;
       }
-      await evictIdlePlaywrightContextsToLimit().catch(() => {
-      });
+      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);
       const { engine, channel } = resolveBrowserEngine(browserType);
@@ -3800,6 +4140,9 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
                 if (persisted.version) {
                   updateQwenWebVersion(persisted.version);
                 }
+                if (persisted.bxV) {
+                  updateQwenBxVersion(persisted.bxV);
+                }
                 cache.lastRefresh = persisted.capturedAt;
                 markAccountHeadersReady(account.id);
                 restoredFromDb = true;
@@ -3893,7 +4236,7 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
         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
@@ -3911,6 +4254,8 @@ async function initPlaywrightForAccount(rawAccount, headless = config.playwright
     } finally {
       release();
     }
+    await evictIdlePlaywrightContextsToLimit().catch(() => {
+    });
   })();
   try {
     await initPromise;
@@ -3994,7 +4339,7 @@ async function loginToQwen(accountId, email, password) {
           saveAuthSession2(accountId, {
             cookie: cookieStr,
             userAgent: cache.headers["user-agent"] || "",
-            bxV: cache.headers["bx-v"] || "2.5.37",
+            bxV: cache.headers["bx-v"] || getQwenBxVersion(),
             bxUa: cache.headers["bx-ua"] || "",
             bxUmidtoken: cache.headers["bx-umidtoken"] || "",
             secChUa: cache.headers["sec-ch-ua"] || void 0,
@@ -4066,7 +4411,7 @@ async function loginToQwen(accountId, email, password) {
           saveAuthSession2(accountId, {
             cookie: cookieStr,
             userAgent: cache.headers["user-agent"] || "",
-            bxV: cache.headers["bx-v"] || "2.5.37",
+            bxV: cache.headers["bx-v"] || getQwenBxVersion(),
             bxUa: cache.headers["bx-ua"] || "",
             bxUmidtoken: cache.headers["bx-umidtoken"] || "",
             secChUa: cache.headers["sec-ch-ua"] || void 0,
@@ -4137,7 +4482,7 @@ async function loginViaApi(page, email, password) {
     }
     const signinUrl = "https://auth.qwen.ai/api/v2/auths/signin";
     const requestId = crypto3.randomUUID();
-    const webVersion = getQwenWebVersion() || "0.3.26";
+    const webVersion = getQwenWebVersion();
     const evalRes = await page.evaluate(
       async ({ email: email2, password: password2, signinUrl: signinUrl2, requestId: requestId2, tz, version }) => {
         try {
@@ -4309,6 +4654,15 @@ async function loginViaUi(page, email, password) {
     if (!page.url().includes("/auth") && await isPageLoggedIn(page, 3e3).catch(() => false)) {
       return { success: true };
     }
+    if (config.captcha.enabled) {
+      await solveVisibleCaptcha(page, {
+        waitForMs: 1500,
+        maxAttempts: config.captcha.maxAttempts,
+        retryDelayMs: config.captcha.retryDelayMs,
+        settleMs: config.captcha.settleMs,
+        sliderTimeoutMs: config.captcha.sliderTimeoutMs
+      }).catch(() => false);
+    }
     const emailSelector = [
       'input[type="email"]',
       'input[name="email"]',
@@ -4464,10 +4818,11 @@ async function loginViaUi(page, email, password) {
     while (Date.now() < postSubmitDeadline) {
       if (page.isClosed()) break;
       if (config.captcha.enabled) {
-        await solveBaxiaCaptcha(page, {
+        await solveVisibleCaptcha(page, {
           waitForMs: 1500,
           maxAttempts: config.captcha.maxAttempts,
-          retryDelayMs: config.captcha.retryDelayMs
+          retryDelayMs: config.captcha.retryDelayMs,
+          sliderTimeoutMs: config.captcha.sliderTimeoutMs
         }).catch(() => {
         });
       }
@@ -4590,7 +4945,7 @@ async function refreshAccountToken(accountId) {
   }
   if (refreshToken) {
     try {
-      const webVersion = getQwenWebVersion() || "0.3.26";
+      const webVersion = getQwenWebVersion();
       const refreshResult = await page.evaluate(
         async ({ rTok, tz, version }) => {
           try {
@@ -4655,7 +5010,7 @@ async function refreshAccountToken(accountId) {
           saveAuthSession2(accountId, {
             cookie: cookieStr,
             userAgent: cache.headers["user-agent"] || session?.userAgent || "",
-            bxV: cache.headers["bx-v"] || session?.bxV || "2.5.37",
+            bxV: cache.headers["bx-v"] || session?.bxV || getQwenBxVersion(),
             bxUa: cache.headers["bx-ua"] || session?.bxUa || "",
             bxUmidtoken: cache.headers["bx-umidtoken"] || session?.bxUmidtoken || "",
             secChUa: cache.headers["sec-ch-ua"] || session?.secChUa,
@@ -4690,7 +5045,7 @@ async function refreshAccountToken(accountId) {
         saveAuthSession2(accountId, {
           cookie: cookieStr,
           userAgent: cache.headers["user-agent"] || session?.userAgent || "",
-          bxV: cache.headers["bx-v"] || session?.bxV || "2.5.37",
+          bxV: cache.headers["bx-v"] || session?.bxV || getQwenBxVersion(),
           bxUa: cache.headers["bx-ua"] || session?.bxUa || "",
           bxUmidtoken: cache.headers["bx-umidtoken"] || session?.bxUmidtoken || "",
           secChUa: cache.headers["sec-ch-ua"] || session?.secChUa,
@@ -4838,7 +5193,7 @@ async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.ti
           cookie: reqHeaders["cookie"] || "",
           "bx-ua": reqHeaders["bx-ua"] || "",
           "bx-umidtoken": reqHeaders["bx-umidtoken"] || "",
-          "bx-v": reqHeaders["bx-v"] || "2.5.37",
+          "bx-v": reqHeaders["bx-v"] || getQwenBxVersion(),
           "user-agent": reqHeaders["user-agent"] || "",
           "x-request-id": reqHeaders["x-request-id"] || "",
           "version": reqHeaders["version"] || "",
@@ -4870,6 +5225,9 @@ async function captureQwenHeaders(accountId, pageOverride, timeoutMs = config.ti
         if (capturedHeaders["version"]) {
           updateQwenWebVersion(capturedHeaders["version"]);
         }
+        if (capturedHeaders["bx-v"]) {
+          updateQwenBxVersion(capturedHeaders["bx-v"]);
+        }
         markAccountHeadersReady(accountId);
         cache.lastRefresh = Date.now();
         cookieCaches.delete(accountId);
@@ -5413,7 +5771,11 @@ function priorityOrderForEviction(accountIds) {
   const ranked = getAccountsByPriority(accountIds.map((id) => ({ id })));
   const rank = /* @__PURE__ */ new Map();
   for (const [index, account] of ranked.entries()) {
-    rank.set(account.id, index);
+    if (getAccountCooldownInfo(account.id)) {
+      rank.set(account.id, Number.MAX_SAFE_INTEGER);
+    } else {
+      rank.set(account.id, index);
+    }
   }
   return orderContextsForEviction(
     accountIds,
@@ -5421,14 +5783,15 @@ function priorityOrderForEviction(accountIds) {
     (id) => lastAccountActivity.get(id) ?? 0
   );
 }
-async function evictIdlePlaywrightContextsToLimit() {
-  const max = config.playwright.maxActiveContexts;
-  if (max <= 0) return 0;
+async function evictIdlePlaywrightContextsToLimit(targetLimit) {
+  const configuredMax = config.playwright.maxActiveContexts;
+  if (configuredMax <= 0) return 0;
+  const max = targetLimit !== void 0 ? 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, 3e4)) return false;
+      if (hasActiveAccountLease(accountId)) return false;
       const mutex = accountMutexes.get(accountId);
       return mutex?.isIdle();
     })
@@ -5441,6 +5804,7 @@ async function evictIdlePlaywrightContextsToLimit() {
   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;
     await closePlaywrightForAccount(candidate.accountId).catch((error) => {
@@ -5543,10 +5907,6 @@ 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"() {