qwenproxy-cli 1.0.0

package/src/core/paths.ts

@@ -0,0 +1,199 @@
+/**
+ * QwenProxy - Unified Cross-Platform Storage & Path Resolution Engine
+ *
+ * Provides resilient, OS-standard persistent data paths for:
+ * - SQLite Database & WAL logs
+ * - AES-256-GCM Master Encryption Key
+ * - Chromium persistent browser profiles (cookies & session storage)
+ * - Account priority & AI client sync caches
+ *
+ * Guarantees zero data loss on package reinstall/update across npm, pnpm, bun, and yarn.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export interface ResolveDataDirOptions {
+  envDataDir?: string;
+  isNodeTest?: boolean;
+  localDataExists?: boolean;
+  platform?: NodeJS.Platform;
+  appData?: string;
+  homeDir?: string;
+  xdgDataHome?: string;
+}
+
+/**
+ * Checks if the current process is running as a unit/mock test.
+ */
+export function isRunningUnderNodeTest(): boolean {
+  return process.argv.some(
+    (arg) =>
+      arg === "--test" ||
+      arg.includes("src/tests/") ||
+      arg.includes("src\\tests\\"),
+  );
+}
+
+/**
+ * Computes the canonical global user data directory according to OS conventions:
+ * - Windows: %APPDATA%\qwenproxy
+ * - macOS:   ~/Library/Application Support/qwenproxy
+ * - Linux:   $XDG_DATA_HOME/qwenproxy or ~/.local/share/qwenproxy
+ */
+export function getOsGlobalDataDir(options?: {
+  platform?: NodeJS.Platform;
+  appData?: string;
+  homeDir?: string;
+  xdgDataHome?: string;
+}): string {
+  const currentPlatform = options?.platform || process.platform;
+  const home = options?.homeDir || os.homedir();
+
+  if (currentPlatform === "win32") {
+    const winPath = path.win32 || path;
+    const appData =
+      options?.appData ||
+      process.env.APPDATA ||
+      winPath.join(home, "AppData", "Roaming");
+    return winPath.join(appData, "qwenproxy");
+  }
+
+  if (currentPlatform === "darwin") {
+    return path.join(home, "Library", "Application Support", "qwenproxy");
+  }
+
+  // Linux / BSD / POSIX
+  const xdgDataHome =
+    options?.xdgDataHome ||
+    process.env.XDG_DATA_HOME ||
+    path.join(home, ".local", "share");
+  return path.join(xdgDataHome, "qwenproxy");
+}
+
+/**
+ * Resolves the active data directory based on environment, testing state,
+ * local checkout presence, or the persistent global OS user directory.
+ */
+export function resolveDataDir(options?: ResolveDataDirOptions): string {
+  // 1. Explicit environment variable override takes top precedence
+  const envDir = options?.envDataDir ?? process.env.QWEN_DATA_DIR;
+  if (envDir && envDir.trim().length > 0) {
+    return path.resolve(envDir.trim());
+  }
+
+  // 2. Automated test isolation
+  const isTest = options?.isNodeTest ?? isRunningUnderNodeTest();
+  if (isTest) {
+    if (options?.localDataExists === false) {
+      return path.resolve("data-test");
+    }
+    if (fs.existsSync(path.resolve("data"))) {
+      return path.resolve("data");
+    }
+    return path.resolve("data-test");
+  }
+  // 3. Local repository checkout (development mode)
+  const localDir = path.resolve("data");
+  const localExists =
+    options?.localDataExists ??
+    (fs.existsSync(path.join(localDir, "db", "qwenproxy.db")) ||
+      fs.existsSync(localDir));
+
+  if (localExists) {
+    return localDir;
+  }
+
+  // 4. Global OS user directory (npm/pnpm/bun/yarn global mode)
+  return getOsGlobalDataDir({
+    platform: options?.platform,
+    appData: options?.appData,
+    homeDir: options?.homeDir,
+    xdgDataHome: options?.xdgDataHome,
+  });
+}
+
+/**
+ * Returns the active root data directory.
+ */
+export function getDataDir(): string {
+  return resolveDataDir();
+}
+
+/**
+ * Directory for SQLite database and encryption key.
+ */
+export function getDbDir(customDataDir?: string): string {
+  return path.join(customDataDir || getDataDir(), "db");
+}
+
+/**
+ * Absolute path to the SQLite database file.
+ */
+export function getDbPath(customDataDir?: string): string {
+  return path.join(getDbDir(customDataDir), "qwenproxy.db");
+}
+
+/**
+ * Absolute path to the master AES-256 encryption key.
+ */
+export function getEncryptionKeyPath(customDataDir?: string): string {
+  return path.join(getDbDir(customDataDir), ".encryption_key");
+}
+
+/**
+ * Directory for persistent Chromium browser profiles.
+ */
+export function getProfilesDir(customDataDir?: string): string {
+  return path.join(customDataDir || getDataDir(), "qwen_profiles");
+}
+
+/**
+ * Path to a specific account's Chromium profile directory.
+ */
+export function getAccountProfilePath(accountId: string, customDataDir?: string): string {
+  return path.join(getProfilesDir(customDataDir), accountId);
+}
+
+/**
+ * Path to account priority persistence file.
+ */
+export function getAccountPriorityPath(customDataDir?: string): string {
+  return path.join(customDataDir || getDataDir(), "account-priority.json");
+}
+
+/**
+ * Path to AI coding clients synchronization state file.
+ */
+export function getSyncStatePath(customDataDir?: string): string {
+  return path.join(customDataDir || getDataDir(), "sync-state.json");
+}
+
+/**
+ * Path to user configuration .env file (either local or in global data dir).
+ */
+export function getEnvFilePath(customDataDir?: string): string {
+  const localEnv = path.resolve(".env");
+  if (fs.existsSync(localEnv)) {
+    return localEnv;
+  }
+  return path.join(customDataDir || getDataDir(), ".env");
+}
+
+/**
+ * Ensures all standard directories exist on disk with proper recursive creation.
+ */
+export function ensureDataDirs(targetDataDir?: string): void {
+  const root = targetDataDir || getDataDir();
+  const dbDir = getDbDir(root);
+  const profilesDir = getProfilesDir(root);
+
+  try {
+    if (!fs.existsSync(root)) fs.mkdirSync(root, { recursive: true });
+    if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+    if (!fs.existsSync(profilesDir)) fs.mkdirSync(profilesDir, { recursive: true });
+  } catch (err: any) {
+    console.error(`[Paths] Error ensuring data directories at ${root}:`, err?.message || String(err));
+  }
+}

