qwenproxy-cli 1.5.3 → 1.6.1

package/src/core/daily-usage.ts

@@ -0,0 +1,276 @@
+/**
+ * QwenProxy - Real-time Daily Token & Quota Metrics Engine
+ *
+ * Tracks empirical per-account and pool-wide daily usage (prompt & completion tokens, turn counts)
+ * keyed strictly by UTC date so it resets automatically every day at 00:00 UTC (21:00 BRT).
+ *
+ * INVARIANT: This is PURELY an observability / monitoring metric for the user.
+ * It NEVER throttles, blocks, or rejects requests locally.
+ */
+
+import { getDatabase } from "./database.ts";
+import { loadAccounts } from "./accounts.ts";
+import { mapClientModelToQwen } from "./model-alias.ts";
+
+/**
+ * Calibrated daily output-tokens baseline per account.
+ * Standard baseline is based on the primary coding model (Plus family): 500,000 output tokens.
+ */
+export const STANDARD_DAILY_TOKEN_BASELINE = 500_000;
+export const DAILY_ACCOUNT_TOKEN_BASELINE = STANDARD_DAILY_TOKEN_BASELINE; // backward-compat
+
+export const MODEL_DAILY_OUTPUT_BASELINES: Record<string, number> = {
+  max: 280_000,
+  plus: 500_000,
+  omni: 620_000,
+};
+
+/**
+ * Returns the normalization weight for a model relative to the standard 500k Plus baseline.
+ * - Max models (280k): 500/280 = ~1.7857x (consumes quota faster)
+ * - Plus models (500k): 1.0x (standard baseline)
+ * - Omni/Flash models (620k): 500/620 = ~0.8065x (lasts longer)
+ */
+export function getModelQuotaWeight(model?: string): number {
+  if (!model) return 1.0;
+  const resolved = mapClientModelToQwen(model).toLowerCase();
+  if (resolved.includes("max")) {
+    return STANDARD_DAILY_TOKEN_BASELINE / MODEL_DAILY_OUTPUT_BASELINES.max;
+  }
+  if (resolved.includes("omni") || resolved.includes("flash")) {
+    return STANDARD_DAILY_TOKEN_BASELINE / MODEL_DAILY_OUTPUT_BASELINES.omni;
+  }
+  return 1.0;
+}
+
+export interface AccountDailyUsage {
+  accountId: string;
+  dateUtc: string;
+  promptTokens: number;
+  completionTokens: number;
+  weightedTokens: number;
+  totalTokens: number;
+  turnsCount: number;
+  usagePercent: number;
+}
+
+export interface PoolDailyUsageSummary {
+  dateUtc: string;
+  totalPromptTokens: number;
+  totalCompletionTokens: number;
+  totalWeightedTokens: number;
+  totalTokens: number;
+  totalTurns: number;
+  poolCapacityTokens: number;
+  poolUsagePercent: number;
+}
+
+/** Formats a timestamp into YYYY-MM-DD in UTC timezone. */
+export function getUtcDateString(timestampMs: number = Date.now()): string {
+  return new Date(timestampMs).toISOString().slice(0, 10);
+}
+
+/**
+ * Records tokens and turn count for a given account on the current UTC date.
+ * Automatically upserts into SQLite `account_daily_usage`.
+ */
+export function recordTurnUsage(
+  accountId: string,
+  usage: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  },
+  modelOrDate?: string,
+  maybeDateUtc?: string,
+): void {
+  if (!accountId || accountId === "global") return;
+
+  let model: string | undefined;
+  let dateUtc: string;
+
+  if (modelOrDate && /^\d{4}-\d{2}-\d{2}$/.test(modelOrDate)) {
+    dateUtc = modelOrDate;
+    model = undefined;
+  } else {
+    model = modelOrDate;
+    dateUtc = maybeDateUtc || getUtcDateString();
+  }
+
+  const prompt = Math.max(0, Number(usage.prompt_tokens) || 0);
+  const completion = Math.max(0, Number(usage.completion_tokens) || 0);
+  const total = Math.max(
+    prompt + completion,
+    Number(usage.total_tokens) || prompt + completion,
+  );
+  const weight = getModelQuotaWeight(model);
+  const weighted = completion * weight;
+
+  try {
+    const db = getDatabase();
+    db.prepare(
+      `
+      INSERT INTO account_daily_usage (
+        account_id, date_utc, prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count, updated_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, 1, datetime('now')
+      )
+      ON CONFLICT(account_id, date_utc) DO UPDATE SET
+        prompt_tokens = prompt_tokens + excluded.prompt_tokens,
+        completion_tokens = completion_tokens + excluded.completion_tokens,
+        weighted_tokens = weighted_tokens + excluded.weighted_tokens,
+        total_tokens = total_tokens + excluded.total_tokens,
+        turns_count = turns_count + 1,
+        updated_at = datetime('now')
+    `,
+    ).run(accountId, dateUtc, prompt, completion, weighted, total);
+  } catch (err: any) {
+    // Non-fatal telemetry: never fail a user completion if DB recording fails
+  }
+}
+
+/**
+ * Returns today's usage statistics for a specific account.
+ */
+export function getAccountDailyUsage(
+  accountId: string,
+  dateUtc: string = getUtcDateString(),
+): AccountDailyUsage {
+  try {
+    const db = getDatabase();
+    const row = db
+      .prepare(
+        `SELECT prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count
+         FROM account_daily_usage
+         WHERE account_id = ? AND date_utc = ?`,
+      )
+      .get(accountId, dateUtc) as any;
+
+    const promptTokens = Number(row?.prompt_tokens) || 0;
+    const completionTokens = Number(row?.completion_tokens) || 0;
+    const weightedTokens = Number(row?.weighted_tokens) || completionTokens;
+    const totalTokens = Number(row?.total_tokens) || 0;
+    const turnsCount = Number(row?.turns_count) || 0;
+
+    const usagePercent = Math.min(
+      100,
+      Math.round((weightedTokens / STANDARD_DAILY_TOKEN_BASELINE) * 100),
+    );
+
+    return {
+      accountId,
+      dateUtc,
+      promptTokens,
+      completionTokens,
+      weightedTokens,
+      totalTokens,
+      turnsCount,
+      usagePercent,
+    };
+  } catch {
+    return {
+      accountId,
+      dateUtc,
+      promptTokens: 0,
+      completionTokens: 0,
+      weightedTokens: 0,
+      totalTokens: 0,
+      turnsCount: 0,
+      usagePercent: 0,
+    };
+  }
+}
+
+/**
+ * Returns daily usage mapped by account_id for the given UTC date.
+ */
+export function getAllAccountsDailyUsage(
+  dateUtc: string = getUtcDateString(),
+): Map<string, AccountDailyUsage> {
+  const result = new Map<string, AccountDailyUsage>();
+  try {
+    const db = getDatabase();
+    const rows = db
+      .prepare(
+        `SELECT account_id, prompt_tokens, completion_tokens, weighted_tokens, total_tokens, turns_count
+         FROM account_daily_usage
+         WHERE date_utc = ?`,
+      )
+      .all(dateUtc) as any[];
+
+    for (const row of rows) {
+      const promptTokens = Number(row.prompt_tokens) || 0;
+      const completionTokens = Number(row.completion_tokens) || 0;
+      const weightedTokens = Number(row.weighted_tokens) || completionTokens;
+      const totalTokens = Number(row.total_tokens) || 0;
+      const turnsCount = Number(row.turns_count) || 0;
+      const usagePercent = Math.min(
+        100,
+        Math.round((weightedTokens / STANDARD_DAILY_TOKEN_BASELINE) * 100),
+      );
+
+      result.set(row.account_id, {
+        accountId: row.account_id,
+        dateUtc,
+        promptTokens,
+        completionTokens,
+        weightedTokens,
+        totalTokens,
+        turnsCount,
+        usagePercent,
+      });
+    }
+  } catch {}
+  return result;
+}
+
+/**
+ * Computes the aggregate pool daily usage and percentage.
+ */
+export function getPoolDailyUsageSummary(
+  targetAccountIds?: string[],
+  dateUtc: string = getUtcDateString(),
+): PoolDailyUsageSummary {
+  const accounts =
+    targetAccountIds && targetAccountIds.length > 0
+      ? targetAccountIds
+      : loadAccounts().map((a) => a.id);
+
+  const accountCount = Math.max(1, accounts.length);
+  const poolCapacityTokens = accountCount * STANDARD_DAILY_TOKEN_BASELINE;
+
+  const usageMap = getAllAccountsDailyUsage(dateUtc);
+
+  let totalPromptTokens = 0;
+  let totalCompletionTokens = 0;
+  let totalWeightedTokens = 0;
+  let totalTokens = 0;
+  let totalTurns = 0;
+
+  for (const id of accounts) {
+    const usage = usageMap.get(id);
+    if (usage) {
+      totalPromptTokens += usage.promptTokens;
+      totalCompletionTokens += usage.completionTokens;
+      totalWeightedTokens += usage.weightedTokens;
+      totalTokens += usage.totalTokens;
+      totalTurns += usage.turnsCount;
+    }
+  }
+
+  const poolUsagePercent = Math.min(
+    100,
+    Math.round((totalWeightedTokens / poolCapacityTokens) * 100),
+  );
+
+  return {
+    dateUtc,
+    totalPromptTokens,
+    totalCompletionTokens,
+    totalWeightedTokens,
+    totalTokens,
+    totalTurns,
+    poolCapacityTokens,
+    poolUsagePercent,
+  };
+}

