qwenproxy-cli 1.0.0

package/src/cache/memory-cache.ts

@@ -0,0 +1,385 @@
+import { promisify } from "util";
+import { brotliCompress, brotliDecompress, constants } from "zlib";
+import { config } from "../core/config.js";
+import { metrics } from "../core/metrics.js";
+
+const compressAsync = promisify(brotliCompress);
+const decompressAsync = promisify(brotliDecompress);
+
+export type CacheKey =
+  | `auth:${string}`
+  | `session:${string}`
+  | `prompt:${string}`
+  | `response:${string}`
+  | `rate:${string}`
+  | `topic:${string}`;
+
+interface CacheEntry<T> {
+  value: T;
+  expiresAt: number;
+  compressed?: boolean;
+}
+
+export class MemoryCache {
+  private connected = false;
+  private store: Map<string, CacheEntry<any>>;
+  private defaultTTL: number;
+  private prefix: string;
+  private cleanupInterval: NodeJS.Timeout | null;
+  private hits: number = 0;
+  private misses: number = 0;
+  private totalBytesSaved: number = 0;
+  private totalCompressedBytes: number = 0;
+  private compressionCount: number = 0;
+  private mutationQueue: Promise<void> = Promise.resolve();
+  // Cache for compiled regex patterns in scan operations (upstream: a63f054)
+  private scanRegexCache: Map<string, RegExp> = new Map();
+
+  constructor(options?: { prefix?: string; defaultTTL?: number }) {
+    this.prefix = options?.prefix || "qwenproxy:";
+    this.defaultTTL = options?.defaultTTL || config.cache.defaultTTL;
+    this.store = new Map();
+    this.cleanupInterval = null;
+
+    this.startCleanup();
+  }
+
+  private startCleanup(): void {
+    this.cleanupInterval = setInterval(() => {
+      if (this.store.size === 0) return;
+      const now = Date.now();
+      for (const [key, entry] of this.store.entries()) {
+        if (entry.expiresAt <= now) {
+          this.store.delete(key);
+        }
+      }
+    }, 60000);
+    this.cleanupInterval.unref?.();
+  }
+
+  async connect(): Promise<void> {
+    this.connected = true;
+  }
+
+  async set<T>(key: CacheKey, value: T, ttl?: number): Promise<void> {
+    const serialized = this.serialize(value);
+    let storedValue: string | Buffer = serialized;
+    let compressed = false;
+    let originalSize: number;
+
+    if (config.cache.compression.enabled) {
+      // Encode once and reuse for both the size check and compression,
+      // avoiding a second UTF-8 pass over large values.
+      const encoded = Buffer.from(serialized);
+      originalSize = encoded.length;
+      if (originalSize >= config.cache.compression.threshold) {
+        try {
+          const compressedBuffer = await compressAsync(encoded, {
+            params: {
+              [constants.BROTLI_PARAM_QUALITY]: config.cache.compression.level,
+            },
+          });
+
+          const compressedSize = compressedBuffer.length;
+          const saved = originalSize - compressedSize;
+
+          if (saved > 0) {
+            storedValue = compressedBuffer;
+            compressed = true;
+            this.totalBytesSaved += saved;
+            this.totalCompressedBytes += compressedSize;
+            this.compressionCount++;
+
+            metrics.increment("cache.compression.bytes.saved", saved);
+            metrics.histogram(
+              "cache.compression.ratio",
+              originalSize / compressedSize,
+            );
+          }
+        } catch (err) {
+          // Compression failed, store uncompressed
+        }
+      }
+    } else {
+      originalSize = Buffer.byteLength(serialized);
+    }
+
+    const effectiveTTL = ttl || this.defaultTTL;
+    const fullKey = this.prefix + key;
+
+    this.store.set(fullKey, {
+      value: storedValue,
+      expiresAt: Date.now() + effectiveTTL * 1000,
+      compressed,
+    });
+
+    metrics.increment("cache.set");
+    metrics.histogram("cache.value.size", originalSize);
+  }
+
+  async get<T>(key: CacheKey): Promise<T | null> {
+    const fullKey = this.prefix + key;
+    const entry = this.store.get(fullKey);
+
+    if (!entry || entry.expiresAt <= Date.now()) {
+      if (entry) this.store.delete(fullKey);
+      this.misses++;
+      metrics.increment("cache.miss");
+      return null;
+    }
+
+    this.hits++;
+    metrics.increment("cache.hit");
+
+    // Decompress if needed
+    if (entry.compressed && Buffer.isBuffer(entry.value)) {
+      try {
+        const decompressed = await decompressAsync(entry.value);
+        return this.deserialize<T>(decompressed.toString());
+      } catch (err) {
+        // Decompression failed, return null
+        this.store.delete(fullKey);
+        return null;
+      }
+    }
+
+    if (entry.compressed) {
+      this.store.delete(fullKey);
+      return null;
+    }
+
+    const serialized =
+      typeof entry.value === "string" ? entry.value : String(entry.value);
+
+    return this.deserialize<T>(serialized);
+  }
+
+  async delete(key: CacheKey): Promise<void> {
+    const fullKey = this.prefix + key;
+    this.store.delete(fullKey);
+    metrics.increment("cache.deleted");
+  }
+
+  async exists(key: CacheKey): Promise<boolean> {
+    const fullKey = this.prefix + key;
+    const entry = this.store.get(fullKey);
+    if (!entry || entry.expiresAt <= Date.now()) {
+      if (entry) this.store.delete(fullKey);
+      return false;
+    }
+    return true;
+  }
+
+  async setWithNX<T>(key: CacheKey, value: T, ttl?: number): Promise<boolean> {
+    return this.withMutation(async () => {
+      const fullKey = this.prefix + key;
+      const entry = this.store.get(fullKey);
+      if (entry && entry.expiresAt > Date.now()) {
+        return false;
+      }
+      if (entry) this.store.delete(fullKey);
+      await this.set(key, value, ttl);
+      return true;
+    });
+  }
+
+  async increment(
+    key: CacheKey,
+    by: number = 1,
+    ttl?: number,
+  ): Promise<number> {
+    return this.withMutation(async () => {
+      const currentValue = await this.get<number>(key);
+      const current =
+        typeof currentValue === "number" && Number.isFinite(currentValue)
+          ? currentValue
+          : 0;
+
+      const newValue = current + by;
+      const effectiveTTL = ttl || this.defaultTTL;
+      const fullKey = this.prefix + key;
+
+      this.store.set(fullKey, {
+        value: this.serialize(newValue),
+        expiresAt: Date.now() + effectiveTTL * 1000,
+      });
+
+      return newValue;
+    });
+  }
+
+  async getMulti<T>(keys: CacheKey[]): Promise<(T | null)[]> {
+    return Promise.all(keys.map((key) => this.get<T>(key)));
+  }
+
+  async scan(pattern: string, _count: number = 100): Promise<string[]> {
+    // Use cached regex for repeated patterns (upstream: a63f054)
+    let regex = this.scanRegexCache.get(pattern);
+    if (!regex) {
+      regex = new RegExp(this.prefix + pattern.replace(/\*/g, ".*"));
+      this.scanRegexCache.set(pattern, regex);
+    }
+    const now = Date.now();
+    const keys: string[] = [];
+
+    for (const [key, entry] of this.store.entries()) {
+      if (regex.test(key) && entry.expiresAt > now) {
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+
+  async flush(pattern?: string): Promise<void> {
+    if (pattern) {
+      const keys = await this.scan(pattern);
+      for (const key of keys) {
+        this.store.delete(key);
+      }
+    } else {
+      this.store.clear();
+    }
+    metrics.increment("cache.flushed");
+  }
+
+  async getStats(): Promise<{
+    connected: boolean;
+    keysCount: number;
+    memoryUsage: string;
+    hitRatio: number;
+    compressionRatio: number;
+    bytesSaved: number;
+  }> {
+    const now = Date.now();
+    let validKeys = 0;
+    let totalBytes = 0;
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt > now) {
+        validKeys++;
+        const valueSize = Buffer.isBuffer(entry.value)
+          ? entry.value.length
+          : Buffer.byteLength(String(entry.value));
+        totalBytes += valueSize + Buffer.byteLength(key);
+      }
+    }
+
+    const totalRequests = this.hits + this.misses;
+    const hitRatio = totalRequests > 0 ? this.hits / totalRequests : 0;
+    const avgCompressionRatio =
+      this.totalCompressedBytes > 0
+        ? (this.totalCompressedBytes + this.totalBytesSaved) /
+          this.totalCompressedBytes
+        : 1;
+
+    // Update gauge metrics
+    metrics.gauge("cache.hit.ratio", hitRatio);
+    metrics.gauge("cache.memory.usage.bytes", totalBytes);
+    metrics.gauge("cache.entries.count", validKeys);
+
+    return {
+      connected: this.connected,
+      keysCount: validKeys,
+      memoryUsage: `${(totalBytes / 1024).toFixed(2)}KB`,
+      hitRatio,
+      compressionRatio: avgCompressionRatio,
+      bytesSaved: this.totalBytesSaved,
+    };
+  }
+
+  private async withMutation<T>(fn: () => Promise<T>): Promise<T> {
+    const previous = this.mutationQueue;
+    let release!: () => void;
+    this.mutationQueue = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+
+    await previous;
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.store.clear();
+    this.connected = false;
+  }
+
+  // Preserve primitive types without coercing numeric-looking strings.
+  private serialize<T>(value: T): string {
+    if (value === null) return "l:";
+    if (value === undefined) return "u:";
+
+    switch (typeof value) {
+      case "string":
+        return `s:${value}`;
+      case "number":
+        return `n:${value}`;
+      case "boolean":
+        return value ? "b:1" : "b:0";
+      default:
+        return `j:${JSON.stringify(value)}`;
+    }
+  }
+
+  private deserialize<T>(serialized: string): T {
+    if (serialized.length >= 2 && serialized[1] === ":") {
+      const type = serialized[0];
+      const payload = serialized.slice(2);
+
+      switch (type) {
+        case "l":
+          return null as T;
+        case "u":
+          return undefined as T;
+        case "s":
+          return payload as T;
+        case "n":
+          return Number(payload) as T;
+        case "b":
+          return (payload === "1") as T;
+        case "j":
+          return JSON.parse(payload) as T;
+      }
+    }
+
+    if (serialized === "null") return null as T;
+    if (serialized === "undefined") return undefined as T;
+    if (serialized === "true") return true as T;
+    if (serialized === "false") return false as T;
+    if (/^-?\d+(\.\d+)?$/.test(serialized)) {
+      return Number(serialized) as T;
+    }
+
+    try {
+      return JSON.parse(serialized) as T;
+    } catch {
+      return serialized as T;
+    }
+  }
+
+  // Invalidate entries by pattern (topic-based)
+  async invalidateByPattern(pattern: string): Promise<number> {
+    const keys = await this.scan(pattern);
+    let count = 0;
+    for (const key of keys) {
+      this.store.delete(key);
+      count++;
+    }
+    if (count > 0) {
+      metrics.increment("cache.topic.invalidation", count);
+    }
+    return count;
+  }
+
+  // Invalidate all entries for a session
+  async invalidateBySession(sessionId: string): Promise<number> {
+    const pattern = `*session:*${sessionId}*`;
+    return this.invalidateByPattern(pattern);
+  }
+}

package/src/clean-cache.ts

@@ -0,0 +1,204 @@
+import "dotenv/config";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { chromium } from "patchright";
+import { pruneAllPlaywrightProfiles } from "./services/playwright.ts";
+
+export function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+
+export function getDirStats(dir: string): { bytes: number; files: number } {
+  let bytes = 0;
+  let files = 0;
+  function walk(d: string) {
+    try {
+      const entries = fs.readdirSync(d, { withFileTypes: true });
+      for (const e of entries) {
+        const full = path.join(d, e.name);
+        if (e.isDirectory()) {
+          walk(full);
+        } else if (e.isFile()) {
+          try {
+            bytes += fs.statSync(full).size;
+            files++;
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  walk(dir);
+  return { bytes, files };
+}
+
+export async function cleanPlaywrightBrowsers(cleanUnused: boolean): Promise<{
+  activeBrowserDir: string | null;
+  unusedDirs: { name: string; path: string; size: string; bytes: number }[];
+  freedBytes: number;
+}> {
+  let activeBrowserDir: string | null = null;
+  let activeRevision: string | null = null;
+  let msPlaywrightDir: string | null = null;
+
+  try {
+    const execPath = chromium.executablePath();
+    // E.g. C:\Users\...\AppData\Local\ms-playwright\chromium-1234\chrome-win64\chrome.exe
+    // The browser folder is the first directory under ms-playwright
+    const resolvedPlaywrightDir = path.resolve(execPath, "..", "..", "..");
+    const rel = path.relative(resolvedPlaywrightDir, execPath);
+    const topFolder = rel.split(path.sep)[0];
+    activeBrowserDir = topFolder;
+    msPlaywrightDir = resolvedPlaywrightDir;
+
+    const matchRev = topFolder.match(/-(\d+)$/);
+    if (matchRev) {
+      activeRevision = matchRev[1];
+    }
+  } catch {}
+
+  if (!msPlaywrightDir || !fs.existsSync(msPlaywrightDir)) {
+    const defaultPlaywrightDir =
+      process.env.PLAYWRIGHT_BROWSERS_PATH ||
+      (process.platform === "win32"
+        ? path.join(os.homedir(), "AppData", "Local", "ms-playwright")
+        : process.platform === "darwin"
+          ? path.join(os.homedir(), "Library", "Caches", "ms-playwright")
+          : path.join(os.homedir(), ".cache", "ms-playwright"));
+    if (fs.existsSync(defaultPlaywrightDir)) {
+      msPlaywrightDir = defaultPlaywrightDir;
+    }
+  }
+
+  const unusedDirs: { name: string; path: string; size: string; bytes: number }[] = [];
+  let freedBytes = 0;
+
+  if (msPlaywrightDir && fs.existsSync(msPlaywrightDir)) {
+    try {
+      const entries = fs.readdirSync(msPlaywrightDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const folderName = entry.name;
+
+        // Never delete:
+        // 1. Exact active browser folder (e.g. chromium-1234)
+        if (folderName === activeBrowserDir) continue;
+
+        // 2. Headless shell sharing the active revision (e.g. chromium_headless_shell-1234)
+        if (activeRevision && folderName.includes(activeRevision)) continue;
+
+        // 3. System tools and critical link directories
+        if (
+          folderName.startsWith("winldd") ||
+          folderName.startsWith("ffmpeg") ||
+          folderName.startsWith(".links") ||
+          folderName.startsWith(".registry")
+        ) {
+          continue;
+        }
+
+        const fullPath = path.join(msPlaywrightDir, folderName);
+        const { bytes } = getDirStats(fullPath);
+        if (bytes > 0) {
+          unusedDirs.push({
+            name: folderName,
+            path: fullPath,
+            size: formatBytes(bytes),
+            bytes,
+          });
+        }
+      }
+
+      if (cleanUnused && unusedDirs.length > 0) {
+        for (const item of unusedDirs) {
+          try {
+            fs.rmSync(item.path, { recursive: true, force: true });
+            freedBytes += item.bytes;
+          } catch (err) {
+            console.warn(`[CleanCache] Warning: could not remove ${item.name}:`, err);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn("[CleanCache] Error reading ms-playwright directory:", err);
+    }
+  }
+
+  return { activeBrowserDir, unusedDirs, freedBytes };
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cleanAll = args.includes("--all") || args.includes("--browsers");
+
+  console.log("==================================================");
+  console.log("  [QwenProxy] Cache & Storage Optimization Tool");
+  console.log("==================================================\n");
+
+  // 1. Profile Transient Cache Pruning (V8 Code Cache, GPU Cache)
+  console.log("1. Limpando caches transitórios dos perfis (data/qwen_profiles/)...");
+  const profileResult = pruneAllPlaywrightProfiles();
+  if (profileResult.totalFreedFiles > 0) {
+    console.log(
+      `   [OK] Perfis limpos com sucesso!`,
+    );
+    console.log(
+      `   Espaço liberado: ${formatBytes(profileResult.totalFreedBytes)} em ${profileResult.totalFreedFiles} arquivos (${profileResult.profilesCleaned} perfil(is)).`,
+    );
+    console.log(
+      `   (Todos os cookies, sessões e logins foram 100% preservados!)`,
+    );
+  } else {
+    console.log("   [OK] Nenhum cache transitório acumulado nos perfis.");
+  }
+  console.log("");
+
+  // 2. Playwright Browser Binaries Cleanup
+  console.log("2. Inspecionando diretório global do Playwright (ms-playwright)...");
+  const browserResult = await cleanPlaywrightBrowsers(cleanAll);
+
+  if (browserResult.activeBrowserDir) {
+    console.log(`   Navegador ativo em uso pelo QwenProxy: ${browserResult.activeBrowserDir}`);
+  }
+
+  if (browserResult.unusedDirs.length > 0) {
+    const totalReclaimable = browserResult.unusedDirs.reduce((acc, d) => acc + d.bytes, 0);
+
+    if (cleanAll) {
+      console.log(`   [OK] ${browserResult.unusedDirs.length} navegador(es) não utilizado(s) removido(s):`);
+      for (const d of browserResult.unusedDirs) {
+        console.log(`     - ${d.name} (${d.size})`);
+      }
+      console.log(`   Total recuperado no SSD: ${formatBytes(browserResult.freedBytes)}!`);
+    } else {
+      console.log(`   [INFO] Encontrados ${browserResult.unusedDirs.length} navegador(es) legados/não utilizados no seu SSD:`);
+      for (const d of browserResult.unusedDirs) {
+        console.log(`     - ${d.name} (${d.size})`);
+      }
+      console.log(`   Espaço recuperável no SSD: ${formatBytes(totalReclaimable)}.`);
+      console.log(`   Para liberar esse espaço automaticamente, execute:`);
+      console.log(`   npm run clean:all\n`);
+    }
+  } else {
+    console.log("   [OK] O diretório do Playwright já está enxuto (sem navegadores órfãos).\n");
+  }
+
+  console.log("==================================================");
+  console.log("  Otimização concluída com segurança!");
+  console.log("==================================================\n");
+}
+
+const isDirectRun =
+  process.argv[1] &&
+  (process.argv[1].endsWith("clean-cache.ts") ||
+    process.argv[1].endsWith("clean-cache.js"));
+
+if (isDirectRun) {
+  main().catch((err) => {
+    console.error("[CleanCache] Erro fatal durante a limpeza:", err);
+    process.exit(1);
+  });
+}