qwenproxy-cli 1.0.10 → 1.0.11

package/bin/qwenproxy.js

@@ -196,11 +196,37 @@ const child = spawn(process.execPath, ["--import", tsxLoaderArg, targetPath, ...
   env: process.env,
 });
 
+const restoreTerminal = () => {
+  try {
+    const RESET_SEQ = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1049l\x1b[?25h\x1b[0m";
+    fs.writeSync(1, RESET_SEQ);
+  } catch {}
+  if (process.stdin.setRawMode) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch {}
+  }
+};
+
 child.on("exit", (code, signal) => {
+  restoreTerminal();
   process.exit(code ?? (signal ? 1 : 0));
 });
 
 child.on("error", (err) => {
+  restoreTerminal();
   console.error("❌ [QwenProxy] Failed to execute CLI script:", err.message);
   process.exit(1);
 });
+
+process.on("SIGINT", () => {
+  restoreTerminal();
+  process.exit(130);
+});
+
+process.on("SIGTERM", () => {
+  restoreTerminal();
+  process.exit(143);
+});
+
+process.on("exit", restoreTerminal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qwenproxy-cli",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "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/api/server.ts

@@ -721,9 +721,6 @@ export async function startServer(options?: {
 
           for (const account of remainingAccounts) {
             try {
-              // Add to priority list first (initial priority based on config order)
-              ensureAccountInPriority(account.id);
-
               // Validate login in background
               const ok = await validateAccountLogin(
                 account,
@@ -732,6 +729,8 @@ export async function startServer(options?: {
               );
 
               if (ok) {
+                // Add to priority list only once validated
+                ensureAccountInPriority(account.id);
                 validated++;
                 console.log(
                   `✅ [Server] Standby account validated: ${maskEmail(account.email)}`,
@@ -739,17 +738,28 @@ export async function startServer(options?: {
               } else {
                 failed++;
                 console.warn(
-                  `⚠️  [Server] Standby account login failed: ${maskEmail(account.email)}`,
+                  `⚠️  [Server] Standby account login failed: ${maskEmail(account.email)} (quarantined)`,
+                );
+                const { markAccountRateLimited } = await import("../core/account-manager.ts");
+                markAccountRateLimited(
+                  account.id,
+                  24 * 3600 * 1000,
+                  "AuthFailed: Standby validation failed",
                 );
               }
             } catch (error) {
               failed++;
               console.warn(
-                `⚠️  [Server] Standby account validation error: ${maskEmail(account.email)}: ${getErrorMessage(error)}`,
+                `⚠️  [Server] Standby account validation error: ${maskEmail(account.email)}: ${getErrorMessage(error)} (quarantined)`,
+              );
+              const { markAccountRateLimited } = await import("../core/account-manager.ts");
+              markAccountRateLimited(
+                account.id,
+                24 * 3600 * 1000,
+                `AuthFailed: ${getErrorMessage(error)}`,
               );
             }
           }
-
           if (failed > 0) {
             console.warn(
               `⚠️  [Server] Standby validation finished: ${validated} ok, ${failed} failed`,

package/src/core/config.ts

@@ -75,7 +75,7 @@ const envSchema = z
     // Deadline for the FIRST upstream chunk on thinking models (the reasoning
     // idle of 600s is for gaps AFTER data flows; a stream that produced
     // nothing in this window is dead and should fail fast, retryable).
-    QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("180000"),
+    QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
     TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
     // Mid-stream silence window for thinking models: 3 min with ZERO upstream
     // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and

package/src/routes/chat/account.ts

@@ -474,13 +474,17 @@ export async function acquireUpstreamStream(
 		if (
 			isAccountTemporarilyBusy(accountId) &&
 			params.allowTemporarilyBusyAccountId !== accountId &&
-			accountId !== stickyThreadAccountId
+			accountId !== stickyThreadAccountId &&
+			hasFreeAlternateAccount(configuredAccounts, accountId, triedAccountIds)
 		) {
 			console.log(
 				`⏭️  [Chat] Skipping account ${accountEmail} (${accountId}) temporarily busy (chat in progress)`,
 			);
-			account = getNextAvailableAccount(triedAccountIds);
-			continue;
+			const nextCandidate = getNextAvailableAccount(triedAccountIds);
+			if (nextCandidate && !getAccountCooldownInfo(nextCandidate.id)) {
+				account = nextCandidate;
+				continue;
+			}
 		}
 
 		// Do not wait 30 seconds on a saturated account when another account is

package/src/services/captcha-coordinator.ts

@@ -10,7 +10,7 @@ import {
   solveBaxiaCaptcha,
 } from "./captcha-solver.ts";
 
-const CHALLENGE_NAVIGATION_TIMEOUT_MS = 20_000;
+const CHALLENGE_NAVIGATION_TIMEOUT_MS = 8_000;
 const CHALLENGE_PATH_MARKER = "_____tmd_____";
 
 /**
@@ -114,13 +114,15 @@ export async function recoverBaxiaCaptcha(
   // cannot be mistaken for a stuck browser and reset the account context.
   // 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.max(
+  const solverOperationTimeoutMs = Math.min(
     config.timeouts.page,
-    config.captcha.timeoutMs +
-      config.captcha.maxAttempts *
-        (5_000 + config.captcha.retryDelayMs + config.captcha.settleMs) +
-      2 * CHALLENGE_NAVIGATION_TIMEOUT_MS +
-      5_000,
+    Math.max(
+      15_000,
+      config.captcha.timeoutMs +
+        config.captcha.maxAttempts *
+          (3_000 + config.captcha.retryDelayMs + config.captcha.settleMs) +
+        2 * CHALLENGE_NAVIGATION_TIMEOUT_MS,
+    ),
   );
 
   try {

package/src/services/playwright.ts

@@ -66,6 +66,7 @@ import { Mutex } from "../core/mutex.ts";
 import {
   markAccountHeadersReady,
   unmarkAccountHeadersReady,
+  markAccountRateLimited,
 } from "../core/account-manager.ts";
 import { getAccountsByPriority } from "../core/account-priority.ts";
 import {
@@ -160,7 +161,7 @@ export function buildChromiumLaunchArgs(viewport: {
 // to the pool quickly (the 2026-08-22 log showed a lock held for 154s before
 // the waiter's recovery path finally ran). The chat lock keeps its own longer
 // hold budget (see acquireChatLock).
-const ACCOUNT_MUTEX_MAX_HOLD_MS = 60_000;
+const ACCOUNT_MUTEX_MAX_HOLD_MS = 180_000;
 const accountMutexes = new Map<string, Mutex>();
 
 function getAccountMutex(accountId: string): Mutex {
@@ -1529,9 +1530,67 @@ export async function validateAccountLogin(
     release();
   }
 }
-
 // ─── Login ────────────────────────────────────────────────────────────────────
 
+export interface LoginAttemptResult {
+  success: boolean;
+  permanentFailure?: boolean;
+  reason?: string;
+}
+
+export function classifyQwenAuthError(
+  code?: string,
+  details?: string,
+): { isPermanent: boolean; reason: string } {
+  const c = (code || "").trim().toLowerCase();
+  const d = (details || "").trim().toLowerCase();
+  const combined = `${c} ${d}`;
+
+  if (
+    combined.includes("frozen") ||
+    combined.includes("blocked") ||
+    combined.includes("suspend") ||
+    combined.includes("bloquead")
+  ) {
+    return {
+      isPermanent: true,
+      reason: `Conta bloqueada ou suspensa (${details || code || "AccountSuspended"})`,
+    };
+  }
+
+  if (
+    combined.includes("password") ||
+    combined.includes("senha") ||
+    combined.includes("credential")
+  ) {
+    return {
+      isPermanent: true,
+      reason: `Senha incorreta (${details || code || "PasswordError"})`,
+    };
+  }
+
+  if (
+    combined.includes("user") ||
+    combined.includes("email") ||
+    combined.includes("account") ||
+    combined.includes("not exist") ||
+    combined.includes("not found") ||
+    combined.includes("not registered") ||
+    combined.includes("não encontrado") ||
+    combined.includes("não existe")
+  ) {
+    return {
+      isPermanent: true,
+      reason: `E-mail/usuário não encontrado (${details || code || "UserNotExist"})`,
+    };
+  }
+
+  return {
+    isPermanent: false,
+    reason: details || code || "Falha desconhecida no login",
+  };
+}
+
 async function loginToQwen(
   accountId: string,
   email: string,
@@ -1544,22 +1603,46 @@ async function loginToQwen(
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     // Try API login first
     const apiResult = await loginViaApi(page, email, password);
-    if (apiResult) {
+    if (apiResult.success) {
       await saveStorageState(page.context(), accountId);
       return true;
     }
 
+    if (apiResult.permanentFailure) {
+      console.error(
+        `❌ [Playwright] Falha irrecuperável de autenticação para ${maskEmail(email)}: ${apiResult.reason}`,
+      );
+      markAccountRateLimited(
+        accountId,
+        24 * 3600 * 1000,
+        `AuthPermanentFailure: ${apiResult.reason}`,
+      );
+      return false;
+    }
+
     // Fallback to UI login
     const uiResult = await loginViaUi(page, email, password);
-    if (uiResult) {
+    if (uiResult.success) {
       await saveStorageState(page.context(), accountId);
       return true;
     }
 
+    if (uiResult.permanentFailure) {
+      console.error(
+        `❌ [Playwright] Falha irrecuperável de autenticação para ${maskEmail(email)}: ${uiResult.reason}`,
+      );
+      markAccountRateLimited(
+        accountId,
+        24 * 3600 * 1000,
+        `AuthPermanentFailure: ${uiResult.reason}`,
+      );
+      return false;
+    }
+
     if (attempt < maxAttempts) {
       const backoffMs = attempt * 5_000;
       console.warn(
-        `⚠️  [Playwright] Login attempt ${attempt}/${maxAttempts} failed for ${maskEmail(email)}, retrying in ${backoffMs / 1000}s`,
+        `⚠️  [Playwright] Login attempt ${attempt}/${maxAttempts} failed for ${maskEmail(email)} (${apiResult.reason || uiResult.reason || "falha temporária"}), retrying in ${backoffMs / 1000}s`,
       );
       await sleep(backoffMs);
     }
@@ -1568,6 +1651,11 @@ async function loginToQwen(
   console.error(
     `❌ [Playwright] All login methods failed for ${maskEmail(email)}`,
   );
+  markAccountRateLimited(
+    accountId,
+    24 * 3600 * 1000,
+    "AuthFailed: All login methods exhausted",
+  );
   return false;
 }
 
@@ -1575,7 +1663,7 @@ async function loginViaApi(
   page: Page,
   email: string,
   password: string,
-): Promise<boolean> {
+): Promise<LoginAttemptResult> {
   try {
     await page.goto(qwenUrl("/auth"), {
       waitUntil: "domcontentloaded",
@@ -1585,7 +1673,7 @@ async function loginViaApi(
 
     // Check if already logged in
     if (!page.url().includes("/auth")) {
-      return true;
+      return { success: true };
     }
 
     const hashedPassword = crypto
@@ -1597,22 +1685,20 @@ async function loginViaApi(
     const result = await page.evaluate(
       async ({ email, password, signinUrl }) => {
         try {
-          const response = await fetch(signinUrl,
-            {
-              method: "POST",
-              signal: AbortSignal.timeout(10_000),
-              headers: {
-                accept: "application/json, text/plain, */*",
-                "content-type": "application/json",
-                source: "web",
-                timezone: new Date().toString().split(" (")[0],
-                "x-request-id": crypto.randomUUID(),
-              },
-              body: JSON.stringify({ email, password, login_type: "email" }),
+          const response = await fetch(signinUrl, {
+            method: "POST",
+            signal: AbortSignal.timeout(10_000),
+            headers: {
+              accept: "application/json, text/plain, */*",
+              "content-type": "application/json",
+              source: "web",
+              timezone: new Date().toString().split(" (")[0],
+              "x-request-id": crypto.randomUUID(),
             },
-          );
-          const data = await response.json();
-          return { ok: response.ok, data };
+            body: JSON.stringify({ email, password, login_type: "email" }),
+          });
+          const data = await response.json().catch(() => null);
+          return { ok: response.ok, status: response.status, data };
         } catch (e: any) {
           return { ok: false, error: e.message };
         }
@@ -1620,18 +1706,48 @@ async function loginViaApi(
       { email, password: hashedPassword, signinUrl },
     );
 
+    if (result.data) {
+      if (result.data.success === true) {
+        await page.goto(qwenUrl("/"), {
+          waitUntil: "domcontentloaded",
+          timeout: config.timeouts.navigation,
+        });
+        const loggedIn = !page.url().includes("auth") && !page.url().includes("login");
+        if (loggedIn) {
+          return { success: true };
+        }
+      } else if (result.data.success === false) {
+        const code = result.data?.data?.code || result.data?.code;
+        const details =
+          result.data?.data?.details || result.data?.details || result.data?.message;
+        const classified = classifyQwenAuthError(code, details);
+        return {
+          success: false,
+          permanentFailure: classified.isPermanent,
+          reason: classified.reason,
+        };
+      }
+    }
+
     if (result.ok) {
       await page.goto(qwenUrl("/"), {
         waitUntil: "domcontentloaded",
         timeout: config.timeouts.navigation,
       });
-      return !page.url().includes("auth") && !page.url().includes("login");
+      const loggedIn = !page.url().includes("auth") && !page.url().includes("login");
+      return {
+        success: loggedIn,
+        reason: loggedIn ? undefined : "Redirecionado de volta para /auth após signin",
+      };
     }
 
-    return false;
-  } catch (err) {
-    console.warn(`⚠️  [Playwright] API login error: ${err}`);
-    return false;
+    return {
+      success: false,
+      reason: result.error || `HTTP ${result.status || "desconhecido"} sem corpo JSON válido`,
+    };
+  } catch (err: any) {
+    console.warn(`⚠️  [Playwright] API login error: ${err?.message || err}`);
+    return { success: false, reason: err?.message || String(err) };
   }
 }
 
@@ -1639,7 +1755,7 @@ async function loginViaUi(
   page: Page,
   email: string,
   password: string,
-): Promise<boolean> {
+): Promise<LoginAttemptResult> {
   try {
     await page.goto(qwenUrl("/auth"), {
       waitUntil: "domcontentloaded",
@@ -1649,7 +1765,7 @@ async function loginViaUi(
 
     // Check if already logged in
     if (!page.url().includes("/auth")) {
-      return true;
+      return { success: true };
     }
 
     // Wait for email input
@@ -1665,11 +1781,11 @@ async function loginViaUi(
         timeout: config.timeouts.page,
       });
     } catch {
-      if (!page.url().includes("/auth")) return true;
+      if (!page.url().includes("/auth")) return { success: true };
       console.warn(
         `⚠️  [Playwright] Email input not found on ${page.url()} (possible captcha or anti-bot challenge)`,
       );
-      throw new Error("Email input not found");
+      return { success: false, reason: "Campo de e-mail não encontrado (possível captcha)" };
     }
 
     // Fill email
@@ -1711,6 +1827,28 @@ async function loginViaUi(
     }
     await sleep(3000);
 
+    // Check for UI error elements in DOM (Ant Design errors, alerts, toasts)
+    const errorSelector = [
+      ".ant-form-item-explain-error",
+      ".ant-message-error",
+      ".ant-message-notice",
+      '[role="alert"]',
+      ".qwenchat-auth-error",
+      ".auth-error-message",
+    ].join(", ");
+    const errorEl = page.locator(errorSelector).first();
+    if (await errorEl.isVisible().catch(() => false)) {
+      const errorText = (await errorEl.innerText().catch(() => "")).trim();
+      if (errorText) {
+        const classified = classifyQwenAuthError(undefined, errorText);
+        return {
+          success: false,
+          permanentFailure: classified.isPermanent,
+          reason: `Formulário: ${classified.reason}`,
+        };
+      }
+    }
+
     // Check if login was successful
     const isLoggedIn =
       !page.url().includes("auth") && !page.url().includes("login");
@@ -1720,12 +1858,16 @@ async function loginViaUi(
         waitUntil: "domcontentloaded",
         timeout: config.timeouts.navigation,
       });
+      return { success: true };
     }
 
-    return isLoggedIn;
-  } catch (err) {
-    console.warn(`⚠️  [Playwright] UI login error: ${err}`);
-    return false;
+    return {
+      success: false,
+      reason: "A página permaneceu na tela de autenticação após envio do formulário",
+    };
+  } catch (err: any) {
+    console.warn(`⚠️  [Playwright] UI login error: ${err?.message || err}`);
+    return { success: false, reason: err?.message || String(err) };
   }
 }
 
@@ -2780,7 +2922,7 @@ export async function keepAlivePlaywrightAccount(
     if (shouldNavigate) {
       await page.goto(qwenUrl("/"), {
         waitUntil: "domcontentloaded",
-        timeout: Math.min(config.timeouts.navigation, 15_000),
+        timeout: Math.min(config.timeouts.navigation, 30_000),
       });
       lastKeepAliveNavigation.set(accountId, now);
     } else {

package/src/tui/app.ts

@@ -81,13 +81,19 @@ export class TuiApp {
     // Listen for key events
     // Listen for key and mouse events with microtask coalescing
     this.screen.onKey(async (key) => {
-      await this.handleKey(key);
-      this.requestRender();
+      try {
+        await this.handleKey(key);
+        this.requestRender();
+      } catch (err: any) {
+        console.error(`[TUI] Erro ao processar tecla: ${err?.message || String(err)}`);
+      }
     });
 
     // Listen for terminal resize
     this.screen.onResize(() => {
-      this.render();
+      try {
+        this.render();
+      } catch {}
     });
 
     // Start server in-process together with TUI ("tudo junto uma coisa só")
@@ -219,8 +225,9 @@ export class TuiApp {
   }
   private render(): void {
     if (!this.isRunning) return;
-    const { cols, rows } = this.screen.getSize();
-    const frame: string[] = [];
+    try {
+      const { cols, rows } = this.screen.getSize();
+      const frame: string[] = [];
 
     // 1. Header Deck (Tabs & Title)
     const serverState = ServerManager.getInstance().getState();
@@ -266,6 +273,9 @@ export class TuiApp {
     const availableContentRows = Math.max(8, rows - 3);
     const viewLines = activeView.render(cols, availableContentRows, this.statusSnapshot);
     frame.push(...viewLines);
-    this.screen.render(frame);
+      this.screen.render(frame);
+    } catch (err: any) {
+      console.error(`[TUI] Erro na renderização: ${err?.message || String(err)}`);
+    }
   }
 }

package/src/tui/screen.ts

@@ -207,6 +207,7 @@ export class Screen {
     process.on("SIGTERM", this.exitHandler!);
     process.on("SIGBREAK", this.exitHandler!);
     process.on("exit", this.exitHandler!);
+    process.on("uncaughtException", this.exitHandler!);
     return true;
   }
 
@@ -234,6 +235,7 @@ export class Screen {
       process.removeListener("SIGTERM", this.exitHandler);
       process.removeListener("SIGBREAK", this.exitHandler);
       process.removeListener("exit", this.exitHandler);
+      process.removeListener("uncaughtException", this.exitHandler);
       this.exitHandler = null;
     }