@pedrofariasx/qwenproxy 1.1.0

package/src/cache/memory-cache.ts

@@ -0,0 +1,186 @@
+import { config } from '../core/config.js'
+import { metrics } from '../core/metrics.js'
+
+export type CacheKey =
+  | `auth:${string}`
+  | `session:${string}`
+  | `prompt:${string}`
+  | `response:${string}`
+  | `rate:${string}`
+  | `models:${string}`
+
+interface CacheEntry<T> {
+  value: T
+  expiresAt: number
+}
+
+export class MemoryCache {
+  private store: Map<string, CacheEntry<any>>
+  private defaultTTL: number
+  private prefix: string
+  private cleanupInterval: NodeJS.Timeout | null
+
+  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(() => {
+      const now = Date.now()
+      for (const [key, entry] of this.store.entries()) {
+        if (entry.expiresAt <= now) {
+          this.store.delete(key)
+        }
+      }
+    }, 60000)
+  }
+
+  async connect(): Promise<void> {
+    // No-op for in-memory cache
+  }
+
+  async set<T>(key: CacheKey, value: T, ttl?: number): Promise<void> {
+    const serialized = JSON.stringify(value)
+    const effectiveTTL = ttl || this.defaultTTL
+    const fullKey = this.prefix + key
+    
+    this.store.set(fullKey, {
+      value,
+      expiresAt: Date.now() + (effectiveTTL * 1000)
+    })
+    
+    metrics.increment('cache.set')
+    metrics.histogram('cache.value.size', Buffer.byteLength(serialized))
+  }
+
+  async get<T>(key: CacheKey): Promise<T | null> {
+    const start = Date.now()
+    const fullKey = this.prefix + key
+    const entry = this.store.get(fullKey)
+    
+    metrics.histogram('cache.get.latency', Date.now() - start)
+
+    if (!entry || entry.expiresAt <= Date.now()) {
+      if (entry) this.store.delete(fullKey)
+      metrics.increment('cache.miss')
+      return null
+    }
+
+    metrics.increment('cache.hit')
+    return entry.value as T
+  }
+
+  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> {
+    const fullKey = this.prefix + key
+    if (this.store.has(fullKey)) {
+      const entry = this.store.get(fullKey)
+      if (entry && entry.expiresAt > Date.now()) {
+        return false
+      }
+    }
+    await this.set(key, value, ttl)
+    return true
+  }
+
+  async increment(key: CacheKey, by: number = 1, ttl?: number): Promise<number> {
+    const fullKey = this.prefix + key
+    const entry = this.store.get(fullKey)
+    let current = 0
+    
+    if (entry && entry.expiresAt > Date.now()) {
+      current = typeof entry.value === 'number' ? entry.value : 0
+    }
+    
+    const newValue = current + by
+    const effectiveTTL = ttl || this.defaultTTL
+    
+    this.store.set(fullKey, {
+      value: 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[]> {
+    const regex = new RegExp(this.prefix + pattern.replace(/\*/g, '.*'))
+    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
+  }> {
+    const now = Date.now()
+    let validKeys = 0
+    let totalBytes = 0
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt > now) {
+        validKeys++
+        totalBytes += Buffer.byteLength(JSON.stringify(entry.value)) + Buffer.byteLength(key)
+      }
+    }
+    
+    return {
+      connected: true,
+      keysCount: validKeys,
+      memoryUsage: `${(totalBytes / 1024).toFixed(2)}KB`
+    }
+  }
+
+  async close(): Promise<void> {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval)
+      this.cleanupInterval = null
+    }
+    this.store.clear()
+  }
+}
+
+export const cache = new MemoryCache()

package/src/core/account-manager.ts

