qwenproxy-cli 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "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/mutex.ts

@@ -102,6 +102,16 @@ export class Mutex {
     this.lockedByKey = "";
   }
 
+  /**
+   * Heartbeat the lock: extend lockedAt while the holder is actively making progress.
+   * Prevents premature force-release during long-running streaming generations.
+   */
+  touch(key?: string): void {
+    if (this.locked && (!key || this.lockedByKey === key)) {
+      this.lockedAt = Date.now();
+    }
+  }
+
   /** Returns true if the mutex is not locked and has no waiting queue. */
   isIdle(): boolean {
     return !this.locked && this.queue.length === 0;

package/src/routes/chat/account.ts

@@ -112,10 +112,11 @@ const personalizationLocks = new Map<string, Mutex>();
 		mutex = new Mutex(
 			`chat:${chatId.substring(0, 8)}`,
 			// The chat lock is held for the whole stream lifetime. A long
-			// generation (reasoning + huge context) can legitimately exceed the
-			// global 120s hold limit; use the same budget as the acquire timeout
-			// so the force-release never kills a healthy mid-stream turn.
-			timeoutMs,
+			// generation (reasoning + huge context) can legitimately take 4-5 min;
+			// use config.timeouts.totalRequestTimeout (600s) as the max hold limit, while
+			// touchChatLock extends it on every chunk so active streams are never
+			// force-released mid-generation.
+			config.timeouts.totalRequestTimeout,
 		);
 		chatLocks.set(chatId, mutex);
 	}
@@ -141,6 +142,12 @@ const personalizationLocks = new Map<string, Mutex>();
 	};
 }
 
