qwenproxy-cli 1.6.1 → 1.6.2

package/src/login.ts

@@ -50,7 +50,8 @@ async function showMenu() {
     }
 
     console.log("\nOptions:");
-    console.log("  [A] Add account");
+    console.log("  [A] Add account (Password)");
+    console.log("  [O] Add account (Passwordless / Email OTP)");
     if (accounts.length > 0) {
       console.log("  [R] Remove an account");
     }
@@ -64,7 +65,22 @@ async function showMenu() {
     }
 
     if (choice === "A") {
-      await addAccountFlow();
+      clear();
+      console.log("=== Add New Account ===\n");
+      console.log("Authentication method:");
+      console.log("  [1] Traditional Password (Email + Password)");
+      console.log("  [2] Passwordless (Email Verification Code / OTP)\n");
+      const method = (await askQuestion("Select method [1/2] (default 1): ")).trim();
+      if (method === "2") {
+        await addAccountOtpFlow();
+      } else {
+        await addAccountPasswordFlow();
+      }
+      continue;
+    }
+
+    if (choice === "O") {
+      await addAccountOtpFlow();
       continue;
     }
 
@@ -75,9 +91,9 @@ async function showMenu() {
   }
 }
 
-async function addAccountFlow() {
+async function addAccountPasswordFlow() {
   clear();
-  console.log("=== Add New Account ===\n");
+  console.log("=== Add New Account (Password Login) ===\n");
   const email = await askQuestion("Email: ");
   if (!email || !email.trim()) {
     console.log("Email is required.");
@@ -151,6 +167,76 @@ async function addAccountFlow() {
   await askQuestion("\nPress Enter to continue...");
 }
 
+async function addAccountOtpFlow() {
+  clear();
+  console.log("=== Add New Account (Passwordless / Email OTP) ===\n");
+  const email = await askQuestion("Email: ");
+  if (!email || !email.trim()) {
+    console.log("Email is required.");
+    await askQuestion("Press Enter to continue...");
+    return;
+  }
+
+  const trimmedEmail = email.trim();
+  const existingAccounts = listAccounts();
+  if (
+    existingAccounts.some(
+      (a) => a.email.toLowerCase() === trimmedEmail.toLowerCase(),
+    )
+  ) {
+    console.log(
+      `\n❌ Error: An account with email "${trimmedEmail}" already exists.`,
+    );
+    await askQuestion("Press Enter to continue...");
+    return;
+  }
+
+  console.log(
+    `\n⏳ Requesting OTP verification code for ${maskEmail(trimmedEmail)}...`,
+  );
+
+  const { startEmailOtpLogin, verifyEmailOtpLogin, cancelEmailOtpLogin } =
+    await import("./services/playwright.ts");
+
+  const startRes = await startEmailOtpLogin(trimmedEmail, { headless: false });
+  if (!startRes.success || !startRes.sessionId) {
+    console.log(
+      `\n❌ Failed to request code: ${startRes.error || "Unknown error"}`,
+    );
+    await askQuestion("Press Enter to continue...");
+    return;
+  }
+
+  console.log(`\n✉️  Verification code sent to ${trimmedEmail}!`);
+  console.log("Check your email inbox (and spam folder).\n");
+
+  while (true) {
+    const code = await askQuestion("Enter 6-digit code (or 'C' to cancel): ");
+    if (!code || !code.trim()) continue;
+
+    if (code.trim().toUpperCase() === "C") {
+      await cancelEmailOtpLogin(startRes.sessionId);
+      console.log("\nLogin cancelled.");
+      await askQuestion("Press Enter to continue...");
+      return;
+    }
+
+    console.log("\n⏳ Verifying code and establishing 30-day session...");
+    const verifyRes = await verifyEmailOtpLogin(startRes.sessionId, code.trim());
+    if (verifyRes.success && verifyRes.account) {
+      console.log(
+        `\n✅ Account verified and saved: ${maskEmail(verifyRes.account.email)} (${verifyRes.account.id})`,
+      );
+      console.log("Passwordless 30-day session active.");
+      await askQuestion("\nPress Enter to continue...");
+      return;
+    } else {
+      console.log(`\n❌ ${verifyRes.error || "Invalid code"}`);
+      console.log("Please try again or enter 'C' to cancel.\n");
+    }
+  }
+}
+
 async function removeAccountFlow() {
   const accounts = listAccounts();
   if (accounts.length === 0) return;

package/src/routes/chat/account.ts

@@ -82,8 +82,8 @@ const MAX_ANTI_BOT_ROTATIONS = 1;
  * a stuck account page (closed context / WAF) can otherwise hold each browser
  * op for 60s and keep the personalization mutex blocked for minutes.
  */
-export const PERSONALIZATION_SYNC_DEADLINE_MS = 45_000;
-export const COLD_ACCOUNT_PERSONALIZATION_SYNC_DEADLINE_MS = 60_000;
+export const PERSONALIZATION_SYNC_DEADLINE_MS = 90_000;
+export const COLD_ACCOUNT_PERSONALIZATION_SYNC_DEADLINE_MS = 120_000;
 
 export function computePersonalizationDeadlineMs(
 	accountId: string | undefined,
@@ -1282,8 +1282,15 @@ async function tryCreateStreamWithRetry(
 							const { isCaptchaRecoveryActive } = await import(
 								"../../services/captcha-coordinator.ts"
 							);
-							if (currentAccountId && isCaptchaRecoveryActive(currentAccountId)) {
-								// Captcha solver is actively solving puzzle in background; extend deadline by 30s
+							const { isPlaywrightInitializing } = await import(
+								"../../services/playwright.ts"
+							);
+							if (
+								currentAccountId &&
+								(isCaptchaRecoveryActive(currentAccountId) ||
+									isPlaywrightInitializing(currentAccountId))
+							) {
+								// Captcha solver is actively solving puzzle or browser is launching/initializing; extend deadline by 30s
 								acquireDeadlineTimer = setTimeout(checkDeadline, 30_000);
 								acquireDeadlineTimer.unref?.();
 								return;

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

@@ -22,6 +22,7 @@ import {
   ValidationError,
 } from "../../core/errors.ts";
 import { isAbortError } from "./helpers.ts";
+import { isOverloadMessage, OVERLOAD_COOLDOWN_MS } from "../../utils/overload-detector.ts";
 
 export type RetryAction = {
   /** Outer/create-stream layer should retry this failure */
@@ -50,6 +51,9 @@ export type RetryableStreamError = RetryableQwenStreamError & {
   retryWithFullPrompt?: boolean;
   switchAccount?: boolean;
   dropFiles?: boolean;
+  accountCooldownMs?: number;
+  accountCooldownReason?: string;
+  reason?: string;
 };
 
 function errMessage(err: unknown): string {
@@ -231,10 +235,11 @@ export function isAccountInitializationError(err: unknown): boolean {
 }
 
 export function isQuotaLikeError(err: unknown): boolean {
-  // Chat-not-exist / invalid attachment must never look like quota.
+  // Chat-not-exist / invalid attachment / explicit overload must never look like quota.
   if (isChatNotExistError(err) || isInvalidInputError(err)) return false;
-
   const code = errCode(err).toLowerCase();
+  if (code === "server_overloaded" || code === "overload") return false;
+
   const message = errMessage(err).toLowerCase();
 
   // Note: RetryableQwenStreamError inherits OpenAI-style code "rate_limit_exceeded".
@@ -424,6 +429,26 @@ export function isInternalServerError(err: unknown): boolean {
   );
 }
 
+/**
+ * Detects in-band plain text overload messages from Qwen.
+ */
+export function isOverloadError(err: unknown): boolean {
+  const code = errCode(err).toLowerCase();
+  if (
+    code === "quota_limit" ||
+    code === "ratelimited" ||
+    code === "rate_limit" ||
+    code === "rate_limit_exceeded" ||
+    code === "membership_limit" ||
+    code === "internal_error" ||
+    code === "internal_server_error"
+  ) {
+    return false;
+  }
+  if (code === "server_overloaded" || code === "overload") return true;
+  return !code && isOverloadMessage(errMessage(err));
+}
+
 /**
  * Build a RetryAction with sane defaults so each classification branch only
  * spells out the fields it actually changes. Defaults: retryable, no account
@@ -610,6 +635,18 @@ export function classifyRetryAction(
       });
     }
 
+    if (isOverloadError(err)) {
+      const typed = err as RetryableStreamError;
+      return makeRetryAction("server_busy", {
+        switchAccount: true,
+        forceNewChat: true,
+        retryWithFullPrompt: true,
+        retryAfterMs: typed.retryAfterMs ?? 3_000,
+        accountCooldownMs: OVERLOAD_COOLDOWN_MS,
+        accountCooldownReason: "ServerOverloaded",
+      });
+    }
+
     if (isInternalServerError(err) && !(err instanceof QwenUpstreamError)) {
       const typed = err as RetryableStreamError;
       return makeRetryAction("upstream_internal_error", {
@@ -654,11 +691,13 @@ export function classifyRetryAction(
     if (err instanceof RetryableQwenStreamError) {
       const typed = err as RetryableStreamError;
       // Default switch unless caller explicitly set switchAccount=false
-      return makeRetryAction("explicit_retryable", {
+      return makeRetryAction(typed.reason || "explicit_retryable", {
         switchAccount: typed.switchAccount !== false,
         forceNewChat: typed.forceNewChat === true,
         retryWithFullPrompt: typed.retryWithFullPrompt === true,
         retryAfterMs: typed.retryAfterMs ?? baseDelayMs,
+        accountCooldownMs: typed.accountCooldownMs,
+        accountCooldownReason: typed.accountCooldownReason,
       });
     }
 
@@ -702,6 +741,9 @@ export function toRetryableStreamError(
   error.retryWithFullPrompt = merged.retryWithFullPrompt;
   error.switchAccount = merged.switchAccount;
   error.dropFiles = merged.dropFiles;
+  error.accountCooldownMs = merged.accountCooldownMs;
+  error.accountCooldownReason = merged.accountCooldownReason;
+  error.reason = merged.reason;
   return error;
 }
 

package/src/routes/chat/streaming.ts

@@ -79,6 +79,7 @@ import {
   applyUpstreamUsage,
   buildUsage,
 } from "./helpers.ts";
+import { isOverloadMessage, OVERLOAD_COOLDOWN_MS } from "../../utils/overload-detector.ts";
 
 function firstString(...values: unknown[]): string | null {
   for (const value of values) {
@@ -477,6 +478,19 @@ export async function processNonStreamingResponse(
               isThinkingChunk = false;
               if (delta.content !== undefined) {
                 const newContent = delta.content || "";
+                if (isOverloadMessage(newContent)) {
+                  throw toRetryableStreamError(
+                    "server_overloaded",
+                    newContent,
+                    {
+                      switchAccount: true,
+                      forceNewChat: true,
+                      reason: "server_busy",
+                      accountCooldownMs: OVERLOAD_COOLDOWN_MS,
+                      accountCooldownReason: "ServerOverloaded",
+                    },
+                  );
+                }
                 const result = getIncrementalDelta(
                   lastRawContent,
                   newContent,
@@ -1875,6 +1889,19 @@ export async function processStreamingResponse(
                 isThinkingChunk = false;
                 if (delta.content !== undefined) {
                   const newContent = delta.content || "";
+                  if (!emittedModelOutput && isOverloadMessage(newContent)) {
+                    throw toRetryableStreamError(
+                      "server_overloaded",
+                      newContent,
+                      {
+                        switchAccount: true,
+                        forceNewChat: true,
+                        reason: "server_busy",
+                        accountCooldownMs: OVERLOAD_COOLDOWN_MS,
+                        accountCooldownReason: "ServerOverloaded",
+                      },
+                    );
+                  }
                   const result = getIncrementalDelta(
                     lastRawContent,
                     newContent,