package/src/core/database.ts

@@ -170,8 +170,28 @@ function runMigrations(db: Database.Database): void {
       instruction_hash TEXT NOT NULL,
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     );
+
+    CREATE TABLE IF NOT EXISTS account_daily_usage (
+      account_id TEXT NOT NULL,
+      date_utc TEXT NOT NULL,
+      prompt_tokens INTEGER NOT NULL DEFAULT 0,
+      completion_tokens INTEGER NOT NULL DEFAULT 0,
+      weighted_tokens REAL NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      turns_count INTEGER NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (account_id, date_utc)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_daily_usage_date ON account_daily_usage(date_utc);
   `);
 
+  try {
+    db.exec(`ALTER TABLE account_daily_usage ADD COLUMN weighted_tokens REAL DEFAULT 0;`);
+  } catch (err) {
+    if (!isDuplicateColumnError(err)) throw err;
+  }
+
   // Cooldown persistence columns — wrapped in try-catch because
   // SQLite doesn't support IF NOT EXISTS for ALTER TABLE ADD COLUMN.
   try {
@@ -341,7 +361,11 @@ export function saveAuthSession(
     ) VALUES (
       ?, ?, ?, ?, ?, ?,
       ?, ?, ?, ?,
-      ?, ?, ?, ?, datetime('now')
+      COALESCE(?, (SELECT user_id FROM qwen_auth_sessions WHERE account_id = ?)),
+      ?,
+      COALESCE(?, (SELECT refresh_token FROM qwen_auth_sessions WHERE account_id = ?)),
+      ?,
+      datetime('now')
     )
   `);
   stmt.run(
@@ -356,8 +380,10 @@ export function saveAuthSession(
     session.secChUaPlatform || null,
     session.version || null,
     session.userId || null,
+    accountId,
     session.tokenExpiresAt || null,
     session.refreshToken || null,
+    accountId,
     session.capturedAt ?? Date.now(),
   );
 }