+export function touchChatLock(chatId: string | undefined): void {
+	if (!chatId) return;
+	const mutex = chatLocks.get(chatId);
+	mutex?.touch();
+}
+
 async function acquirePersonalizationLock(
 	accountId: string,
 ): Promise<() => void> {

package/src/routes/chat/streaming.ts

@@ -30,6 +30,7 @@ import {
   shouldRetryInvalidInputOnSameAccount,
 } from "./retry-policy.ts";
 import type { Message, OpenAIRequest, Usage } from "../../utils/types.ts";
+import { touchChatLock } from "./account.ts";
 import { StreamingToolParser } from "../../tools/parser.ts";
 import {
   getStream,
@@ -351,7 +352,7 @@ export async function processNonStreamingResponse(
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-
+      touchChatLock(currentUiSessionId);
       const decoded = decoder.decode(value, { stream: true });
       if (!sawSseProtocol) {
         protocolBuffer += decoded;
@@ -1598,7 +1599,7 @@ export async function processStreamingResponse(
             throw readError;
           }
           if (readResult.done) break;
-
+          touchChatLock(currentUiSessionId);
           buffer += decoder.decode(readResult.value, { stream: true });
           lineEnd = buffer.indexOf("\n");
           if (lineEnd === -1) continue;
@@ -2141,7 +2142,7 @@ export async function processStreamingResponse(
           retryReadLoop: while (true) {
             const { done, value } = await retryReader.read();
             if (done) break;
-
+            touchChatLock(currentUiSessionId);
             retryBuf += retryDecoder.decode(value, { stream: true });
             let lineStart = 0;
             let lineEnd = retryBuf.indexOf("\n", lineStart);

package/src/services/captcha-coordinator.ts

@@ -111,26 +111,27 @@ export async function recoverBaxiaCaptcha(
 
   // The slider itself waits up to 5s for each attempt. Keep the page
   // operation alive for the full bounded solver budget so a slow challenge
-  // cannot be mistaken for a stuck browser and reset the account context.
+  // cannot be mistaken for a stuck browser. Do not clamp to timeouts.page.
   // Two navigations (open the challenge, return to the chat page) are part of
   // the recovery, so their budget belongs in the same total.
-  const solverOperationTimeoutMs = Math.min(
-    config.timeouts.page,
-    Math.max(
-      15_000,
-      config.captcha.timeoutMs +
-        config.captcha.maxAttempts *
-          (3_000 + config.captcha.retryDelayMs + config.captcha.settleMs) +
-        2 * CHALLENGE_NAVIGATION_TIMEOUT_MS,
-    ),
+  const solverOperationTimeoutMs = Math.max(
+    15_000,
+    config.captcha.timeoutMs +
+      config.captcha.maxAttempts *
+        (3_000 + config.captcha.retryDelayMs + config.captcha.settleMs) +
+      2 * CHALLENGE_NAVIGATION_TIMEOUT_MS,
   );
 
   try {
+    // 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),
       solverOperationTimeoutMs,
       Math.min(config.timeouts.page, 5_000),
+      false,
     );
 
     metrics.histogram("captcha.solve.duration", Date.now() - startedAt, {

package/src/services/chat-cleanup.ts

@@ -10,32 +10,52 @@ import {
   closeAllPlaywright,
 } from "./playwright.ts";
 import { isAuthMockEnabled } from "./auth-playwright.ts";
+import { maskEmail } from "../core/logger.ts";
 export interface DeleteChatsResult {
   attempted: number;
   succeeded: number;
   mode: "accounts";
 }
 
-async function ensurePlaywrightSession(account: QwenAccount): Promise<void> {
+async function ensurePlaywrightSession(
+  account: QwenAccount,
+  index = 1,
+  total = 1,
+): Promise<void> {
   if (isPlaywrightInitialized(account.id) || isAuthMockEnabled()) return;
 
   const credentials = getAccountCredentials(account.id);
   if (!credentials) {
-    throw new Error(`Account ${account.id} credentials not found`);
+    throw new Error(`Credenciais da conta ${account.id} não encontradas.`);
   }
 
   console.log(
-    `[DeleteChats] Initializing Playwright session for ${account.email}...`,
+    `[DeleteChats] [${index}/${total}] Abrindo navegador para ${maskEmail(account.email)}...`,
   );
-  await initPlaywrightForAccount(credentials);
+  await initPlaywrightForAccount(credentials, true, "chromium", {
+    skipHeaderCapture: true,
+  });
   console.log(
-    `✅ [DeleteChats] Playwright session ready for ${account.email}.`,
+    `✅ [DeleteChats] [${index}/${total}] Sessão pronta para ${maskEmail(account.email)}.`,
   );
 }
 
-export async function deleteChatsForAccount(account: QwenAccount): Promise<boolean> {
-  await ensurePlaywrightSession(account);
-  return deleteAllQwenChats(account.id);
+export async function deleteChatsForAccount(
+  account: QwenAccount,
+  index = 1,
+  total = 1,
+): Promise<boolean> {
+  await ensurePlaywrightSession(account, index, total);
+  console.log(
+    `🗑️  [DeleteChats] [${index}/${total}] Apagando conversas remotas de ${maskEmail(account.email)}...`,
+  );
+  const ok = await deleteAllQwenChats(account.id);
+  if (ok) {
+    console.log(
+      `✅ [DeleteChats] [${index}/${total}] Conversas apagadas com sucesso para ${maskEmail(account.email)}.`,
+    );
+  }
+  return ok;
 }
 
 export async function deleteChatsForAccountId(accountId: string): Promise<boolean> {
@@ -65,13 +85,16 @@ export async function deleteChatsForConfiguredAccounts(keepBrowserOpen = false):
   let succeeded = 0;
 
   try {
-    for (const account of accounts) {
+    for (let i = 0; i < accounts.length; i++) {
+      const account = accounts[i];
+      const currentIdx = i + 1;
+      const totalCount = accounts.length;
       try {
-        const ok = await deleteChatsForAccount(account);
+        const ok = await deleteChatsForAccount(account, currentIdx, totalCount);
         if (ok) succeeded++;
       } catch (error) {
         console.error(
-          `[DeleteChats] Failed to delete chats for ${account.email}:`,
+          `❌ [DeleteChats] [${currentIdx}/${totalCount}] Falha ao apagar conversas de ${maskEmail(account.email)}:`,
           error instanceof Error ? error.message : String(error),
         );
       }

package/src/services/playwright.ts

@@ -199,7 +199,11 @@ async function recoverStuckAccountMutex(
   // A normal request can recover the browser on the next attempt. Avoid
   // recursively scheduling another reset when the reset/close path itself was
   // the operation that timed out.
-  if (!key.startsWith("profile-reset:") && !key.startsWith("close:")) {
+  if (
+    !key.startsWith("profile-reset:") &&
+    !key.startsWith("close:") &&
+    !key.startsWith("init:")
+  ) {
     schedulePlaywrightProfileReset(accountId);
   }
 }
@@ -232,7 +236,7 @@ async function acquireAccountMutex(
 const accountContexts = new Map<string, BrowserContext>();
 const accountPages = new Map<string, Page>();
 const cachedUserAgents = new Map<string, string>();
-
+const inFlightAccountInits = new Map<string, Promise<void>>();
 let sharedBrowser: Browser | null = null;
 let sharedBrowserPromise: Promise<Browser> | null = null;
 
@@ -1286,6 +1290,7 @@ export async function initPlaywrightForAccount(
   rawAccount: QwenAccount,
   headless = true,
   browserType: BrowserType = "chromium",
+  options: { skipHeaderCapture?: boolean } = {},
 ): Promise<void> {
   const account = await resolveAccountCredentials(rawAccount);
   if (accountPages.has(account.id)) {
@@ -1294,12 +1299,19 @@ export async function initPlaywrightForAccount(
     );
     return;
   }
+  const existingInit = inFlightAccountInits.get(account.id);
+  if (existingInit) {
+    await existingInit;
+    return;
+  }
 
-  const release = await acquireAccountMutex(
-    account.id,
-    `init:${account.id.substring(0, 12)}`,
-  );
-  try {
+  const initPromise = (async () => {
+    const release = await acquireAccountMutex(
+      account.id,
+      `init:${account.id.substring(0, 12)}`,
+      Math.max(PLAYWRIGHT_MUTEX_WAIT_MS, 120_000),
+    );
+    try {
     // Double-check after acquiring lock
     if (accountPages.has(account.id)) {
       return;
@@ -1335,11 +1347,19 @@ export async function initPlaywrightForAccount(
 
     let acctContext: BrowserContext;
     try {
-      acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+      acctContext = await withTimeout(
+        engine.launchPersistentContext(profilePath, launchOptions),
+        30_000,
+        `O navegador não iniciou em 30s para a conta ${maskEmail(account.email)}. Se o QwenProxy estiver rodando em outro terminal, feche-o antes de executar este comando.`,
+      );
     } catch (launchErr: any) {
       if (launchErr?.message?.includes("Executable doesn't exist")) {
         autoInstallPlaywrightChromium();
-        acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+        acctContext = await withTimeout(
+          engine.launchPersistentContext(profilePath, launchOptions),
+          30_000,
+          `O navegador não iniciou em 30s para a conta ${maskEmail(account.email)}.`,
+        );
       } else {
         throw launchErr;
       }
@@ -1461,7 +1481,9 @@ export async function initPlaywrightForAccount(
         );
         throw validationError;
       }
-      await captureQwenHeaders(account.id);
+      if (!options.skipHeaderCapture) {
+        await captureQwenHeaders(account.id);
+      }
 
       // Header capture may leave the UI on a generated chat page. Return the
       // primary tab to the canonical chat home.
@@ -1485,8 +1507,16 @@ export async function initPlaywrightForAccount(
       cleanupPlaywrightAccountState(account.id);
       throw error;
     }
+    } finally {
+      release();
+    }
+  })();
+
+  inFlightAccountInits.set(account.id, initPromise);
+  try {
+    await initPromise;
   } finally {
-    release();
+    inFlightAccountInits.delete(account.id);
   }
 }
 
@@ -1540,11 +1570,19 @@ export async function validateAccountLogin(
 
     let acctContext: BrowserContext;
     try {
-      acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+      acctContext = await withTimeout(
+        engine.launchPersistentContext(profilePath, launchOptions),
+        30_000,
+        `O navegador não iniciou em 30s para a conta ${maskEmail(account.email)}. Se o QwenProxy estiver rodando em outro terminal, feche-o antes de executar este comando.`,
+      );
     } catch (launchErr: any) {
       if (launchErr?.message?.includes("Executable doesn't exist")) {
         autoInstallPlaywrightChromium();
-        acctContext = await engine.launchPersistentContext(profilePath, launchOptions);
+        acctContext = await withTimeout(
+          engine.launchPersistentContext(profilePath, launchOptions),
+          30_000,
+          `O navegador não iniciou em 30s para a conta ${maskEmail(account.email)}.`,
+        );
       } else {
         throw launchErr;
       }

package/src/services/qwen.ts

@@ -733,14 +733,15 @@ async function withQwenBrowserPage<T>(
   operationTimeoutMs = config.timeouts.page,
   recoverOnTimeout = true,
 ): Promise<T> {
-  // Keep the account page on the chat UI for normal browser operations. The
-  // personalization helper passes /settings/personalization explicitly; an
-  // omitted target must not leave a same-origin settings page in place.
-  const effectiveTargetPath = targetPath || "/";
-  const targetUrl = qwenUrl(effectiveTargetPath);
+  // When targetPath is omitted, any page under the Qwen origin can run the
+  // in-page evaluate/fetch without an expensive, stream-breaking page.goto.
+  // Only navigate when targetPath is explicitly provided or when the page is not
+  // on the Qwen origin yet (e.g. about:blank).
+  const targetUrl = qwenUrl(targetPath || "/");
   const targetOrigin = new URL(targetUrl).origin;
-  const normalizedTargetPath =
-    new URL(targetUrl).pathname.replace(/\/+$/, "") || "/";
+  const normalizedTargetPath = targetPath
+    ? new URL(targetUrl).pathname.replace(/\/+$/, "") || "/"
+    : null;
 
   return withAccountPage(
     accountId,
@@ -755,10 +756,11 @@ async function withQwenBrowserPage<T>(
         // Navigate below when the current page has no usable URL.
       }
 
-      if (
+      const needsNavigation =
         currentOrigin !== targetOrigin ||
-        (normalizedTargetPath && currentPath !== normalizedTargetPath)
-      ) {
+        (normalizedTargetPath !== null && currentPath !== normalizedTargetPath);
+
+      if (needsNavigation) {
         await page.goto(targetUrl, {
           waitUntil: "domcontentloaded",
           timeout: Math.min(config.timeouts.navigation, operationTimeoutMs),
@@ -773,44 +775,7 @@ async function withQwenBrowserPage<T>(
   );
 }
 
-async function withQwenPersonalizationPage<T>(
-  accountId: string,
-  fn: (page: Page) => Promise<T>,
-  operationTimeoutMs = config.timeouts.page,
-  recoverOnTimeout = true,
-): Promise<T> {
-  return withQwenBrowserPage(
-    accountId,
-    async (page) => {
-      try {
-        return await fn(page);
-      } finally {
-        if (!page.isClosed()) {
-          try {
-            const currentUrl = new URL(page.url());
-            const currentPath = currentUrl.pathname.replace(/\/+$/, "") || "/";
-            if (currentUrl.origin !== qwenOrigin() || currentPath !== "/") {
-              await page.goto(qwenUrl("/"), {
-                waitUntil: "domcontentloaded",
-                timeout: Math.min(config.timeouts.navigation, operationTimeoutMs),
-              });
-            }
-          } catch (error) {
-            // Do not mask the personalization request result if restoring the
-            // normal chat page fails; the next normal operation will retry it.
-            logger.warn("[Qwen] Could not restore chat page after personalization", {
-              accountId,
-              error: error instanceof Error ? error.message : String(error),
-            });
-          }
-        }
-      }
-    },
-    "/settings/personalization",
-    operationTimeoutMs,
-    recoverOnTimeout,
-  );
-}
+
 
 /**
  * Build minimal headers for browser-side fetch. The browser automatically
@@ -1951,14 +1916,31 @@ function formatPublicQwenModel(model: Record<string, unknown>): PublicQwenModel
 }
 
 export async function deleteAllQwenChats(accountId?: string): Promise<boolean> {
-  const { headers } = await getQwenHeaders(false, accountId);
+  let requestHeaders: Record<string, string>;
+  if (isAuthMockEnabled()) {
+    const { headers } = await getQwenHeaders(false, accountId);
+    requestHeaders = buildCapturedQwenHeaders(headers, {
+      referer: qwenUrl("/settings/chats"),
+    });
+  } else {
+    // In live mode, requestQwenTextInBrowser executes inside the authenticated
+    // browser page where session cookies are attached automatically.
+    // Bypassing getQwenHeaders avoids triggering captureQwenHeaders (which sends
+    // a dummy chat completion to intercept anti-fraud tokens not needed for deletions).
+    requestHeaders = {
+      source: "web",
+      version: "0.2.89",
+      timezone: new Date().toString().split(" (")[0],
+      "x-request-id": crypto.randomUUID(),
+      Referer: qwenUrl("/settings/chats"),
+    };
+  }
+
   const response = await requestQwenTextInBrowser(
     accountId,
     "DELETE",
     "/api/v2/chats/",
-    buildCapturedQwenHeaders(headers, {
-      referer: qwenUrl("/settings/chats"),
-    }),
+    requestHeaders,
     undefined,
     { referrer: qwenUrl("/settings/chats") },
   );

package/src/tools/parser.ts

@@ -302,6 +302,14 @@ function advanceMarkdownCodeState(
   let delimiterLength = initialDelimiterLength;
 
   for (let i = 0; i < text.length;) {
+    // Inline code spans (1 or 2 backticks) cannot cross line breaks per CommonMark §6.1.
+    // Only fenced code blocks (3+ backticks) span multiple lines.
+    if (text[i] === "\n" && delimiterLength < 3) {
+      delimiterLength = 0;
+      i++;
+      continue;
+    }
+
     if (text[i] !== "`") {
       i++;
       continue;
@@ -320,7 +328,6 @@ function advanceMarkdownCodeState(
 
     i += runLength;
   }
-
   return delimiterLength;
 }
 
@@ -331,6 +338,13 @@ function findNextToolOpenTagOutsideMarkdownCode(
   let delimiterLength = initialDelimiterLength;
 
   for (let i = 0; i < buffer.length;) {
+    // Inline code spans (1 or 2 backticks) cannot cross line breaks per CommonMark §6.1.
+    if (buffer[i] === "\n" && delimiterLength < 3) {
+      delimiterLength = 0;
+      i++;
+      continue;
+    }
+
     if (buffer[i] === "`") {
       let runLength = 1;
       while (i + runLength < buffer.length && buffer[i + runLength] === "`") {
@@ -346,7 +360,6 @@ function findNextToolOpenTagOutsideMarkdownCode(
       i += runLength;
       continue;
     }
-
     if (delimiterLength === 0 && buffer[i] === "<") {
       const sub = buffer.substring(i);
       for (const name of getOpenNames()) {
@@ -371,6 +384,13 @@ function findPartialToolOpenIndexOutsideMarkdownCode(
   const openNames = getOpenNames();
 
   for (let i = 0; i < buffer.length;) {
+    // Inline code spans (1 or 2 backticks) cannot cross line breaks per CommonMark §6.1.
+    if (buffer[i] === "\n" && delimiterLength < 3) {
+      delimiterLength = 0;
+      i++;
+      continue;
+    }
+
     if (buffer[i] === "`") {
       let runLength = 1;
       while (i + runLength < buffer.length && buffer[i + runLength] === "`") {
@@ -386,7 +406,6 @@ function findPartialToolOpenIndexOutsideMarkdownCode(
       i += runLength;
       continue;
     }
-
     if (delimiterLength === 0 && buffer[i] === "<") {
       const tailLower = buffer.substring(i).toLowerCase();
       if (!tailLower.includes(">")) {