package/src/core/prompt-limits.ts

@@ -0,0 +1,214 @@
+import { config } from "./config.ts";
+import { ContextLengthExceededError } from "./errors.ts";
+import {
+  getModelCapabilities,
+  getModelContextWindow,
+} from "./model-registry.ts";
+import { estimateTokenCount } from "../utils/context-truncation.ts";
+
+const INPUT_TOKEN_SAFETY_MARGIN = 4_096;
+
+/**
+ * Maximum number of recent messages to keep when truncating.
+ * Older messages are dropped with a truncation notice.
+ */
+const TRUNCATION_KEEP_RECENT_MESSAGES = 20;
+
+/**
+ * Notice added when history is truncated.
+ */
+const TRUNCATION_NOTICE =
+  "\n\n[Context truncated: older messages were removed to fit within model limits. Recent messages preserved.]\n\n";
+
+export interface PromptLimitStats {
+  bytes: number;
+  estimatedTokens: number;
+  modelContextWindow: number;
+  usableInputTokens: number;
+}
+
+export interface PromptLimitOptions {
+  /** Skip the model-token check until live model metadata has been synced. */
+  checkModelContext?: boolean;
+  /** Use metadata synchronized from this account, never another account. */
+  accountId?: string;
+}
+
+export function getUtf8ByteLength(value: string): number {
+  return Buffer.byteLength(value, "utf8");
+}
+
+export function getPromptLimitStats(
+  prompt: string,
+  modelId: string,
+  accountId?: string,
+): PromptLimitStats {
+  const modelContextWindow = getModelContextWindow(modelId, accountId);
+  const capabilities = getModelCapabilities(modelId, accountId);
+  const reservedOutputTokens = Math.max(
+    INPUT_TOKEN_SAFETY_MARGIN,
+    capabilities.maxOutputTokens,
+    capabilities.maxThinkingTokens,
+  );
+
+  return {
+    bytes: getUtf8ByteLength(prompt),
+    estimatedTokens: estimateTokenCount(prompt),
+    modelContextWindow,
+    usableInputTokens: Math.max(1, modelContextWindow - reservedOutputTokens),
+  };
+}
+
+/**
+ * Reject input that Qwen's web endpoint is unlikely to accept before allocating
+ * an upstream chat or retrying it on other accounts.
+ */
+export function assertPromptWithinLimits(
+  prompt: string,
+  modelId: string,
+  options: PromptLimitOptions = {},
+): PromptLimitStats {
+  const maxPromptBytes = config.qwen.maxPromptBytes;
+  const checkModelContext = options.checkModelContext !== false;
+
+  // Nothing to enforce: skip the byte scan and the O(n) token estimation
+  // entirely (the default QWEN_MAX_PROMPT_BYTES=0 makes the byte check a
+  // no-op, and callers pass checkModelContext:false before the live model
+  // context window is known).
+  if (maxPromptBytes <= 0 && !checkModelContext) {
+    return {
+      bytes: 0,
+      estimatedTokens: 0,
+      modelContextWindow: getModelContextWindow(modelId, options.accountId),
+      usableInputTokens: 1,
+    };
+  }
+
+  const stats = getPromptLimitStats(prompt, modelId, options.accountId);
+
+  if (maxPromptBytes > 0 && stats.bytes > maxPromptBytes) {
+    throw new ContextLengthExceededError(
+      `Input is too large for QwenProxy (${stats.bytes} UTF-8 bytes; limit ${maxPromptBytes}). Reduce or summarize the conversation before retrying.`,
+    );
+  }
+
+  if (
+    options.checkModelContext !== false &&
+    stats.estimatedTokens > stats.usableInputTokens
+  ) {
+    throw new ContextLengthExceededError(
+      `Input exceeds the usable context for ${modelId} (${stats.estimatedTokens} estimated tokens; limit ${stats.usableInputTokens}). Reduce or summarize the conversation before retrying.`,
+    );
+  }
+
+  return stats;
+}
+
+/**
+ * Personalization is account-global Qwen state. Keep its settings payload below
+ * a separate cap so a large tool schema cannot trigger a WAF challenge there.
+ */
+export function isRequestPersonalizationWithinLimit(
+  instruction: string,
+): boolean {
+  const maxPersonalizationBytes = config.qwen.maxPersonalizationBytes;
+  return (
+    maxPersonalizationBytes <= 0 ||
+    getUtf8ByteLength(instruction) <= maxPersonalizationBytes
+  );
+}
+
+export interface TruncationResult {
+  prompt: string;
+  wasTruncated: boolean;
+  originalTokens: number;
+  truncatedTokens: number;
+  messagesKept: number;
+  messagesDropped: number;
+}
+
+/**
+ * Intelligently truncate a prompt to fit within model context limits.
+ * 
+ * Strategy:
+ * 1. Keep system prompt + tools (instructions) intact
+ * 2. Keep recent messages (up to TRUNCATION_KEEP_RECENT_MESSAGES)
+ * 3. Drop older messages with a truncation notice
+ * 4. If still too large, progressively drop more messages
+ */
+export function truncatePromptToIntelligentLimit(
+  prompt: string,
+  modelId: string,
+  accountId?: string,
+  messages?: Array<{ role: string; content: string | null }>,
+): TruncationResult {
+  const stats = getPromptLimitStats(prompt, modelId, accountId);
+  const originalTokens = stats.estimatedTokens;
+
+  // Within limits, no truncation needed
+  if (stats.estimatedTokens <= stats.usableInputTokens) {
+    return {
+      prompt,
+      wasTruncated: false,
+      originalTokens,
+      truncatedTokens: originalTokens,
+      messagesKept: messages?.length ?? 0,
+      messagesDropped: 0,
+    };
+  }
+
+  // If no messages provided, do simple character-based truncation
+  if (!messages || messages.length === 0) {
+    const maxChars = Math.floor(stats.usableInputTokens * 4); // ~4 chars per token
+    const truncated = prompt.slice(0, maxChars);
+    return {
+      prompt: truncated + TRUNCATION_NOTICE,
+      wasTruncated: true,
+      originalTokens,
+      truncatedTokens: estimateTokenCount(truncated),
+      messagesKept: 0,
+      messagesDropped: 0,
+    };
+  }
+
+  // Intelligent truncation: keep recent messages, drop older ones
+  const totalMessages = messages.length;
+  let keepCount = Math.min(TRUNCATION_KEEP_RECENT_MESSAGES, totalMessages);
+  let droppedCount = totalMessages - keepCount;
+
+  // Build truncated prompt from recent messages
+  const buildTruncatedPrompt = (keep: number): string => {
+    const recentMessages = messages.slice(-keep);
+    const messageText = recentMessages
+      .map((m) => `${m.role}: ${m.content ?? ""}`)
+      .join("\n\n");
+    return messageText + TRUNCATION_NOTICE;
+  };
+
+  let truncatedPrompt = buildTruncatedPrompt(keepCount);
+  let truncatedTokens = estimateTokenCount(truncatedPrompt);
+
+  // Progressively drop more messages if still too large
+  while (truncatedTokens > stats.usableInputTokens && keepCount > 1) {
+    keepCount = Math.max(1, Math.floor(keepCount / 2));
+    droppedCount = totalMessages - keepCount;
+    truncatedPrompt = buildTruncatedPrompt(keepCount);
+    truncatedTokens = estimateTokenCount(truncatedPrompt);
+  }
+
+  // Final fallback: hard character limit
+  if (truncatedTokens > stats.usableInputTokens) {
+    const maxChars = Math.floor(stats.usableInputTokens * 4);
+    truncatedPrompt = truncatedPrompt.slice(0, maxChars) + TRUNCATION_NOTICE;
+    truncatedTokens = estimateTokenCount(truncatedPrompt);
+  }
+
+  return {
+    prompt: truncatedPrompt,
+    wasTruncated: true,
+    originalTokens,
+    truncatedTokens,
+    messagesKept: keepCount,
+    messagesDropped: droppedCount,
+  };
+}