package/src/core/process-guard.ts

@@ -0,0 +1,77 @@
+/**
+ * Process teardown error guard.
+ *
+ * Catches unhandled rejections and uncaught exceptions that arise from
+ * benign browser/CDP connection closures (e.g. ProtocolError: session closed,
+ * Network.setCacheDisabled, target crashed during shutdown) and prevents
+ * them from terminating the Node.js process.
+ */
+
+export function isPlaywrightAlreadyClosedMessage(message: string): boolean {
+  if (!message) return false;
+  return (
+    message.includes("Target page, context or browser has been closed") ||
+    message.includes("Browser has been closed") ||
+    message.includes("Target closed") ||
+    message.includes("Target crashed") ||
+    message.includes("Page crashed") ||
+    message.includes("Assertion error") ||
+    message.includes("Cannot find parent object") ||
+    message.includes("Connection closed") ||
+    message.includes("session closed") ||
+    message.includes("Session closed") ||
+    message.includes("Network.setCacheDisabled") ||
+    message.includes("Protocol error") ||
+    message.includes("storageState timed out")
+  );
+}
+
+export function isBenignTeardownError(error: unknown): boolean {
+  if (!error) return false;
+  const message =
+    error instanceof Error
+      ? error.message
+      : typeof error === "object" && "message" in error
+        ? String((error as any).message)
+        : String(error);
+  return isPlaywrightAlreadyClosedMessage(message);
+}
+
+let guardsInstalled = false;
+
+/**
+ * Installs process-wide handlers for uncaughtException and unhandledRejection
+ * to guard against asynchronous Playwright/CDP driver teardown crashes.
+ */
+export function installProcessTeardownGuards(label = "Process"): void {
+  if (guardsInstalled) return;
+  guardsInstalled = true;
+
+  process.on("uncaughtException", (error: unknown) => {
+    if (isBenignTeardownError(error)) {
+      const msg =
+        error instanceof Error
+          ? error.message
+          : typeof error === "object" && error !== null && "message" in error
+            ? String((error as any).message)
+            : String(error);
+      console.warn(`⚠️  [${label}] Handled benign driver teardown exception: ${msg}`);
+      return;
+    }
+    console.error(`❌ [${label}] Uncaught Exception:`, error);
+  });
+
+  process.on("unhandledRejection", (reason: unknown) => {
+    if (isBenignTeardownError(reason)) {
+      const msg =
+        reason instanceof Error
+          ? reason.message
+          : typeof reason === "object" && reason !== null && "message" in reason
+            ? String((reason as any).message)
+            : String(reason);
+      console.warn(`⚠️  [${label}] Handled benign driver teardown rejection: ${msg}`);
+      return;
+    }
+    console.error(`❌ [${label}] Unhandled Rejection:`, reason);
+  });
+}

