qwenproxy-cli 1.0.0 → 1.0.2

package/src/core/watchdog.ts

@@ -1,195 +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);
-  }
-}
+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

@@ -1,23 +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);
-});
+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

@@ -1,64 +1,65 @@
-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)
-  })
-}
+process.env.DOTENV_CONFIG_QUIET = 'true'
+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, quiet: true })
+} else {
+  dotenv.config({ quiet: true })
+}
+// 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)
+  })
+}