package/src/core/reasoning-effort.ts

@@ -0,0 +1,102 @@
+/**
+ * Normalize OpenAI / Codex / provider reasoning.effort values.
+ *
+ * Provider-compatible names (common across OpenAI, Codex, Cursor, agents):
+ * - Max / high / xhigh  → thinking ON  (Qwen thinking_mode: "Thinking")
+ * - Fast / none / low   → thinking OFF (Qwen thinking_mode: "Fast")
+ * - medium              → thinking ON  (default mid-tier agents)
+ *
+ * Qwen upstream only has a boolean + Thinking|Fast — no true medium gradient.
+ */
+
+import { stripFastSuffix } from "./model-registry.ts";
+
+export type NormalizedEffort = "low" | "medium" | "high";
+
+/** Human-facing / provider aliases → normalized. */
+const EFFORT_ALIASES: Record<string, NormalizedEffort> = {
+  // Fast path (thinking off)
+  none: "low",
+  off: "low",
+  disable: "low",
+  disabled: "low",
+  minimal: "low",
+  min: "low",
+  low: "low",
+  fast: "low",
+  quick: "low",
+  "thinking-off": "low",
+  thinking_off: "low",
+  "no-thinking": "low",
+  no_thinking: "low",
+
+  // Mid
+  medium: "medium",
+  med: "medium",
+  default: "medium",
+
+  // Max path (thinking on)
+  high: "high",
+  xhigh: "high",
+  "x-high": "high",
+  max: "high",
+  maximum: "high",
+  ultra: "high",
+  deep: "high",
+  thinking: "high",
+  "thinking-on": "high",
+  thinking_on: "high",
+};
+
+/**
+ * Map any client-provided effort string to low|medium|high.
+ * Unknown values fall back to "high" (prefer thinking for agentic clients like Codex).
+ */
+export function normalizeReasoningEffort(
+  value: unknown,
+): NormalizedEffort | undefined {
+  if (value === null || value === undefined || value === "") return undefined;
+
+  const key = String(value).trim().toLowerCase();
+  if (!key) return undefined;
+
+  if (EFFORT_ALIASES[key]) return EFFORT_ALIASES[key];
+
+  // numeric 0-100 style (rare)
+  const n = Number(key);
+  if (Number.isFinite(n)) {
+    if (n <= 33) return "low";
+    if (n <= 66) return "medium";
+    return "high";
+  }
+
+  console.warn(
+    `[Effort] Unknown reasoning effort '${value}' — defaulting to high`,
+  );
+  return "high";
+}
+
+/**
+ * Returns the clean, canonical model id, stripping any legacy suffix.
+ */
+export function applyEffortToModel(
+  model: string,
+  _effort: NormalizedEffort | undefined,
+): string {
+  return model.replace(/-(?:low|medium|high|fast|no-thinking|thinking)$/, "");
+}
+
+/**
+ * Chat-completions mapping: effort -> Qwen reasoning mode.
+ * - low    → "fast"     (thinking OFF / Fast mode)
+ * - medium → "auto"     (thinking AUTO / Qwen decides dynamically)
+ * - high   → "thinking" (thinking ON / forced reasoning mode)
+ */
+export function effortToReasoningMode(
+  effort: NormalizedEffort | undefined,
+): "fast" | "auto" | "thinking" | undefined {
+  if (effort === "low") return "fast";
+  if (effort === "medium") return "auto";
+  if (effort === "high") return "thinking";
+  return undefined;
+}