package/src/core/version.ts

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

package/src/delete-chats.ts

@@ -1,6 +1,9 @@
 import "dotenv/config";
+import { installProcessTeardownGuards } from "./core/process-guard.ts";
 import { deleteChatsForConfiguredAccounts } from "./services/chat-cleanup.ts";
 
+installProcessTeardownGuards("DeleteChats");
+
 async function run(): Promise<void> {
   console.log("🗑️  [DeleteChats] Using Playwright sessions");
 

package/src/index.ts

@@ -16,36 +16,10 @@ if (fs.existsSync(envPath)) {
 } else {
   dotenv.config({ quiet: true })
 }
-// Prevent benign asynchronous driver/browser teardown exceptions from crashing the server
-process.on('uncaughtException', async (error: unknown) => {
-  const { isPlaywrightAlreadyClosedError } = await import('./services/playwright.ts');
-  if (isPlaywrightAlreadyClosedError(error)) {
-    const msg =
-      error instanceof Error
-        ? error.message
-        : typeof error === 'object' && error !== null && 'message' in error
-          ? String((error as any).message)
-          : String(error);
-    console.warn(`⚠️  [Playwright] Handled benign driver teardown exception: ${msg}`);
-    return;
-  }
-  console.error('❌ [Process] Uncaught Exception:', error);
-});
+import { installProcessTeardownGuards } from './core/process-guard.ts'
 
-process.on('unhandledRejection', async (reason: unknown) => {
-  const { isPlaywrightAlreadyClosedError } = await import('./services/playwright.ts');
-  if (isPlaywrightAlreadyClosedError(reason)) {
-    const msg =
-      reason instanceof Error
-        ? reason.message
-        : typeof reason === 'object' && reason !== null && 'message' in reason
-          ? String((reason as any).message)
-          : String(reason);
-    console.warn(`⚠️  [Playwright] Handled benign driver teardown rejection: ${msg}`);
-    return;
-  }
-  console.error('❌ [Process] Unhandled Rejection:', reason);
-});
+// Prevent benign asynchronous driver/browser teardown exceptions from crashing the server
+installProcessTeardownGuards("Playwright");
 import { startServer } from './api/server.js'
 const isTui = process.argv.includes('--tui') || process.env.QWEN_TUI === 'true'
 

package/src/login.ts

@@ -9,8 +9,10 @@ import {
 import { maskEmail } from "./core/logger.ts";
 import * as readline from "readline";
 import * as dotenv from "dotenv";
+import { installProcessTeardownGuards } from "./core/process-guard.ts";
 
 dotenv.config();
+installProcessTeardownGuards("Login");
 
 const rl = readline.createInterface({
   input: process.stdin,

package/src/routes/chat/account.ts

@@ -271,8 +271,13 @@ export function resolveInitialAccount(
 
 		// Explicit preferred account (sticky / same-account retry)
 		if (typeof preferredAccountId === "string" && preferredAccountId) {
+			const needle = preferredAccountId.toLowerCase();
 			const preferred = configuredAccounts.find(
-				(candidate) => candidate.id === preferredAccountId,
+				(candidate) =>
+					candidate.id === preferredAccountId ||
+					candidate.id.toLowerCase().startsWith(needle) ||
+					candidate.email.toLowerCase() === needle ||
+					candidate.email.toLowerCase().includes(needle),
 			);
 			if (preferred && !getAccountCooldownInfo(preferred.id)) {
 				return { account: preferred, configuredAccounts };
@@ -939,7 +944,12 @@ async function tryCreateStreamWithRetry(
 	accountEmail: string,
 ): Promise<CreateStreamSuccess | CreateStreamFailure> {
 	const maxAttempts = Math.max(1, config.retry.maxAttempts);
-	const maxAccountSwitches = Math.max(0, config.retry.maxAccountSwitches);
+	const accounts = loadAccounts();
+	const configuredAccountCount = accounts.length;
+	const maxAccountSwitches = Math.max(
+		config.retry.maxAccountSwitches,
+		Math.min(configuredAccountCount - 1, 6),
+	);
 	let attemptsLeft = maxAttempts;
 	let retryDelay = config.retry.baseDelayMs;
 	let attempt = 0;
@@ -956,7 +966,6 @@ async function tryCreateStreamWithRetry(
 	let chatInProgressOriginAccountEmail: string | null = null;
 	let lastAttemptError: any = null;
 	let invalidInputSameAccountRetried = false;
-	const accounts = loadAccounts();
 	const isSingleAccount = accounts.length <= 1;
 	let currentAccountId = accountId;
 	let currentAccountEmail = accountEmail;
@@ -1268,7 +1277,18 @@ async function tryCreateStreamWithRetry(
 				const acquireDeadlineMs = config.concurrency.acquireDeadlineMs;
 				let acquireDeadlineTimer: NodeJS.Timeout | undefined;
 				const acquireDeadline = new Promise<never>((_, reject) => {
-					acquireDeadlineTimer = setTimeout(() => {
+					const checkDeadline = async () => {
+						try {
+							const { isCaptchaRecoveryActive } = await import(
+								"../../services/captcha-coordinator.ts"
+							);
+							if (currentAccountId && isCaptchaRecoveryActive(currentAccountId)) {
+								// Captcha solver is actively solving puzzle in background; extend deadline by 30s
+								acquireDeadlineTimer = setTimeout(checkDeadline, 30_000);
+								acquireDeadlineTimer.unref?.();
+								return;
+							}
+						} catch {}
 						// Abort the losing createQwenStream (it is still queued on the
 						// stream lock or mid-create); the post-lock signal re-check in
 						// createQwenStream then throws instead of letting the orphan
@@ -1279,7 +1299,8 @@ async function tryCreateStreamWithRetry(
 						) as Error & { code?: string };
 						err.code = "acquire_deadline";
 						reject(err);
-					}, acquireDeadlineMs);
+					};
+					acquireDeadlineTimer = setTimeout(checkDeadline, acquireDeadlineMs);
 					acquireDeadlineTimer.unref?.();
 				});
 				result = await Promise.race([
@@ -1740,6 +1761,13 @@ async function tryCreateStreamWithRetry(
 				currentAccountId = nextAccount.id;
 				currentAccountEmail = maskEmail(nextAccount.email);
 				accountSwitches++;
+				const isRealQuotaError =
+					policy.reason === "quota_or_rate_limit" &&
+					(policy.accountCooldownReason === "RateLimited" ||
+						policy.accountCooldownReason === "QuotaExceeded");
+				if (isRealQuotaError) {
+					attemptsLeft = Math.max(attemptsLeft, 1);
+				}
 
 				// Account switch always rebuilds a fresh upstream chat with full history.
 				// Do NOT persist sticky binding until create succeeds — premature empty

package/src/routes/chat/index.ts

@@ -242,7 +242,7 @@ export async function chatCompletions(c: Context) {
       updateLogicalThread: parallelEscape ? false : ctx.updateLogicalThread,
       allowThreadReuse: ctx.allowThreadReuse,
       forceNewChat: parallelEscape,
-      preferredAccountId: undefined,
+      preferredAccountId: c.req.header("x-qwenproxy-account") || undefined,
       messageCount: msgCount,
       fullMessageCount: parsed.messageCount,
       toolsCount: declaredTools.length || undefined,

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

@@ -404,6 +404,26 @@ export function isCorruptedChatHistoryError(err: unknown): boolean {
   );
 }
 
+/**
+ * Qwen upstream internal or server-busy errors.
+ * Transient server-side failures requiring a fresh chat and account switch.
+ */
+export function isInternalServerError(err: unknown): boolean {
+  const code = errCode(err).toLowerCase();
+  const message = errMessage(err).toLowerCase();
+  return (
+    code === "internal_error" ||
+    code === "internal_server_error" ||
+    code === "server_error" ||
+    code === "server_busy" ||
+    code === "busy" ||
+    message.includes("internal_error") ||
+    message.includes("ocorreu um erro inesperado") ||
+    message.includes("unexpected error") ||
+    message.includes("internal server error")
+  );
+}
+
 /**
  * Build a RetryAction with sane defaults so each classification branch only
  * spells out the fields it actually changes. Defaults: retryable, no account
@@ -590,6 +610,16 @@ export function classifyRetryAction(
       });
     }
 
+    if (isInternalServerError(err) && !(err instanceof QwenUpstreamError)) {
+      const typed = err as RetryableStreamError;
+      return makeRetryAction("upstream_internal_error", {
+        switchAccount: typed.switchAccount !== false,
+        forceNewChat: true,
+        retryWithFullPrompt: true,
+        retryAfterMs: typed.retryAfterMs ?? Math.min(baseDelayMs * 2, 3000),
+      });
+    }
+
     if (
         isNetworkLikeError(err) ||
         err instanceof QwenUpstreamUnavailableError ||