qwenproxy-cli 1.0.0

package/src/core/account-manager.ts

@@ -0,0 +1,297 @@
+import {
+  QwenAccount,
+  loadAccounts,
+  updateAccountCooldown,
+} from "./accounts.ts";
+import { getAccountsByPriority } from "./account-priority.ts";
+import { formatCooldownUntil } from "./logger.ts";
+
+let currentIndex = 0;
+
+interface CooldownEntry {
+  until: number;
+  reason: string;
+}
+
+const cooldowns = new Map<string, CooldownEntry>();
+
+/**
+ * Milliseconds until the next UTC midnight plus a safety margin. The Qwen
+ * daily quota resets at 00:00 UTC, so this is the correct "when is this
+ * account usable again" for a quota exhaust — regardless of the upstream
+ * "Wait about N hour(s)" hint (accurate mid-day, but rounds to ~24h near
+ * midnight when the real reset is minutes away).
+ */
+export function computeQuotaCooldownMs(
+  nowMs: number,
+  marginMs = 5 * 60 * 1000,
+): number {
+  const nextMidnight = new Date(nowMs);
+  nextMidnight.setUTCHours(24, 0, 0, 0);
+  const targetMs = nextMidnight.getTime() - nowMs + marginMs;
+  // A daily quota cooldown must never exceed 24h (cap to 24h - 1m so it never spills over
+  // during the first marginMs window after 00:00 UTC).
+  const maxCooldownMs = 24 * 60 * 60 * 1000 - 60_000;
+  return Math.min(maxCooldownMs, Math.max(60_000, targetMs));
+}
+
+// The long-ago 24h blind fallback was the source of "treated available accounts
+// as unavailable": when no explicit duration was given (e.g. a quota exhaust
+// without the wait hint) the account was parked for a full day even though the
+// Qwen daily quota resets at the next UTC midnight. Fall back to the same
+// midnight-based behavior instead.
+function defaultCooldownDurationMs(): number {
+  return computeQuotaCooldownMs(Date.now());
+}
+
+export function markAccountRateLimited(
+  accountId: string,
+  cooldownMs?: number,
+  reason?: string,
+  options: { silent?: boolean } = {},
+): void {
+  const duration = cooldownMs ?? defaultCooldownDurationMs();
+  const until = Date.now() + duration;
+  const cooldownReason = reason ?? "RateLimited";
+
+  cooldowns.set(accountId, {
+    until,
+    reason: cooldownReason,
+  });
+
+  // Persist to database
+  if (accountId !== "global") {
+    try {
+      updateAccountCooldown(accountId, until, cooldownReason);
+    } catch (err) {
+      console.error(
+        `❌ [AccountManager] Failed to save cooldown to DB for ${accountId}:`,
+        (err as Error).message,
+      );
+    }
+  }
+
+  if (!options.silent) {
+    console.log(
+      `⏱️  [AccountManager] Cooldown set | ${accountId} | reason=${cooldownReason} | ${Math.round(duration / 1000)}s | until=${formatCooldownUntil(new Date(until))}`,
+    );
+  }
+}
+
+export function clearAccountCooldown(accountId: string): void {
+  cooldowns.delete(accountId);
+  if (accountId !== "global") {
+    try {
+      updateAccountCooldown(accountId, 0, null);
+    } catch (err) {
+      console.error(
+        `❌ [AccountManager] Failed to clear cooldown in DB for ${accountId}:`,
+        (err as Error).message,
+      );
+    }
+  }
+}
+
+export function clearAllAccountCooldowns(): number {
+  const accounts = loadAccounts();
+  let count = 0;
+  for (const account of accounts) {
+    if (cooldowns.has(account.id) || (account.cooldown_until && account.cooldown_until > 0)) {
+      clearAccountCooldown(account.id);
+      count++;
+    }
+  }
+  cooldowns.delete("global");
+  return count;
+}
+
+export function getAccountCooldownInfo(
+  accountId: string,
+): { onCooldown: boolean; remainingMs: number; reason: string } | null {
+  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(
+          `❌ [AccountManager] Failed to clear expired cooldown in DB:`,
+          (err as Error).message,
+        );
+      }
+    }
+    return null;
+  }
+  return { onCooldown: true, remainingMs: remaining, reason: entry.reason };
+}
+
+function isAccountOnCooldown(accountId: string): boolean {
+  return getAccountCooldownInfo(accountId) !== null;
+}
+
+// ─── Headers-ready gate (mirrors upstream `markAccountReady`) ───────────────
+// Accounts whose anti-bot headers were successfully captured are "ready". The
+// rotation pickers below skip not-ready accounts whenever at least one account
+// IS ready, so a request never lands on a lane that is still warming up or
+// whose context just died (Playwright page unavailable → 300s init cooldown).
+// The gate degrades to "all accounts pass" when NO account is ready (startup
+// warmup / freshly-restored headers) so a single-account or cold pool stays
+// lossless — exactly the upstream `anyReady` rule.
+const headersReadyAccounts = new Set<string>();
+
+export function markAccountHeadersReady(accountId: string): void {
+  if (!accountId || accountId === "global") return;
+  headersReadyAccounts.add(accountId);
+}
+
+export function unmarkAccountHeadersReady(accountId: string): void {
+  if (!accountId) return;
+  headersReadyAccounts.delete(accountId);
+}
+
+export function isAccountHeadersReady(accountId: string): boolean {
+  return headersReadyAccounts.has(accountId);
+}
+
+function anyUsableAccountHeadersReady(
+  accounts: QwenAccount[],
+  triedSet?: Set<string>,
+): boolean {
+  return accounts.some(
+    (a) =>
+      (!triedSet || !triedSet.has(a.id)) &&
+      !isAccountOnCooldown(a.id) &&
+      isAccountHeadersReady(a.id),
+  );
+}
+
+function passesHeadersReadyGate(
+  accountId: string,
+  anyReady: boolean,
+): boolean {
+  return !anyReady || isAccountHeadersReady(accountId);
+}
+
+export function syncCooldownsFromDb(accounts: QwenAccount[]): void {
+  const now = Date.now();
+  for (const account of accounts) {
+    if (account.cooldown_until && account.cooldown_until > now) {
+      if (!cooldowns.has(account.id)) {
+        cooldowns.set(account.id, {
+          until: account.cooldown_until,
+          reason: account.cooldown_reason || "RateLimited",
+        });
+      }
+    } else {
+      if (cooldowns.has(account.id)) {
+        cooldowns.delete(account.id);
+      }
+    }
+  }
+}
+
+export function getNextAccount(): QwenAccount | null {
+  const accounts = loadAccounts();
+  if (accounts.length === 0) {
+    return null;
+  }
+
+  syncCooldownsFromDb(accounts);
+
+  // Ordena por prioridade (contas que funcionaram bem vêm primeiro)
+  const prioritized = getAccountsByPriority(accounts);
+  // Gate: once ANY usable account has captured headers, only ready accounts rotate.
+  // If all ready accounts are on cooldown, anyReady degrades to false so non-ready
+  // accounts can be initialized on-demand instead of falsely reporting pool exhaustion.
+  const anyReady = anyUsableAccountHeadersReady(accounts);
+
+  for (let i = 0; i < prioritized.length; i++) {
+    const account = prioritized[currentIndex % prioritized.length];
+    currentIndex = (currentIndex + 1) % prioritized.length;
+    if (
+      !isAccountOnCooldown(account.id) &&
+      passesHeadersReadyGate(account.id, anyReady)
+    ) {
+      return account;
+    }
+  }
+
+  // All accounts on cooldown — return the one with the shortest remaining cooldown.
+  let best: QwenAccount | null = null;
+  let bestRemaining = Infinity;
+  for (const account of prioritized) {
+    const info = getAccountCooldownInfo(account.id);
+    if (info && info.remainingMs < bestRemaining) {
+      bestRemaining = info.remainingMs;
+      best = account;
+    }
+  }
+  return best;
+}
+
+export function getNextAvailableAccount(
+  triedAccountIds?: Set<string> | string,
+): QwenAccount | null {
+  const accounts = loadAccounts();
+  if (accounts.length === 0) return null;
+
+  syncCooldownsFromDb(accounts);
+
+  let triedSet: Set<string>;
+  if (triedAccountIds instanceof Set) {
+    triedSet = triedAccountIds;
+  } else {
+    triedSet = new Set(triedAccountIds ? [triedAccountIds] : []);
+  }
+
+  // Ordena por prioridade (contas que funcionaram bem vêm primeiro)
+  const prioritized = getAccountsByPriority(accounts);
+  // Gate: once ANY untried, non-cooldown account has captured headers, only ready accounts rotate.
+  // If all ready accounts are on cooldown or tried, anyReady degrades to false so non-ready
+  // accounts can be initialized on-demand instead of falsely reporting pool exhaustion.
+  const anyReady = anyUsableAccountHeadersReady(accounts, triedSet);
+
+  // 1. Try to find an untried account that is NOT on cooldown
+  for (let i = 0; i < prioritized.length; i++) {
+    const idx = (currentIndex + i) % prioritized.length;
+    const account = prioritized[idx];
+    if (triedSet.has(account.id)) continue;
+    if (
+      !isAccountOnCooldown(account.id) &&
+      passesHeadersReadyGate(account.id, anyReady)
+    ) {
+      currentIndex = (idx + 1) % prioritized.length;
+      return account;
+    }
+  }
+
+  // 2. If all untried accounts are on cooldown, return the untried one with the shortest remaining cooldown
+  let best: QwenAccount | null = null;
+  let bestRemaining = Infinity;
+  for (const account of prioritized) {
+    if (triedSet.has(account.id)) continue;
+    const info = getAccountCooldownInfo(account.id);
+    if (info && info.remainingMs < bestRemaining) {
+      bestRemaining = info.remainingMs;
+      best = account;
+    }
+  }
+  return best;
+}
+
+export function getCooldownStatus(): Record<
+  string,
+  { remainingMs: number; reason: string }
+> {
+  const result: Record<string, { remainingMs: number; reason: string }> = {};
+  for (const [id, info] of cooldowns.entries()) {
+    const remaining = info.until - Date.now();
+    if (remaining > 0) {
+      result[id] = { remainingMs: remaining, reason: info.reason };
+    }
+  }
+  return result;
+}