package/src/core/stream-registry.ts

@@ -0,0 +1,96 @@
+import { metrics } from "./metrics.js";
+
+const activeStreams = new Map<
+  string,
+  {
+    abortController: AbortController;
+    accountId: string;
+    uiSessionId: string;
+    targetResponseId: string;
+    headers: Record<string, string>;
+    /** True once at least one model chunk reached the client. */
+    emittedChunk: boolean;
+  }
+>();
+
+export function registerStream(
+  key: string,
+  entry: {
+    abortController: AbortController;
+    accountId: string;
+    uiSessionId: string;
+    targetResponseId: string;
+    headers: Record<string, string>;
+  },
+): void {
+  const existing = activeStreams.get(key);
+  if (existing && existing.abortController !== entry.abortController) {
+    existing.abortController.abort();
+  }
+
+  activeStreams.set(key, { emittedChunk: false, ...entry });
+  metrics.gauge("streams.active", activeStreams.size);
+}
+
+export function getStream(key: string): ReturnType<typeof activeStreams.get> {
+  return activeStreams.get(key);
+}
+
+export function getStreamKeysBySessionId(sessionId: string): string[] {
+  const keys: string[] = [];
+  for (const [key, entry] of activeStreams.entries()) {
+    if (entry.uiSessionId === sessionId) {
+      keys.push(key);
+    }
+  }
+  return keys;
+}
+
+export function getStreamKeyBySessionAndResponse(
+  sessionId: string,
+  responseId: string,
+): string | undefined {
+  for (const [key, entry] of activeStreams.entries()) {
+    if (
+      entry.uiSessionId === sessionId &&
+      entry.targetResponseId === responseId
+    ) {
+      return key;
+    }
+  }
+  return undefined;
+}
+
+export function removeStream(key: string): void {
+  activeStreams.delete(key);
+  metrics.gauge("streams.active", activeStreams.size);
+}
+
+/**
+ * Mark a stream as having emitted at least one model chunk to the client.
+ * The emit-aware supersede uses this to avoid killing a generation the client
+ * has not consumed yet (e.g. a parallel title request racing the main stream).
+ */
+export function markStreamEmitted(key: string): void {
+  const entry = activeStreams.get(key);
+  if (entry) {
+    entry.emittedChunk = true;
+  }
+}
+
+export function updateStreamTargetResponseId(
+  key: string,
+  targetResponseId: string,
+): void {
+  const entry = activeStreams.get(key);
+  if (entry) {
+    entry.targetResponseId = targetResponseId;
+  }
+}
+
+export function updateStreamSessionId(key: string, uiSessionId: string): void {
+  const entry = activeStreams.get(key);
+  if (entry) {
+    entry.uiSessionId = uiSessionId;
+  }
+}