@@ -0,0 +1,132 @@
+import { QwenAccount, loadAccounts } from './accounts.ts'
+import { config } from './config.js'
+
+let currentIndex = 0
+
+interface CooldownEntry {
+  until: number
+  reason: string
+}
+
+const cooldowns = new Map<string, CooldownEntry>()
+
+const DEFAULT_COOLDOWN_MS = 3 * 60 * 1000 // 3 minutes
+
+let accountsCache: QwenAccount[] | null = null
+let accountsCacheTimestamp = 0
+const ACCOUNTS_CACHE_TTL = config.cache.defaultTTL * 1000
+
+function getCachedAccounts(): QwenAccount[] {
+  const now = Date.now()
+  if (!accountsCache || (now - accountsCacheTimestamp) > ACCOUNTS_CACHE_TTL) {
+    accountsCache = loadAccounts()
+    accountsCacheTimestamp = now
+  }
+  return accountsCache
+}
+
+export function invalidateAccountsCache(): void {
+  accountsCache = null
+  accountsCacheTimestamp = 0
+}
+
+export function markAccountRateLimited(accountId: string, cooldownMs?: number, reason?: string): void {
+  cooldowns.set(accountId, {
+    until: Date.now() + (cooldownMs ?? DEFAULT_COOLDOWN_MS),
+    reason: reason ?? 'RateLimited',
+  })
+  console.log(`[AccountManager] Account ${accountId} marked as rate-limited. Cooldown until ${new Date(Date.now() + (cooldownMs ?? DEFAULT_COOLDOWN_MS)).toISOString()}`)
+}
+
+export function clearAccountCooldown(accountId: string): void {
+  cooldowns.delete(accountId)
+}
+
+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)
+    return null
+  }
+  return { onCooldown: true, remainingMs: remaining, reason: entry.reason }
+}
+
+function isAccountOnCooldown(accountId: string): boolean {
+  return getAccountCooldownInfo(accountId) !== null
+}
+
+export function getNextAccount(forceReset?: boolean): QwenAccount | null {
+  const accounts = getCachedAccounts()
+  if (accounts.length === 0) {
+    return null
+  }
+
+  if (forceReset) {
+    currentIndex = 0
+  }
+
+  for (let i = 0; i < accounts.length; i++) {
+    const account = accounts[currentIndex % accounts.length]
+    currentIndex = (currentIndex + 1) % accounts.length
+    if (!isAccountOnCooldown(account.id)) {
+      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 accounts) {
+    const info = getAccountCooldownInfo(account.id)
+    if (info && info.remainingMs < bestRemaining) {
+      bestRemaining = info.remainingMs
+      best = account
+    }
+  }
+  return best
+}
+
+export function getNextAvailableAccount(skipAccountId?: string): QwenAccount | null {
+  const accounts = getCachedAccounts()
+  if (accounts.length === 0) return null
+
+  for (let i = 0; i < accounts.length; i++) {
+    const idx = (currentIndex + i) % accounts.length
+    const account = accounts[idx]
+    if (skipAccountId && account.id === skipAccountId) continue
+    if (!isAccountOnCooldown(account.id)) {
+      currentIndex = (idx + 1) % accounts.length
+      return account
+    }
+  }
+
+  // All remaining accounts on cooldown — return the one with shortest cooldown
+  let best: QwenAccount | null = null
+  let bestRemaining = Infinity
+  for (const account of accounts) {
+    if (skipAccountId && account.id === skipAccountId) continue
+    const info = getAccountCooldownInfo(account.id)
+    if (info && info.remainingMs < bestRemaining) {
+      bestRemaining = info.remainingMs
+      best = account
+    }
+  }
+  return best
+}
+
+export function getAccountCount(): number {
+  return getCachedAccounts().length
+}
+
+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/accounts.ts

@@ -0,0 +1,78 @@
+import crypto from 'crypto'
+import { getDatabase } from './database.ts'
+import { config } from './config.js'
+
+export interface QwenAccount {
+  id: string
+  email: string
+  password: string
+}
+
+let accountsCache: QwenAccount[] | null = null
+let accountsCacheTimestamp = 0
+const ACCOUNTS_CACHE_TTL = config.cache.defaultTTL * 1000
+
+function getCachedAccounts(): QwenAccount[] {
+  const now = Date.now()
+  if (!accountsCache || (now - accountsCacheTimestamp) > ACCOUNTS_CACHE_TTL) {
+    const db = getDatabase()
+    accountsCache = db.prepare('SELECT id, email, password FROM accounts ORDER BY created_at ASC').all() as QwenAccount[]
+    accountsCacheTimestamp = now
+  }
+  return accountsCache
+}
+
+export function invalidateAccountsCache(): void {
+  accountsCache = null
+  accountsCacheTimestamp = 0
+}
+
+export function loadAccounts(): QwenAccount[] {
+  return getCachedAccounts()
+}
+
+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 email ${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,
+    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)
+  if (result.changes > 0) {
+    invalidateAccountsCache()
+  }
+  return result.changes > 0
+}
+
+export function listAccounts(): QwenAccount[] {
+  return getCachedAccounts().map(a => ({ id: a.id, email: a.email, password: '***' }))
+}
+
+export function getAccountCredentials(id: string): QwenAccount | undefined {
+  const db = getDatabase()
+  const row = db.prepare('SELECT id, email, password FROM accounts WHERE id = ?').get(id)
+  return row as QwenAccount | undefined
+}