package/src/core/account-priority.ts

@@ -0,0 +1,163 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "fs";
+import { join, resolve } from "path";
+
+interface PriorityData {
+  accountOrder: string[];
+  lastUpdated: number;
+}
+
+/**
+ * Mock account used by test suites (TEST_MOCK_QWEN_AUTH). Must never be
+ * persisted to the real priority file or it pollutes production routing.
+ */
+const MOCK_ACCOUNT_ID = "mock-account";
+
+function isPersistableAccount(accountId: string): boolean {
+  return accountId !== MOCK_ACCOUNT_ID;
+}
+
+import { getDataDir, getAccountPriorityPath } from "./paths.ts";
+
+const DATA_DIR = getDataDir();
+const PRIORITY_FILE = getAccountPriorityPath();
+
+let priorityCache: PriorityData | null = null;
+
+/** Invalidate the in-memory priority cache (test isolation). */
+export function invalidatePriorityCache(): void {
+  priorityCache = null;
+}
+
+function loadPriority(): PriorityData {
+  if (priorityCache) return priorityCache;
+
+  try {
+    if (existsSync(PRIORITY_FILE)) {
+      const data = JSON.parse(readFileSync(PRIORITY_FILE, "utf-8"));
+      // Filter out any mock/test accounts that may have leaked into the file
+      const accountOrder: string[] = (data.accountOrder || []).filter(
+        isPersistableAccount,
+      );
+      priorityCache = {
+        accountOrder,
+        lastUpdated: data.lastUpdated || 0,
+      };
+      return priorityCache!;
+    }
+  } catch (err) {
+    console.error("❌ [AccountPriority] Failed to load priority file:", (err as Error).message);
+  }
+
+  priorityCache = { accountOrder: [], lastUpdated: 0 };
+  return priorityCache;
+}
+
+function savePriority(data: PriorityData): void {
+  try {
+    mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(PRIORITY_FILE, JSON.stringify(data, null, 2), "utf-8");
+    priorityCache = data;
+  } catch (err) {
+    console.error("❌ [AccountPriority] Failed to save priority file:", (err as Error).message);
+  }
+}
+
+/**
+ * Reordena contas: conta que funcionou vai para o topo
+ */
+export function markAccountSuccessful(accountId: string): void {
+  if (!isPersistableAccount(accountId)) return;
+  const data = loadPriority();
+  
+  // Remove se já existe
+  data.accountOrder = data.accountOrder.filter(id => id !== accountId);
+  
+  // Adiciona no topo
+  data.accountOrder.unshift(accountId);
+  data.lastUpdated = Date.now();
+  
+  savePriority(data);
+}
+
+/**
+ * Reordena contas: conta que falhou vai para o final
+ */
+export function markAccountFailed(accountId: string): void {
+  if (!isPersistableAccount(accountId)) return;
+  const data = loadPriority();
+  
+  // Remove se já existe
+  data.accountOrder = data.accountOrder.filter(id => id !== accountId);
+  
+  // Adiciona no final
+  data.accountOrder.push(accountId);
+  data.lastUpdated = Date.now();
+  
+  savePriority(data);
+}
+
+/**
+ * Adiciona conta à prioridade se não existir (prioridade inicial).
+ * Contas novas entram no final da lista, mantendo a ordem de configuração.
+ */
+export function ensureAccountInPriority(accountId: string): void {
+  if (!isPersistableAccount(accountId)) return;
+  const data = loadPriority();
+  
+  // Se já existe, não faz nada
+  if (data.accountOrder.includes(accountId)) {
+    return;
+  }
+  
+  // Adiciona no final (prioridade inicial baixa)
+  data.accountOrder.push(accountId);
+  data.lastUpdated = Date.now();
+  
+  savePriority(data);
+}
+
+/**
+ * Retorna contas ordenadas por prioridade (melhores primeiro)
+ */
+export function getAccountsByPriority<T extends { id: string }>(accounts: T[]): T[] {
+  const data = loadPriority();
+  
+  if (data.accountOrder.length === 0) {
+    return accounts;
+  }
+  
+  // Cria mapa de prioridade (menor índice = maior prioridade)
+  const priorityMap = new Map<string, number>();
+  data.accountOrder.forEach((id, index) => {
+    priorityMap.set(id, index);
+  });
+  
+  // Ordena: contas na lista de prioridade vêm primeiro, depois as que não estão na lista
+  return [...accounts].sort((a, b) => {
+    const priorityA = priorityMap.get(a.id);
+    const priorityB = priorityMap.get(b.id);
+    
+    // Ambos têm prioridade definida
+    if (priorityA !== undefined && priorityB !== undefined) {
+      return priorityA - priorityB;
+    }
+    
+    // Apenas A tem prioridade
+    if (priorityA !== undefined) {
+      return -1;
+    }
+    
+    // Apenas B tem prioridade
+    if (priorityB !== undefined) {
+      return 1;
+    }
+    
+    // Nenhum tem prioridade, mantém ordem original
+    return 0;
+  });
+}

