qwenproxy-cli 1.0.0

package/src/core/waf-isolation.ts

@@ -0,0 +1,117 @@
+/**
+ * WAF hard-block contingency (aligned with upstream account-isolation.ts).
+ *
+ * When a Baxia/TMD challenge could NOT be solved, quarantining the account is
+ * not enough: the fingerprint seed is derived from the accountId, so the
+ * account returns from cooldown on the SAME device identity the WAF already
+ * flagged, and the challenge re-propagates immediately. The contingency here:
+ *  - escalates the quarantine window per consecutive hard block (×2, capped),
+ *  - rotates the account's fingerprint seed (fresh device identity),
+ *  - closes the account's Playwright context so the next use re-initializes
+ *    with the rotated profile (cookies/storage persist in the profile dir).
+ *
+ * Strictly per-account: a block on one account never touches another's state.
+ */
+import { config } from "./config.ts";
+import { logger } from "./logger.ts";
+import { markAccountRateLimited } from "./account-manager.ts";
+import { rotateFingerprintSeed } from "../services/fingerprint.ts";
+
+const ESCALATION_FACTOR = 2;
+const MAX_CONSECUTIVE_FOR_ESCALATION = 4;
+
+interface WafBlockState {
+  consecutiveHardBlocks: number;
+  lastBlockAt: number;
+}
+
+const states = new Map<string, WafBlockState>();
+
+export interface WafBlockResult {
+  cooldownMs: number;
+  fingerprintRotated: true;
+  escalated: boolean;
+}
+
+type ContextResetListener = (accountId: string) => void | Promise<void>;
+let contextResetListener: ContextResetListener | null = null;
+
+/**
+ * Register the hook that physically resets an account's browser context after
+ * a fingerprint rotation. Injected by the Playwright layer so this module
+ * stays decoupled from it (and unit-testable without a browser).
+ */
+export function setWafContextResetListener(fn: ContextResetListener | null): void {
+  contextResetListener = fn;
+}
+
+function getState(accountId: string): WafBlockState {
+  let state = states.get(accountId);
+  if (!state) {
+    state = { consecutiveHardBlocks: 0, lastBlockAt: 0 };
+    states.set(accountId, state);
+  }
+  return state;
+}
+
+export function getWafHardBlockCount(accountId: string): number {
+  return states.get(accountId)?.consecutiveHardBlocks ?? 0;
+}
+
+/**
+ * Record an unsolvable WAF challenge on `accountId`: quarantine (escalating),
+ * rotate the device fingerprint, and reset the browser context.
+ */
+export function recordWafHardBlock(accountId: string): WafBlockResult {
+  const state = getState(accountId);
+  state.consecutiveHardBlocks += 1;
+  state.lastBlockAt = Date.now();
+
+  const base = config.captcha.accountCooldownMs;
+  const cap = config.captcha.hardBlockMaxCooldownMs;
+  const exponent = Math.min(
+    state.consecutiveHardBlocks - 1,
+    MAX_CONSECUTIVE_FOR_ESCALATION,
+  );
+  const cooldownMs = Math.min(cap, base * Math.pow(ESCALATION_FACTOR, exponent));
+
+  if (cooldownMs > 0) {
+    markAccountRateLimited(accountId, cooldownMs, "WafChallenge");
+  }
+
+  rotateFingerprintSeed(accountId);
+  logger.warn(
+    `[WafIsolation] Hard WAF block on ${accountId}: fingerprint rotated (streak ${state.consecutiveHardBlocks}), quarantined ${Math.round(cooldownMs / 1000)}s`,
+  );
+
+  if (contextResetListener) {
+    // Best-effort: the next use re-initializes the context with the rotated
+    // profile; a failed close must not abort the quarantine.
+    void Promise.resolve(contextResetListener(accountId)).catch((error: unknown) => {
+      logger.warn(
+        `[WafIsolation] Context reset listener failed for ${accountId}: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    });
+  }
+
+  return {
+    cooldownMs,
+    fingerprintRotated: true,
+    escalated: state.consecutiveHardBlocks > 1,
+  };
+}
+
+/** A successful stream on the account clears the escalation streak. */
+export function noteWafRecovery(accountId: string): void {
+  const state = states.get(accountId);
+  if (state && state.consecutiveHardBlocks > 0) {
+    state.consecutiveHardBlocks = 0;
+  }
+}
+
+/** Test/admin helper: drop all isolation state for an account. */
+export function clearWafIsolation(accountId: string): void {
+  states.delete(accountId);
+}

package/src/core/watchdog.ts

@@ -0,0 +1,195 @@
+import { EventEmitter } from "events";
+import { config } from "./config.js";
+import { metrics } from "./metrics.js";
+import {
+  classifyRamUsage,
+  getHeapUsageSnapshot,
+  getRssUsageSnapshot,
+  type HeapUsageSnapshot,
+  type RssUsageSnapshot,
+} from "./memory-usage.js";
+
+export type { HeapUsageSnapshot, RssUsageSnapshot };
+export {
+  getHeapUsageSnapshot,
+  getRssUsageSnapshot,
+  getMemoryUsagePct,
+  classifyRamUsage,
+} from "./memory-usage.js";
+
+export interface HealthStatus {
+  ram: "ok" | "warning" | "critical";
+  streams: "ok" | "congested" | "blocked";
+  overall: "healthy" | "degraded" | "unhealthy";
+  heap?: HeapUsageSnapshot;
+  /** RSS vs total system memory — the RAM pressure signal used for `ram`. */
+  rss?: RssUsageSnapshot;
+}
+
+export class Watchdog extends EventEmitter {
+  private checkInterval: NodeJS.Timeout | null = null;
+  private consecutiveFailures: number = 0;
+  private recoveryInProgress: boolean = false;
+
+  start(): void {
+    if (this.checkInterval) return;
+
+    this.checkInterval = setInterval(() => {
+      this.performHealthCheck().catch((error) => {
+        this.emit("check:error", error);
+        this.consecutiveFailures++;
+      });
+    }, config.watchdog.checkInterval);
+    this.checkInterval.unref?.();
+
+    this.emit("started");
+  }
+
+  private async performHealthCheck(): Promise<void> {
+    const heap = getHeapUsageSnapshot();
+    const rss = getRssUsageSnapshot();
+    const status: HealthStatus = {
+      // RAM pressure is measured from RSS vs total system memory (not the V8
+      // heap): Playwright browser processes consume memory outside the heap,
+      // so heap-vs-limit misreads real pressure on a VPS.
+      ram: classifyRamUsage(
+        rss.usagePercent,
+        config.watchdog.ram.warningThreshold,
+        config.watchdog.ram.criticalThreshold,
+      ),
+      streams: this.checkStreams(),
+      overall: "healthy",
+      heap,
+      rss,
+    };
+
+    status.overall = this.calculateOverall(status);
+
+    if (status.overall === "unhealthy") {
+      this.consecutiveFailures++;
+      if (
+        this.consecutiveFailures >=
+          config.watchdog.consecutiveFailuresThreshold &&
+        !this.recoveryInProgress
+      ) {
+        await this.triggerRecovery(status);
+      }
+    } else {
+      this.consecutiveFailures = 0;
+    }
+
+    this.emit("health:check", status);
+    metrics.gauge(
+      "watchdog.ram.status",
+      status.ram === "ok" ? 0 : status.ram === "warning" ? 1 : 2,
+    );
+    metrics.gauge(
+      "watchdog.overall",
+      status.overall === "healthy" ? 0 : status.overall === "degraded" ? 1 : 2,
+    );
+    metrics.gauge("memory.heap.limit", heap.heapSizeLimit);
+    metrics.gauge("memory.heap.usage_percent", heap.usagePercent);
+    metrics.gauge("memory.rss", heap.rss);
+    metrics.gauge("memory.rss.usage_percent", rss.usagePercent);
+  }
+
+  private checkStreams(): "ok" | "congested" | "blocked" {
+    const activeStreams = metrics.get("streams.active")?.value || 0;
+    if (activeStreams > config.watchdog.streams.criticalThreshold)
+      return "blocked";
+    if (activeStreams > config.watchdog.streams.warningThreshold)
+      return "congested";
+    return "ok";
+  }
+
+  private calculateOverall(
+    status: HealthStatus,
+  ): "healthy" | "degraded" | "unhealthy" {
+    const critical = ["critical", "blocked"];
+    const warning = ["warning", "congested"];
+
+    const values = [status.ram, status.streams];
+    if (values.some((v) => critical.includes(v))) return "unhealthy";
+    if (values.some((v) => warning.includes(v))) return "degraded";
+    return "healthy";
+  }
+
+  private async triggerRecovery(status: HealthStatus): Promise<void> {
+    if (this.recoveryInProgress) return;
+    this.recoveryInProgress = true;
+
+    this.emit("recovery:start", status);
+    metrics.increment("watchdog.recovery.triggered");
+
+    try {
+      if (status.ram === "critical") {
+        await this.recoverRAM();
+      }
+      if (status.streams === "blocked") {
+        await this.recoverStreams();
+      }
+
+      this.emit("recovery:complete");
+      metrics.increment("watchdog.recovery.success");
+    } catch (error: any) {
+      this.emit("recovery:error", error);
+      metrics.increment("watchdog.recovery.failed");
+    } finally {
+      this.recoveryInProgress = false;
+    }
+  }
+
+  private async recoverRAM(): Promise<void> {
+    if (global.gc) global.gc();
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    this.emit("recovery:ram:freed");
+    // RAM pressure is now measured from RSS, which Playwright browser processes
+    // dominate — GC alone cannot relieve it. Close genuinely parked contexts
+    // (idle mutex, no active stream, preserves the max-active-context minimum)
+    // so the next health check sees the freed RSS.
+    try {
+      const { closeIdlePlaywrightAccounts } = await import(
+        "../services/playwright.js"
+      );
+      const closed = await closeIdlePlaywrightAccounts(
+        config.sessionKeeper.idleMs,
+      );
+      if (closed > 0) {
+        this.emit("recovery:ram:contexts-closed", closed);
+      }
+    } catch {
+      // Playwright may not be initialized (mock mode / pre-start); RSS relief
+      // is best-effort and GC already ran.
+    }
+  }
+
+  private async recoverStreams(): Promise<void> {
+    this.emit("recovery:streams:throttled");
+  }
+
+  stop(): void {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+    this.emit("stopped");
+  }
+
+  getStatus(): Promise<HealthStatus> {
+    const heap = getHeapUsageSnapshot();
+    const rss = getRssUsageSnapshot();
+    const status: HealthStatus = {
+      ram: classifyRamUsage(
+        rss.usagePercent,
+        config.watchdog.ram.warningThreshold,
+        config.watchdog.ram.criticalThreshold,
+      ),
+      streams: this.checkStreams(),
+      overall: "healthy",
+      heap,
+      rss,
+    };
+    status.overall = this.calculateOverall(status);
+    return Promise.resolve(status);
+  }
+}

package/src/delete-chats.ts

@@ -0,0 +1,23 @@
+import "dotenv/config";
+import { deleteChatsForConfiguredAccounts } from "./services/chat-cleanup.ts";
+
+async function run(): Promise<void> {
+  console.log("🗑️  [DeleteChats] Using Playwright sessions");
+
+  const result = await deleteChatsForConfiguredAccounts();
+  console.log(
+    `✅ [DeleteChats] Completed in ${result.mode} mode: ${result.succeeded}/${result.attempted} scope(s) cleared.`,
+  );
+
+  if (result.succeeded !== result.attempted) {
+    process.exitCode = 1;
+  }
+}
+
+run().catch((error) => {
+  console.error(
+    "[DeleteChats] Fatal error:",
+    error instanceof Error ? error.message : String(error),
+  );
+  process.exit(1);
+});

package/src/index.ts

@@ -0,0 +1,64 @@
+import dotenv from 'dotenv'
+import fs from 'node:fs'
+import { getEnvFilePath, ensureDataDirs } from './core/paths.ts'
+
+// Ensure persistent user data directory exists
+ensureDataDirs()
+
+// Load .env from local directory or persistent global OS directory
+const envPath = getEnvFilePath()
+if (fs.existsSync(envPath)) {
+  dotenv.config({ path: envPath })
+} else {
+  dotenv.config()
+}
+// Prevent benign asynchronous driver/browser teardown exceptions from crashing the server
+process.on('uncaughtException', (error: unknown) => {
+  const msg = error instanceof Error ? error.message : String(error)
+  if (
+    msg.includes('Cannot find parent object') ||
+    msg.includes('Target page, context or browser has been closed') ||
+    msg.includes('Browser has been closed') ||
+    msg.includes('Target closed') ||
+    msg.includes('Connection closed')
+  ) {
+    console.warn(`⚠️  [Playwright] Handled benign driver teardown exception: ${msg}`)
+    return
+  }
+  console.error('❌ [Process] Uncaught Exception:', error)
+})
+
+process.on('unhandledRejection', (reason: unknown) => {
+  const msg = reason instanceof Error ? reason.message : String(reason)
+  if (
+    msg.includes('Cannot find parent object') ||
+    msg.includes('Target page, context or browser has been closed') ||
+    msg.includes('Browser has been closed') ||
+    msg.includes('Target closed') ||
+    msg.includes('Connection closed')
+  ) {
+    console.warn(`⚠️  [Playwright] Handled benign driver teardown rejection: ${msg}`)
+    return
+  }
+  console.error('❌ [Process] Unhandled Rejection:', reason)
+})
+import { startServer } from './api/server.js'
+const isTui = process.argv.includes('--tui') || process.env.QWEN_TUI === 'true'
+
+if (isTui) {
+  const { TuiApp } = await import('./tui/app.ts')
+  const app = new TuiApp()
+  await app.start()
+} else {
+  startServer().catch((error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error)
+    // Expected configuration errors are already formatted with an emoji and
+    // actionable guidance; print only the message to avoid leaking stack traces.
+    if (message.includes('[Server]')) {
+      console.error(message)
+    } else {
+      console.error('❌ [Server] Failed to start:', message)
+    }
+    process.exit(1)
+  })
+}

package/src/login.ts

@@ -0,0 +1,147 @@
+import {
+  addAccount,
+  removeAccount,
+  listAccounts,
+  type QwenAccount,
+} from "./core/accounts.ts";
+
+import { maskEmail } from "./core/logger.ts";
+import * as readline from "readline";
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function askQuestion(query: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(query, (answer) => {
+      resolve(answer.trim());
+    });
+  });
+}
+
+function clear() {
+  process.stdout.write("\x1Bc");
+}
+
+async function showMenu() {
+  while (true) {
+    const accounts = listAccounts();
+    clear();
+    console.log("=== QwenProxy Account Manager ===\n");
+    console.log("Auth mode: Playwright (validated on server start)\n");
+
+    if (accounts.length > 0) {
+      console.log(`Configured accounts (${accounts.length}):\n`);
+      for (let i = 0; i < accounts.length; i++) {
+        console.log(
+          `  [${i + 1}] ${accounts[i].email} (ID: ${accounts[i].id})`,
+        );
+      }
+    } else {
+      console.log("No accounts configured yet.\n");
+    }
+
+    console.log("\nOptions:");
+    console.log("  [A] Add account");
+    if (accounts.length > 0) {
+      console.log("  [R] Remove an account");
+    }
+    console.log("  [Q] Quit\n");
+
+    const choice = (await askQuestion("Select an option: ")).toUpperCase();
+
+    if (choice === "Q") {
+      rl.close();
+      process.exit(0);
+    }
+
+    if (choice === "A") {
+      await addAccountFlow();
+      continue;
+    }
+
+    if (choice === "R" && accounts.length > 0) {
+      await removeAccountFlow();
+      continue;
+    }
+  }
+}
+
+async function addAccountFlow() {
+  clear();
+  console.log("=== Add New Account ===\n");
+  const email = await askQuestion("Email: ");
+  if (!email) {
+    console.log("Email is required.");
+    await askQuestion("Press Enter to continue...");
+    return;
+  }
+
+  const password = await askQuestion("Password: ");
+  if (!password) {
+    console.log("Password is required.");
+    await askQuestion("Press Enter to continue...");
+    return;
+  }
+
+  let account: QwenAccount | null = null;
+  try {
+    account = addAccount(email, password);
+    console.log(`Account added: ${maskEmail(account.email)} (${account.id})`);
+    console.log("Credentials will be validated by Playwright on server start.");
+  } catch (err: any) {
+    if (account) removeAccount(account.id);
+    console.log(`\nError: ${err.message}`);
+  }
+
+  await askQuestion("Press Enter to continue...");
+}
+
+async function removeAccountFlow() {
+  const accounts = listAccounts();
+  if (accounts.length === 0) return;
+
+  clear();
+  console.log("=== Remove Account ===\n");
+
+  for (let i = 0; i < accounts.length; i++) {
+    console.log(
+      `  [${i + 1}] ${maskEmail(accounts[i].email)} (ID: ${accounts[i].id})`,
+    );
+  }
+
+  const input = await askQuestion(
+    "\nSelect account number to remove (or 0 to cancel): ",
+  );
+  const idx = parseInt(input) - 1;
+
+  if (isNaN(idx) || idx < 0 || idx >= accounts.length) {
+    console.log(input !== "0" ? "Invalid selection." : "Cancelled.");
+    await askQuestion("Press Enter to continue...");
+    return;
+  }
+
+  const account = accounts[idx];
+  const confirm = await askQuestion(`\nRemove ${account.email}? (y/N): `);
+  if (confirm.toLowerCase() === "y") {
+    if (removeAccount(account.id)) {
+      console.log(`Account ${maskEmail(account.email)} removed.`);
+    } else {
+      console.log("Failed to remove account.");
+    }
+  } else {
+    console.log("Cancelled.");
+  }
+
+  await askQuestion("Press Enter to continue...");
+}
+
+showMenu().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/reset-cooldowns.ts

@@ -0,0 +1,11 @@
+import { clearAllAccountCooldowns } from "./core/account-manager.ts";
+import { loadAccounts } from "./core/accounts.ts";
+
+function main() {
+  const accounts = loadAccounts();
+  console.log(`🔍 Checking cooldowns for ${accounts.length} configured account(s)...`);
+  const cleared = clearAllAccountCooldowns();
+  console.log(`✅ Cooldowns reset successfully: ${cleared} account(s) cleared.`);
+}
+
+main();