package/src/core/config.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod'
+
+const envSchema = z.object({
+  PORT: z.string().default('3000'),
+  HOST: z.string().default('0.0.0.0'),
+  HEADLESS: z.string().default('true'),
+  BROWSER: z.enum(['chromium', 'firefox', 'webkit', 'chrome', 'edge']).default('chromium'),
+  USER_DATA_DIR: z.string().default('./qwen_profiles'),
+  USER_AGENT: z.string().default('Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'),
+  LOG_CONSOLE: z.string().default('false'),
+  NAVIGATION_TIMEOUT: z.string().default('30000'),
+  PAGE_TIMEOUT: z.string().default('15000'),
+  HTTP_TIMEOUT: z.string().default('10000'),
+  CHAT_TIMEOUT: z.string().default('120000'),
+  CACHE_TTL: z.string().default('3600'),
+  RESPONSE_TTL: z.string().default('1800'),
+  METRICS_INTERVAL: z.string().default('10000'),
+  WATCHDOG_INTERVAL: z.string().default('5000'),
+  WATCHDOG_FAILURES: z.string().default('3'),
+  RAM_WARNING: z.string().default('80'),
+  RAM_CRITICAL: z.string().default('95'),
+  WS_WARNING: z.string().default('50'),
+  WS_CRITICAL: z.string().default('100'),
+  QWEN_BASE_URL: z.string().default('https://chat.qwen.ai'),
+  QWEN_HTTP_ENDPOINT: z.string().default('https://api.qwen.ai/v1/chat'),
+  QWEN_API_KEY: z.string().default(''),
+  API_KEY: z.string().default(''),
+})
+
+const env = envSchema.parse(process.env)
+
+export const config = {
+  server: {
+    port: parseInt(env.PORT),
+    host: env.HOST,
+  },
+  browser: {
+    headless: env.HEADLESS !== 'false',
+    type: env.BROWSER,
+    userDataDir: env.USER_DATA_DIR,
+    userAgent: env.USER_AGENT,
+    args: [
+      '--disable-gpu',
+      '--disable-dev-shm-usage',
+      '--disable-accelerated-2d-canvas',
+      '--no-first-run',
+      '--no-zygote',
+      '--disable-features=IsolateOrigins,site-per-process',
+    ],
+    launchTimeout: 30000,
+    healthCheckInterval: 30000,
+    headers: {
+      'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      'accept-language': 'en-US,en;q=0.9',
+    },
+    logConsole: env.LOG_CONSOLE === 'true',
+  },
+  timeouts: {
+    navigation: parseInt(env.NAVIGATION_TIMEOUT),
+    page: parseInt(env.PAGE_TIMEOUT),
+    http: parseInt(env.HTTP_TIMEOUT),
+    chat: parseInt(env.CHAT_TIMEOUT),
+  },
+  cache: {
+    defaultTTL: parseInt(env.CACHE_TTL),
+    responseTTL: parseInt(env.RESPONSE_TTL),
+  },
+  metrics: {
+    interval: parseInt(env.METRICS_INTERVAL),
+  },
+  watchdog: {
+    checkInterval: parseInt(env.WATCHDOG_INTERVAL),
+    consecutiveFailuresThreshold: parseInt(env.WATCHDOG_FAILURES),
+    ram: {
+      warningThreshold: parseInt(env.RAM_WARNING),
+      criticalThreshold: parseInt(env.RAM_CRITICAL),
+    },
+    streams: {
+      warningThreshold: parseInt(env.WS_WARNING),
+      criticalThreshold: parseInt(env.WS_CRITICAL),
+    },
+  },
+  apiKey: env.API_KEY,
+  qwen: {
+    baseUrl: env.QWEN_BASE_URL,
+    httpEndpoint: env.QWEN_HTTP_ENDPOINT,
+    apiKey: env.QWEN_API_KEY,
+  },
+}
+
+export type Config = typeof config

package/src/core/database.ts