package/src/core/accounts.ts

@@ -0,0 +1,186 @@
+import "dotenv/config";
+import crypto from "crypto";
+import { getDatabase } from "./database.ts";
+import { decrypt, encrypt } from "./crypto-utils.ts";
+
+export interface QwenAccount {
+  id: string;
+  email: string;
+  password: string;
+  cooldown_until?: number;
+  cooldown_reason?: string | null;
+}
+
+function generateId(email: string): string {
+  return crypto
+    .createHash("md5")
+    .update(email)
+    .digest("hex")
+    .replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+}
+
+function parseEnvAccounts(): QwenAccount[] {
+  const envAccounts = process.env.QWEN_ACCOUNTS;
+  if (!envAccounts) return [];
+
+  const separator = envAccounts.includes(";") ? ";" : ",";
+
+  return envAccounts
+    .split(separator)
+    .map((entry, index) => {
+      const trimmed = entry.trim();
+      const colonIdx = trimmed.indexOf(":");
+      if (colonIdx === -1) {
+        console.warn(
+          `[Accounts] Invalid QWEN_ACCOUNTS entry at index ${index}: "${trimmed}"`,
+        );
+        return null;
+      }
+      const email = trimmed.substring(0, colonIdx);
+      const password = trimmed.substring(colonIdx + 1);
+      if (!email || !password) {
+        console.warn(
+          `[Accounts] Invalid QWEN_ACCOUNTS entry at index ${index}: "${trimmed}"`,
+        );
+        return null;
+      }
+      return {
+        id: generateId(email),
+        email: email.trim(),
+        password: password.trim(),
+      };
+    })
+    .filter((a): a is QwenAccount => a !== null);
+}
+
+let lastSyncedEnv = "";
+let lastSyncTime = 0;
+const SYNC_INTERVAL = 30_000;
+
+function syncEnvAccounts(): void {
+  const envAccounts = process.env.QWEN_ACCOUNTS || "";
+  const now = Date.now();
+  if (envAccounts === lastSyncedEnv && now - lastSyncTime < SYNC_INTERVAL)
+    return;
+
+  lastSyncedEnv = envAccounts;
+  lastSyncTime = now;
+
+  const accounts = parseEnvAccounts();
+  if (accounts.length === 0) return;
+
+  const db = getDatabase();
+  const upsert = db.prepare(`
+    INSERT INTO accounts (id, email, password) VALUES (?, ?, ?)
+    ON CONFLICT(email) DO UPDATE SET password = excluded.password, updated_at = datetime('now')
+  `);
+
+  const sync = db.transaction(() => {
+    for (const acc of accounts) {
+      upsert.run(acc.id, acc.email, encrypt(acc.password));
+    }
+  });
+
+  sync();
+}
+
+let accountsCache: QwenAccount[] | null = null;
+let accountsCacheTime = 0;
+const ACCOUNTS_CACHE_TTL = 5_000;
+
+function getCachedAccounts(): QwenAccount[] {
+  syncEnvAccounts();
+
+  const now = Date.now();
+  if (accountsCache && now - accountsCacheTime < ACCOUNTS_CACHE_TTL) {
+    return accountsCache;
+  }
+
+  const db = getDatabase();
+  const rows = db
+    .prepare(
+      "SELECT id, email, password, cooldown_until, cooldown_reason FROM accounts ORDER BY created_at ASC",
+    )
+    .all() as QwenAccount[];
+
+  accountsCache = rows.map((row) => ({
+    ...row,
+    password: decrypt(row.password),
+  }));
+  accountsCacheTime = now;
+  return accountsCache;
+}
+
+export function loadAccounts(): QwenAccount[] {
+  return getCachedAccounts().map((account) => ({
+    ...account,
+    password: "***",
+  }));
+}
+
+export function invalidateAccountsCache(): void {
+  accountsCache = null;
+  accountsCacheTime = 0;
+}
+
+export function addAccount(
+  email: string,
+  password: string,
+  id?: string,
+): QwenAccount {
+  if (!email || typeof email !== "string" || email.trim().length === 0) {
+    throw new Error("Email is required");
+  }
+
+  const db = getDatabase();
+
+  const existing = db
+    .prepare("SELECT id FROM accounts WHERE email = ?")
+    .get(email.trim());
+  if (existing) {
+    throw new Error("Account with this email already exists");
+  }
+
+  const newAccount: QwenAccount = {
+    id: id || crypto.randomUUID(),
+    email: email.trim(),
+    password,
+  };
+
+  db.prepare("INSERT INTO accounts (id, email, password) VALUES (?, ?, ?)").run(
+    newAccount.id,
+    newAccount.email,
+    encrypt(newAccount.password),
+  );
+
+  invalidateAccountsCache();
+  return newAccount;
+}
+
+export function removeAccount(id: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM accounts WHERE id = ?").run(id);
+  invalidateAccountsCache();
+  return result.changes > 0;
+}
+
+export function listAccounts(): QwenAccount[] {
+  return loadAccounts();
+}
+
+export function getAccountCredentials(id: string): QwenAccount | undefined {
+  const cached = getCachedAccounts();
+  return cached.find((a) => a.id === id);
+}
+
+export function updateAccountCooldown(
+  id: string,
+  cooldownUntil: number,
+  reason: string | null,
+): void {
+  const db = getDatabase();
+  db.prepare(
+    "UPDATE accounts SET cooldown_until = ?, cooldown_reason = ? WHERE id = ?",
+  ).run(cooldownUntil, reason, id);
+  invalidateAccountsCache();
+}