@@ -0,0 +1,92 @@
+import Database from 'better-sqlite3'
+import path from 'path'
+import fs from 'fs'
+
+const DATA_DIR = path.resolve('data')
+const DB_PATH = path.join(DATA_DIR, 'qwenproxy.db')
+
+let db: Database.Database | null = null
+
+export function getDatabase(): Database.Database {
+  if (db) return db
+
+  // Ensure data directory exists
+  if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true })
+  }
+
+  db = new Database(DB_PATH)
+
+  // Enable WAL mode for better concurrent read performance (ideal for VPS)
+  db.pragma('journal_mode = WAL')
+  db.pragma('busy_timeout = 5000')
+  db.pragma('synchronous = NORMAL')
+  db.pragma('cache_size = -64000') // 64MB cache
+  db.pragma('foreign_keys = ON')
+
+  runMigrations(db)
+  migrateFromJson(db)
+
+  return db
+}
+
+function runMigrations(db: Database.Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS accounts (
+      id TEXT PRIMARY KEY,
+      email TEXT UNIQUE NOT NULL,
+      password TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_accounts_email ON accounts(email);
+  `)
+}
+
+/**
+ * Auto-migrate existing accounts.json into SQLite on first run.
+ * The JSON file is renamed to accounts.json.bak after successful migration.
+ */
+function migrateFromJson(db: Database.Database): void {
+  const jsonPath = path.resolve('accounts.json')
+  if (!fs.existsSync(jsonPath)) return
+
+  try {
+    const raw = fs.readFileSync(jsonPath, 'utf-8')
+    const accounts = JSON.parse(raw) as Array<{ id: string; email: string; password: string }>
+
+    if (!Array.isArray(accounts) || accounts.length === 0) {
+      // Empty or invalid file — just rename it
+      fs.renameSync(jsonPath, jsonPath + '.bak')
+      return
+    }
+
+    const insert = db.prepare(`
+      INSERT OR IGNORE INTO accounts (id, email, password) VALUES (?, ?, ?)
+    `)
+
+    const migrate = db.transaction(() => {
+      for (const account of accounts) {
+        if (account.id && typeof account.email === 'string' && account.email.trim().length > 0) {
+          insert.run(account.id, account.email.trim(), account.password || '')
+        }
+      }
+    })
+
+    migrate()
+
+    // Rename old file to .bak to avoid re-migration
+    fs.renameSync(jsonPath, jsonPath + '.bak')
+    console.log(`[Database] Migrated ${accounts.length} account(s) from accounts.json to SQLite`)
+  } catch (err: any) {
+    console.error('[Database] Failed to migrate accounts.json:', err.message)
+  }
+}
+
+export function closeDatabase(): void {
+  if (db) {
+    db.close()
+    db = null
+  }
+}

package/src/core/logger.ts

@@ -0,0 +1,96 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+export interface LogEntry {
+  timestamp: Date;
+  level: LogLevel;
+  message: string;
+  context?: string;
+  data?: Record<string, unknown>;
+}
+
+export class Logger {
+  private minLevel: LogLevel;
+  private context?: string;
+  
+  constructor(level: LogLevel = 'info', context?: string) {
+    this.minLevel = level;
+    this.context = context;
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    const levels: LogLevel[] = ['debug', 'info', 'warn', 'error'];
+    return levels.indexOf(level) >= levels.indexOf(this.minLevel);
+  }
+
+  private formatEntry(entry: LogEntry): string {
+    const timestamp = entry.timestamp.toISOString();
+    const pad = (str: string): string => str.padStart(5, ' ');
+    const colorCode = (
+      entry.level === 'error' ? '\x1b[31m' :
+      entry.level === 'warn' ? '\x1b[33m' :
+      entry.level === 'debug' ? '\x1b[36m' : ''
+    );
+    const reset = '\x1b[0m';
+    
+    const coloredLevel = colorCode + pad(entry.level.toUpperCase()) + reset;
+    const contextPart = entry.context ? ` [${entry.context}]` : '';
+    
+    let output = `${timestamp} ${coloredLevel}${contextPart} ${entry.message}`;
+    
+    if (entry.data) {
+      output += '\n' + JSON.stringify(entry.data, null, 2);
+    }
+    
+    return output;
+  }
+
+  debug(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('debug')) {
+      console.log(this.formatEntry({
+        timestamp: new Date(),
+        level: 'debug',
+        message: this.context ? `[${this.context}] ${message}` : message,
+        data,
+      }));
+    }
+  }
+
+  info(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('info')) {
+      console.log(this.formatEntry({
+        timestamp: new Date(),
+        level: 'info',
+        message: this.context ? `[${this.context}] ${message}` : message,
+        data,
+      }));
+    }
+  }
+
+  warn(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('warn')) {
+      console.warn(this.formatEntry({
+        timestamp: new Date(),
+        level: 'warn',
+        message: this.context ? `[${this.context}] ${message}` : message,
+        data,
+      }));
+    }
+  }
+
+  error(message: string, data?: Record<string, unknown>): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatEntry({
+        timestamp: new Date(),
+        level: 'error',
+        message: this.context ? `[${this.context}] ${message}` : message,
+        data,
+      }));
+    }
+  }
+
+  child(context: string): Logger {
+    return new Logger(this.minLevel, this.context ? `${this.context}.${context}` : context);
+  }
+}
+
+export const logger = new Logger('info');