qwenproxy-cli 1.3.5 → 1.4.0

package/dist/sync-clients.js

@@ -0,0 +1,2824 @@
+// src/sync-clients.ts
+import fs14 from "node:fs";
+import dotenv from "dotenv";
+
+// src/core/paths.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+function isRunningUnderNodeTest() {
+  return process.argv.some(
+    (arg) => arg === "--test" || arg.includes("src/tests/") || arg.includes("src\\tests\\")
+  );
+}
+function getOsGlobalDataDir(options) {
+  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");
+  }
+  const xdgDataHome = options?.xdgDataHome || process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
+  return path.join(xdgDataHome, "qwenproxy");
+}
+function resolveDataDir(options) {
+  const envDir = options?.envDataDir ?? process.env.QWEN_DATA_DIR;
+  if (envDir && envDir.trim().length > 0) {
+    return path.resolve(envDir.trim());
+  }
+  const isTest = options?.isNodeTest ?? isRunningUnderNodeTest();
+  if (isTest) {
+    return path.resolve("data-test");
+  }
+  const localDir = path.resolve("data");
+  const localExists = options?.localDataExists ?? (fs.existsSync(path.join(localDir, "db", "qwenproxy.db")) || fs.existsSync(localDir));
+  if (localExists) {
+    return localDir;
+  }
+  return getOsGlobalDataDir({
+    platform: options?.platform,
+    appData: options?.appData,
+    homeDir: options?.homeDir,
+    xdgDataHome: options?.xdgDataHome
+  });
+}
+function getDataDir() {
+  return resolveDataDir();
+}
+function getDbDir(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "db");
+}
+function getProfilesDir(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "qwen_profiles");
+}
+function getSyncStatePath(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "sync-state.json");
+}
+function getEnvFilePath(customDataDir) {
+  if (isRunningUnderNodeTest()) {
+    return path.join(customDataDir || getDataDir(), ".env");
+  }
+  const localEnv = path.resolve(".env");
+  if (fs.existsSync(localEnv)) {
+    return localEnv;
+  }
+  return path.join(customDataDir || getDataDir(), ".env");
+}
+function getLogsDir(customDataDir) {
+  return path.join(customDataDir || getDataDir(), "logs");
+}
+function ensureDataDirs(targetDataDir) {
+  const root = targetDataDir || getDataDir();
+  const dbDir = getDbDir(root);
+  const profilesDir = getProfilesDir(root);
+  const logsDir = getLogsDir(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 });
+    if (!fs.existsSync(logsDir)) fs.mkdirSync(logsDir, { recursive: true });
+  } catch (err) {
+    console.error(`[Paths] Error ensuring data directories at ${root}:`, err?.message || String(err));
+  }
+}
+
+// src/sync/index.ts
+import "dotenv/config";
+import fs13 from "node:fs";
+import path13 from "node:path";
+import os3 from "node:os";
+import Database2 from "better-sqlite3";
+
+// src/core/config.ts
+import { z } from "zod";
+var envSchema = z.object({
+  PORT: z.string().regex(/^\d+$/, "PORT must be a number").refine((value) => {
+    const port = Number(value);
+    return port >= 1 && port <= 65535;
+  }, "PORT must be between 1 and 65535").default("7936"),
+  HOST: z.string().default("127.0.0.1"),
+  INTERNAL_HOST: z.string().default("127.0.0.1"),
+  USER_AGENT: z.string().default(
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36"
+  ),
+  QWEN_BX_V: z.string().default("2.5.37"),
+  // Version header on Qwen API requests = the deployed web bundle version
+  // (fallback when dynamic DOM detection is not yet completed).
+  // Override via env when Qwen ships a new bundle.
+  QWEN_WEB_VERSION: z.string().default("0.2.91"),
+  // Controls bx-ua/bx-umidtoken injection on the GENERAL API paths
+  // (chats/new, settings): those work without them (live-probed). The
+  // completions path is the exception — the 0.2.86 HAR shows the real
+  // client POSTs completions WITH bx-ua, so it always includes the captured
+  // tokens regardless of this flag (buildCompletionHeaders). Set true
+  // to inject them everywhere (legacy behavior).
+  QWEN_SEND_BX_UA: z.string().default("false"),
+  // Conversation mode: "thread" (default) reuses the upstream Qwen chat via
+  // parent_id and sends the thread-native delta; "temp" creates a NEW Qwen
+  // temp chat (chat_mode:"local") for every request and sends the full
+  // history inline (OpenAI standard). Temp chats are ephemeral and never
+  // appear in the account's chat list (live-probed).
+  QWEN_CHAT_MODE: z.enum([
+    "thread",
+    "temp",
+    "temp-thread",
+    "thread-temp",
+    "stateless",
+    "stateles",
+    "stateless-temp",
+    "stateles-temp"
+  ]).default("thread"),
+  PLAYWRIGHT_HEADLESS: z.string().default("true"),
+  PLAYWRIGHT_BROWSER: z.enum(["chromium", "chrome", "edge"]).default("chromium"),
+  PLAYWRIGHT_INIT_BATCH_SIZE: z.string().default("1"),
+  PLAYWRIGHT_CONTEXT_CLOSE_TIMEOUT_MS: z.string().default("10000"),
+  PLAYWRIGHT_IDLE_CONTEXT_TTL_MS: z.string().default("60000"),
+  PLAYWRIGHT_JS_HEAP_MB: z.string().default("256"),
+  PLAYWRIGHT_LOW_MEMORY_FLAGS: z.string().default("true"),
+  // Keep 2 warm contexts by default ({main + reserve} covers the common
+  // failover hop without opening one browser per account): after warmup two
+  // browsers stay open; any extra context (simultaneous use / failover) is
+  // closed once idle. The cap only evicts IDLE contexts — busy mutexes and
+  // active streams are never touched, so concurrent accounts each keep their
+  // own context while serving. Accounts in cooldown (rate-limited) sit idle,
+  // drop out of the warm set and get evicted.
+  PLAYWRIGHT_MAX_ACTIVE_CONTEXTS: z.string().default("2"),
+  PLAYWRIGHT_PREPARE_ALL_ON_STARTUP: z.string().default("false"),
+  CAPTCHA_SOLVER_ENABLED: z.string().default("true"),
+  CAPTCHA_SOLVER_MAX_ATTEMPTS: z.string().default("3"),
+  CAPTCHA_SOLVER_TIMEOUT_MS: z.string().default("15000"),
+  CAPTCHA_SOLVER_RETRY_DELAY_MS: z.string().default("1000"),
+  CAPTCHA_SOLVER_SETTLE_MS: z.string().default("2000"),
+  CAPTCHA_ACCOUNT_COOLDOWN_MS: z.string().default("120000"),
+  // Cap for the escalating quarantine applied when a challenge could NOT be
+  // solved (hard block). Each consecutive hard block doubles the window
+  // (base = CAPTCHA_ACCOUNT_COOLDOWN_MS) up to this cap.
+  CAPTCHA_HARD_BLOCK_MAX_COOLDOWN_MS: z.string().default("3600000"),
+  OSS_MULTIPART_THRESHOLD_MB: z.string().default("5"),
+  CHAT_REQUEST_LOG: z.string().default("false"),
+  HTTP_TIMEOUT: z.string().default("15000"),
+  CHAT_TIMEOUT: z.string().default("180000"),
+  NAVIGATION_TIMEOUT: z.string().default("60000"),
+  PAGE_TIMEOUT: z.string().default("60000"),
+  HEADERS_TIMEOUT: z.string().default("120000"),
+  TIME_TO_FIRST_BYTE: z.string().default("60000"),
+  IDLE_STREAM_TIMEOUT: z.string().default("60000"),
+  // Deadline for the FIRST upstream chunk on thinking models (the reasoning
+  // idle of 600s is for gaps AFTER data flows; a stream that produced
+  // nothing in this window is dead and should fail fast, retryable).
+  QWEN_FIRST_CHUNK_TIMEOUT: z.string().default("60000"),
+  TOTAL_REQUEST_TIMEOUT: z.string().default("600000"),
+  // Mid-stream silence window for thinking models: 3 min with ZERO upstream
+  // bytes is a dead stream (WAF swallow / dropped connection) — fail fast and
+  // let the retry policy rotate accounts. Flowing reasoning chunks RESET this
+  // timer, so legitimate slow thinking is never cut; only total silence is.
+  REASONING_MODEL_TIMEOUT: z.string().default("180000"),
+  CACHE_TTL: z.string().default("3600"),
+  RESPONSE_TTL: z.string().default("1800"),
+  CACHE_COMPRESSION_ENABLED: z.string().default("true"),
+  CACHE_COMPRESSION_THRESHOLD: z.string().default("1024"),
+  CACHE_COMPRESSION_LEVEL: z.string().default("6"),
+  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"),
+  RETRY_BASE_DELAY_MS: z.string().default(process.env.TEST_MOCK_QWEN_AUTH === "true" ? "50" : "1000"),
+  RETRY_MAX_DELAY_MS: z.string().default(process.env.TEST_MOCK_QWEN_AUTH === "true" ? "200" : "10000"),
+  RETRY_MAX_ATTEMPTS: z.string().default("3"),
+  RETRY_MAX_ACCOUNT_SWITCHES: z.string().default("2"),
+  RETRY_ON_UNKNOWN_UPSTREAM: z.string().default("true"),
+  RETRY_AUTO_MALFORMED_TOOLS: z.string().default("true"),
+  RETRY_AUTO_MALFORMED_TOOLS_MAX: z.string().default("2"),
+  MAX_TOOL_CALLS_PER_TURN: z.string().default("6"),
+  QWEN_REPEATED_TOOL_CALL_WARN: z.string().default("2"),
+  ACCOUNT_MAX_CONCURRENT_STREAMS: z.string().default("2"),
+  ACCOUNT_BUSY_WAIT_MS: z.string().default("30000"),
+  // Cap for the "wait forever" account-lease queue (thread owner / last
+  // usable account): the queue previously had NO deadline, so a stuck lease
+  // holder made the next turn wait up to ~600s. A generous finite cap keeps
+  // the wait far above the normal 30s but still bounded.
+  ACCOUNT_QUEUE_WAIT_FOREVER_CAP_MS: z.string().default("120000"),
+  // Hard deadline for one stream-acquire attempt. A dead account (upstream
+  // swallows the completion fetch) otherwise chains metadata/header timeouts
+  // for minutes; this fails the attempt visibly so the retry loop switches.
+  ACQUIRE_DEADLINE_MS: z.string().default("120000"),
+  ACCOUNT_LEASE_MAX_DURATION_MS: z.string().default("600000"),
+  ACCOUNT_INIT_FAILURE_COOLDOWN_MS: z.string().default("300000"),
+  // Timeout before a request waiting on the CHAT lock gives up. The chat lock
+  // is held for the entire stream lifetime, so it must cover the longest
+  // legitimate generation (reasoning models with huge contexts can spend
+  // 2-3 min producing the first byte chain). A 60s hard cap turned a normal
+  // long turn into a 500 for every concurrent request on the same chat
+  // (2026-08-22 production log: lock held 130s -> acquire_deadline 120s).
+  CHAT_LOCK_TIMEOUT_MS: z.string().regex(/^\d+$/, "CHAT_LOCK_TIMEOUT_MS must be a number").default("180000"),
+  STREAM_DISCONNECT_GRACE_MS: z.string().regex(/^\d+$/, "STREAM_DISCONNECT_GRACE_MS must be a number").default("4000"),
+  CHAT_IN_PROGRESS_RETRY_DELAY_MS: z.string().default("2000"),
+  // Temporarily-busy window after a chat_in_progress: long enough to absorb
+  // the upstream chat settle (measured ~1-2s), short enough that the next
+  // turn of the sticky owner is not pushed to a cold account with a full
+  // context replay (8s caused a needless 13.3s hop in the 20:04 session).
+  CHAT_IN_PROGRESS_BUSY_MS: z.string().default("4000"),
+  // Same-chat retry budget for chat_in_progress. The upstream chat stays "in
+  // progress" for 2-16s after a completed turn (grows with turn size); each
+  // retry waits a jittered window (busyMs-based) and NO retry re-sends the
+  // full context — the escalation (new chat + full replay on a cold account)
+  // was the ~1MB re-upload that made tool loops feel like ~40 minutes. After
+  // this budget the request FAILS (thread binding kept) and the client's own
+  // retry lands on the settled chat with the delta intact.
+  CHAT_IN_PROGRESS_MAX_RETRIES: z.string().default("6"),
+  MID_STREAM_FAILOVER_THRESHOLD: z.string().default("2"),
+  MID_STREAM_FAILOVER_BUSY_MS: z.string().default("60000"),
+  QWEN_BASE_URL: z.string().default("https://chat.qwen.ai"),
+  QWEN_CHAT_POOL_SIZE: z.string().default("0"),
+  QWEN_CHAT_POOL_MODELS: z.string().default("qwen3.7-plus"),
+  QWEN_PERSONALIZATION_FROM_REQUEST: z.string().default("true"),
+  QWEN_PERSONALIZATION_VERIFY_GET: z.string().default("true"),
+  QWEN_BROWSER_ONLY_FETCH: z.string().default("true"),
+  QWEN_MAP_OPENAI_MODELS: z.string().default("true"),
+  QWEN_MAX_PROMPT_BYTES: z.string().default("0"),
+  QWEN_MAX_PERSONALIZATION_BYTES: z.string().default("500000"),
+  CONTEXT_METER_ENABLED: z.string().default("true"),
+  CONTEXT_METER_WINDOW_TOKENS: z.string().default("0"),
+  CONTEXT_METER_REPORT_USAGE: z.string().default("true"),
+  DELETE_ALL_CHATS_ON_SHUTDOWN: z.string().default("false"),
+  AUTO_CLEAN_CHATS_ON_STARTUP: z.string().default("true"),
+  AUTO_CLEAN_ORPHAN_CHATS: z.string().default("true"),
+  AUTO_CLEAN_CHAT_MAX_AGE_HOURS: z.string().default("168"),
+  // The Baxia WAF scores live page behavior (pointer/scroll events, open
+  // session) — an account whose page sits frozen for minutes returns a low
+  // trust score and gets TMD-challenged on the next request. On by default;
+  // the keeper skips accounts that are mid-stream or mutex-busy.
+  SESSION_KEEP_ALIVE_ENABLED: z.string().default("true"),
+  SESSION_KEEP_ALIVE_INTERVAL_MS: z.string().default("180000"),
+  SESSION_KEEP_ALIVE_IDLE_MS: z.string().default("120000"),
+  SESSION_KEEP_ALIVE_NAVIGATION_INTERVAL_MS: z.string().default("480000"),
+  API_KEY: z.string().default(""),
+  // Static x-ratelimit-* response headers (OpenAI-shaped, doc §5.2). The proxy
+  // does not enforce a token/request quota; these exist for SDK/tool parsing.
+  RATE_LIMIT_REQUESTS: z.string().default("5000"),
+  RATE_LIMIT_TOKENS: z.string().default("200000")
+});
+var env = envSchema.parse(process.env);
+var config = {
+  server: {
+    port: parseInt(env.PORT),
+    host: env.HOST,
+    internalHost: env.INTERNAL_HOST,
+    rateLimit: {
+      requests: parseInt(env.RATE_LIMIT_REQUESTS),
+      tokens: parseInt(env.RATE_LIMIT_TOKENS)
+    }
+  },
+  logging: {
+    chatRequests: env.CHAT_REQUEST_LOG === "true"
+  },
+  auth: {
+    userAgent: env.USER_AGENT,
+    bxV: env.QWEN_BX_V
+  },
+  playwright: {
+    headless: env.PLAYWRIGHT_HEADLESS !== "false",
+    browser: env.PLAYWRIGHT_BROWSER,
+    initBatchSize: Math.max(1, parseInt(env.PLAYWRIGHT_INIT_BATCH_SIZE)),
+    contextCloseTimeoutMs: Math.max(
+      1e3,
+      parseInt(env.PLAYWRIGHT_CONTEXT_CLOSE_TIMEOUT_MS)
+    ),
+    idleContextTtlMs: Math.max(0, parseInt(env.PLAYWRIGHT_IDLE_CONTEXT_TTL_MS)),
+    jsHeapMb: Math.max(64, parseInt(env.PLAYWRIGHT_JS_HEAP_MB)),
+    lowMemoryFlags: env.PLAYWRIGHT_LOW_MEMORY_FLAGS !== "false",
+    maxActiveContexts: Math.max(0, parseInt(env.PLAYWRIGHT_MAX_ACTIVE_CONTEXTS)),
+    prepareAllOnStartup: env.PLAYWRIGHT_PREPARE_ALL_ON_STARTUP !== "false"
+  },
+  captcha: {
+    enabled: env.CAPTCHA_SOLVER_ENABLED === "true",
+    maxAttempts: Math.max(1, Math.min(5, parseInt(env.CAPTCHA_SOLVER_MAX_ATTEMPTS))),
+    timeoutMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_TIMEOUT_MS)),
+    retryDelayMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_RETRY_DELAY_MS)),
+    settleMs: Math.max(0, parseInt(env.CAPTCHA_SOLVER_SETTLE_MS)),
+    /** Rest an account whose challenge could not be cleared before reusing it. */
+    accountCooldownMs: Math.max(0, parseInt(env.CAPTCHA_ACCOUNT_COOLDOWN_MS)),
+    /** Cap for the escalating hard-block quarantine (×2 per consecutive block). */
+    hardBlockMaxCooldownMs: Math.max(
+      0,
+      parseInt(env.CAPTCHA_HARD_BLOCK_MAX_COOLDOWN_MS)
+    )
+  },
+  oss: {
+    multipartThresholdBytes: Math.max(
+      1 * 1024 * 1024,
+      parseInt(env.OSS_MULTIPART_THRESHOLD_MB) * 1024 * 1024
+    )
+  },
+  timeouts: {
+    http: parseInt(env.HTTP_TIMEOUT),
+    chat: parseInt(env.CHAT_TIMEOUT),
+    navigation: parseInt(env.NAVIGATION_TIMEOUT),
+    page: parseInt(env.PAGE_TIMEOUT),
+    headers: parseInt(env.HEADERS_TIMEOUT),
+    timeToFirstByte: parseInt(env.TIME_TO_FIRST_BYTE),
+    idleStreamTimeout: parseInt(env.IDLE_STREAM_TIMEOUT),
+    totalRequestTimeout: parseInt(env.TOTAL_REQUEST_TIMEOUT),
+    reasoningModelTimeout: parseInt(env.REASONING_MODEL_TIMEOUT),
+    firstChunkTimeout: parseInt(env.QWEN_FIRST_CHUNK_TIMEOUT)
+  },
+  cache: {
+    defaultTTL: parseInt(env.CACHE_TTL),
+    responseTTL: parseInt(env.RESPONSE_TTL),
+    compression: {
+      enabled: env.CACHE_COMPRESSION_ENABLED !== "false",
+      threshold: parseInt(env.CACHE_COMPRESSION_THRESHOLD),
+      level: parseInt(env.CACHE_COMPRESSION_LEVEL)
+    }
+  },
+  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)
+    }
+  },
+  retry: {
+    baseDelayMs: parseInt(env.RETRY_BASE_DELAY_MS),
+    maxDelayMs: parseInt(env.RETRY_MAX_DELAY_MS),
+    maxAttempts: Math.max(1, parseInt(env.RETRY_MAX_ATTEMPTS)),
+    maxAccountSwitches: Math.max(0, parseInt(env.RETRY_MAX_ACCOUNT_SWITCHES)),
+    onUnknownUpstream: env.RETRY_ON_UNKNOWN_UPSTREAM !== "false",
+    chatInProgressDelayMs: Math.max(0, parseInt(env.CHAT_IN_PROGRESS_RETRY_DELAY_MS)),
+    chatInProgressBusyMs: Math.max(0, parseInt(env.CHAT_IN_PROGRESS_BUSY_MS)),
+    chatInProgressMaxAttempts: Math.max(1, parseInt(env.CHAT_IN_PROGRESS_MAX_RETRIES)),
+    midStreamFailoverThreshold: Math.max(
+      0,
+      parseInt(env.MID_STREAM_FAILOVER_THRESHOLD)
+    ),
+    midStreamFailoverBusyMs: Math.max(
+      0,
+      parseInt(env.MID_STREAM_FAILOVER_BUSY_MS)
+    ),
+    autoRetryMalformedTools: env.RETRY_AUTO_MALFORMED_TOOLS !== "false",
+    autoRetryMalformedToolsMax: Math.max(1, parseInt(env.RETRY_AUTO_MALFORMED_TOOLS_MAX)),
+    maxToolCallsPerTurn: Math.max(0, parseInt(env.MAX_TOOL_CALLS_PER_TURN)),
+    repeatedToolCallWarnThreshold: Math.max(
+      1,
+      parseInt(env.QWEN_REPEATED_TOOL_CALL_WARN)
+    )
+  },
+  concurrency: {
+    maxStreamsPerAccount: Math.max(1, parseInt(env.ACCOUNT_MAX_CONCURRENT_STREAMS)),
+    busyWaitMs: Math.max(
+      0,
+      Number.isFinite(parseInt(env.ACCOUNT_BUSY_WAIT_MS)) ? parseInt(env.ACCOUNT_BUSY_WAIT_MS) : 3e4
+    ),
+    /** Bound for the "wait forever" lease queue (default 2 min). */
+    queueWaitForeverCapMs: Math.max(
+      0,
+      Number.isFinite(parseInt(env.ACCOUNT_QUEUE_WAIT_FOREVER_CAP_MS)) ? parseInt(env.ACCOUNT_QUEUE_WAIT_FOREVER_CAP_MS) : 12e4
+    ),
+    /** Hard deadline for one stream-acquire attempt (default 2 min). */
+    acquireDeadlineMs: Math.max(
+      0,
+      Number.isFinite(parseInt(env.ACQUIRE_DEADLINE_MS)) ? parseInt(env.ACQUIRE_DEADLINE_MS) : 12e4
+    ),
+    /** Safety net: force-release leases held longer than this (default 10 min). */
+    leaseMaxDurationMs: Math.max(
+      0,
+      parseInt(env.ACCOUNT_LEASE_MAX_DURATION_MS)
+    ),
+    initFailureCooldownMs: Math.max(
+      3e4,
+      parseInt(env.ACCOUNT_INIT_FAILURE_COOLDOWN_MS)
+    ),
+    /** Max time a request waits on the per-chat lock (default 3 min). */
+    chatLockTimeoutMs: Math.max(
+      0,
+      parseInt(env.CHAT_LOCK_TIMEOUT_MS)
+    )
+  },
+  stream: {
+    disconnectGraceMs: Math.max(
+      0,
+      parseInt(env.STREAM_DISCONNECT_GRACE_MS)
+    )
+  },
+  sessionKeeper: {
+    enabled: env.SESSION_KEEP_ALIVE_ENABLED !== "false",
+    intervalMs: parseInt(env.SESSION_KEEP_ALIVE_INTERVAL_MS),
+    idleMs: parseInt(env.SESSION_KEEP_ALIVE_IDLE_MS),
+    navigationIntervalMs: parseInt(
+      env.SESSION_KEEP_ALIVE_NAVIGATION_INTERVAL_MS
+    )
+  },
+  apiKey: env.API_KEY,
+  qwen: {
+    baseUrl: env.QWEN_BASE_URL,
+    chatPoolSize: Math.max(0, parseInt(env.QWEN_CHAT_POOL_SIZE)),
+    chatPoolModels: env.QWEN_CHAT_POOL_MODELS.split(",").map((model) => model.trim()).filter(Boolean),
+    personalizationFromRequest: env.QWEN_PERSONALIZATION_FROM_REQUEST === "true",
+    personalizationVerifyGet: env.QWEN_PERSONALIZATION_VERIFY_GET !== "false",
+    /** "thread" (reuse upstream chat) or "temp" (new ephemeral chat per request). */
+    /** When true, all requests (personalization, models, media, chat) route exclusively through the browser page (no direct Node fetch). */
+    browserOnlyFetch: env.QWEN_BROWSER_ONLY_FETCH !== "false",
+    mapOpenAiModels: env.QWEN_MAP_OPENAI_MODELS !== "false",
+    chatMode: normalizeChatMode(env.QWEN_CHAT_MODE),
+    maxPromptBytes: Math.max(0, parseInt(env.QWEN_MAX_PROMPT_BYTES)),
+    maxPersonalizationBytes: Math.max(
+      0,
+      parseInt(env.QWEN_MAX_PERSONALIZATION_BYTES)
+    ),
+    deleteAllChatsOnShutdown: env.DELETE_ALL_CHATS_ON_SHUTDOWN === "true",
+    autoCleanChatsOnStartup: env.AUTO_CLEAN_CHATS_ON_STARTUP !== "false",
+    autoCleanOrphanChats: env.AUTO_CLEAN_ORPHAN_CHATS !== "false",
+    autoCleanChatMaxAgeHours: Math.max(
+      1,
+      parseInt(env.AUTO_CLEAN_CHAT_MAX_AGE_HOURS) || 168
+    ),
+    sendBxUa: env.QWEN_SEND_BX_UA === "true",
+    /** Deployed web bundle version sent as the `version` API header. */
+    webVersion: env.QWEN_WEB_VERSION
+  },
+  contextMeter: {
+    enabled: env.CONTEXT_METER_ENABLED === "true",
+    windowTokens: Math.max(0, parseInt(env.CONTEXT_METER_WINDOW_TOKENS)),
+    reportUsage: env.CONTEXT_METER_REPORT_USAGE === "true"
+  }
+};
+function normalizeChatMode(mode) {
+  if (!mode) return "thread";
+  const m = mode.trim().toLowerCase().replace(/_/g, "-");
+  if (m === "stateless-temp" || m === "stateles-temp" || m === "temp") {
+    return "stateless-temp";
+  }
+  if (m === "stateless" || m === "stateles") {
+    return "stateless";
+  }
+  if (m === "thread-temp" || m === "temp-thread") {
+    return "thread-temp";
+  }
+  return "thread";
+}
+
+// src/core/local-auth.ts
+var PLACEHOLDER_API_KEY = "sk-qwenproxy-local";
+function isPlaceholderApiKey(key) {
+  const value = (key || "").trim();
+  return value.length === 0 || value === PLACEHOLDER_API_KEY;
+}
+function isLoopbackHost(host) {
+  const normalized = host.trim().toLowerCase().replace(/^\[|\]$/g, "");
+  return normalized === "127.0.0.1" || normalized === "localhost" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1";
+}
+
+// src/sync/claude-code.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/sync/utils.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+function createTimestampBackup(filePath) {
+  const dir = path2.dirname(filePath);
+  const ext = path2.extname(filePath);
+  const base = path2.basename(filePath, ext);
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const timestamp = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}_${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+  const backupPath = path2.join(dir, `${base}.qwenproxy.${timestamp}${ext}.bak`);
+  fs2.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function findLatestBackup(filePath) {
+  const dir = path2.dirname(filePath);
+  const ext = path2.extname(filePath);
+  const base = path2.basename(filePath, ext);
+  if (!fs2.existsSync(dir)) return void 0;
+  try {
+    const files = fs2.readdirSync(dir);
+    const candidates = files.filter((f) => f.startsWith(base) && f.includes("qwenproxy") && f.endsWith(".bak")).map((f) => path2.join(dir, f)).sort((a, b) => {
+      try {
+        return fs2.statSync(b).mtimeMs - fs2.statSync(a).mtimeMs;
+      } catch {
+        return 0;
+      }
+    });
+    return candidates[0];
+  } catch {
+    return void 0;
+  }
+}
+function restoreFromBackup(filePath, backupPath) {
+  const targetBackup = backupPath && fs2.existsSync(backupPath) ? backupPath : findLatestBackup(filePath);
+  if (!targetBackup || !fs2.existsSync(targetBackup)) {
+    return false;
+  }
+  fs2.copyFileSync(targetBackup, filePath);
+  try {
+    fs2.unlinkSync(targetBackup);
+  } catch {
+  }
+  return true;
+}
+function formatModelDisplayName(model) {
+  if (model === "qwen3.8-max") return "Qwen 3.8 Max";
+  if (model === "qwen3.8-omni-flash") return "Qwen 3.8 Omni Flash";
+  if (model === "qwen3.7-plus") return "Qwen 3.7 Plus";
+  if (model === "qwen3.6-plus") return "Qwen 3.6 Plus";
+  return model.replace(/^qwen/i, "Qwen ").split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ").replace(/\s+/g, " ").trim();
+}
+
+// src/sync/claude-code.ts
+function syncClaudeCode(options) {
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max" } = options;
+  try {
+    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+    let backupPath;
+    let existingSettings = {};
+    if (fs3.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      try {
+        const content = fs3.readFileSync(filePath, "utf-8");
+        existingSettings = JSON.parse(content);
+      } catch {
+        existingSettings = {};
+      }
+    }
+    const env2 = {
+      ...existingSettings.env || {},
+      ANTHROPIC_BASE_URL: baseUrl,
+      ANTHROPIC_AUTH_TOKEN: apiKey,
+      ANTHROPIC_MODEL: model,
+      ANTHROPIC_CUSTOM_MODEL_OPTION: model,
+      ANTHROPIC_CUSTOM_MODEL_OPTION_NAME: formatModelDisplayName(model),
+      ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION: `QwenProxy ${model}`,
+      ANTHROPIC_DEFAULT_SONNET_MODEL: model,
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3.7-plus",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: model,
+      CLAUDE_CODE_MAX_CONTEXT_TOKENS: "1000000",
+      CLAUDE_CODE_DISABLE_ARTIFACT: "1"
+    };
+    const updatedSettings = {
+      ...existingSettings,
+      env: env2,
+      model,
+      enableArtifact: false
+    };
+    fs3.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+    return {
+      client: "claude-code",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Claude Code with model ${model} and baseUrl ${baseUrl}`
+    };
+  } catch (err) {
+    return {
+      client: "claude-code",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreClaudeCode(filePath, backupPath) {
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+  let manuallyCleaned = false;
+  if (fs3.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+      if (data.env && (data.env.ANTHROPIC_BASE_URL?.includes("7936") || data.env.ANTHROPIC_AUTH_TOKEN === "sk-qwenproxy-local" || data.env.ANTHROPIC_MODEL?.includes("qwen"))) {
+        delete data.env.ANTHROPIC_BASE_URL;
+        delete data.env.ANTHROPIC_AUTH_TOKEN;
+        delete data.env.ANTHROPIC_MODEL;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION_NAME;
+        delete data.env.ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION;
+        delete data.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+        delete data.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+        delete data.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+        delete data.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS;
+        delete data.env.CLAUDE_CODE_DISABLE_ARTIFACT;
+        delete data.enableArtifact;
+        if (data.model && data.model.toLowerCase().includes("qwen")) {
+          delete data.model;
+        }
+        if (Object.keys(data.env).length === 0) {
+          delete data.env;
+        }
+        fs3.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {
+    }
+  }
+  const success = restoredFromBackup || manuallyCleaned;
+  return {
+    client: "claude-code",
+    filePath,
+    backupPath,
+    success,
+    action: success ? "restored" : "failed",
+    message: success ? restoredFromBackup ? "Restored Claude Code settings from backup" : "Removed QwenProxy configuration from Claude Code settings" : "Backup file not found"
+  };
+}
+
+// src/sync/codex.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+import os2 from "node:os";
+function removeTomlSection(content, sectionHeader) {
+  const lines = content.split(/\r?\n/);
+  const result = [];
+  let inTargetSection = false;
+  const targetNorm = sectionHeader.replace(/\s+/g, "");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const headerInside = trimmed.slice(1, -1).trim().replace(/\s+/g, "");
+      if (headerInside === targetNorm) {
+        inTargetSection = true;
+        continue;
+      } else {
+        inTargetSection = false;
+      }
+    }
+    if (!inTargetSection) {
+      result.push(line);
+    }
+  }
+  return result.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function updateTopLevelKey(content, key, value) {
+  const firstSectionIdx = content.search(/^\[/m);
+  const topPart = firstSectionIdx === -1 ? content : content.slice(0, firstSectionIdx);
+  const restPart = firstSectionIdx === -1 ? "" : content.slice(firstSectionIdx);
+  const formattedValue = typeof value === "string" ? `"${value}"` : String(value);
+  const keyRegex = new RegExp(`^${key}\\s*=.*$`, "m");
+  let newTopPart;
+  if (keyRegex.test(topPart)) {
+    newTopPart = topPart.replace(keyRegex, `${key} = ${formattedValue}`);
+  } else {
+    newTopPart = `${key} = ${formattedValue}
+` + topPart.trimStart();
+  }
+  return newTopPart + restPart;
+}
+function syncCodexSingleFile(targetPath, options) {
+  fs4.mkdirSync(path4.dirname(targetPath), { recursive: true });
+  let backupPath;
+  let content = "";
+  if (fs4.existsSync(targetPath)) {
+    backupPath = createTimestampBackup(targetPath);
+    content = fs4.readFileSync(targetPath, "utf-8");
+  }
+  const { apiKey, baseUrl, model = "qwen3.8-max", setActive = true } = options;
+  const providerBlock = `[model_providers.qwenproxy]
+name = "QwenProxy"
+base_url = "${baseUrl}"
+wire_api = "responses"
+experimental_bearer_token = "${apiKey}"
+`;
+  content = removeTomlSection(content, "model_providers.qwenproxy");
+  content = content.trimEnd() + (content.length > 0 ? "\n\n" : "") + providerBlock;
+  if (setActive) {
+    content = updateTopLevelKey(content, "model", model);
+    content = updateTopLevelKey(content, "model_provider", "qwenproxy");
+    content = updateTopLevelKey(content, "model_context_window", 1e6);
+  }
+  const catalogMatch = content.match(/^model_catalog_json\s*=\s*["']([^"']+)["']/m);
+  if (catalogMatch && catalogMatch[1]) {
+    try {
+      const rawCatalogPath = catalogMatch[1];
+      const catalogPath = path4.isAbsolute(rawCatalogPath) ? rawCatalogPath : path4.resolve(path4.dirname(targetPath), rawCatalogPath);
+      if (fs4.existsSync(catalogPath)) {
+        const catalog = JSON.parse(fs4.readFileSync(catalogPath, "utf-8"));
+        if (Array.isArray(catalog.models)) {
+          const hasModel = catalog.models.some((m) => m?.slug === model);
+          if (!hasModel) {
+            const template = catalog.models[0] || {};
+            catalog.models.unshift({
+              ...template,
+              slug: model,
+              display_name: formatModelDisplayName(model),
+              description: `QwenProxy ${model}`,
+              context_window: 1e6,
+              max_context_window: 1e6
+            });
+            fs4.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  fs4.writeFileSync(targetPath, content.trimEnd() + "\n", "utf-8");
+  return { backupPath };
+}
+function syncCodex(options) {
+  const { filePath, baseUrl } = options;
+  try {
+    const { backupPath } = syncCodexSingleFile(filePath, options);
+    const home = os2.homedir();
+    const standardPath = path4.join(home, ".codex", "config.toml");
+    const codexHomePath = process.env.CODEX_HOME ? path4.join(process.env.CODEX_HOME, "config.toml") : void 0;
+    const isStandard = path4.resolve(filePath).toLowerCase() === path4.resolve(standardPath).toLowerCase();
+    const isCodexHome = Boolean(codexHomePath) && path4.resolve(filePath).toLowerCase() === path4.resolve(codexHomePath).toLowerCase();
+    if ((isStandard || isCodexHome) && !isRunningUnderNodeTest()) {
+      const alternatePath = isStandard ? codexHomePath : standardPath;
+      if (alternatePath && path4.resolve(alternatePath).toLowerCase() !== path4.resolve(filePath).toLowerCase()) {
+        try {
+          if (fs4.existsSync(alternatePath) || fs4.existsSync(path4.dirname(alternatePath))) {
+            syncCodexSingleFile(alternatePath, options);
+          }
+        } catch {
+        }
+      }
+    }
+    return {
+      client: "codex",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Codex with provider qwenproxy (${baseUrl})`
+    };
+  } catch (err) {
+    return {
+      client: "codex",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreCodex(filePath, backupPath) {
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+  let manuallyCleaned = false;
+  const cleanSingleFile = (p) => {
+    if (fs4.existsSync(p)) {
+      try {
+        let content = fs4.readFileSync(p, "utf-8");
+        if (content.includes("[model_providers.qwenproxy]") || /^model_provider\s*=\s*["']qwenproxy["']/m.test(content)) {
+          content = removeTomlSection(content, "model_providers.qwenproxy");
+          content = content.replace(/^model_provider\s*=\s*["']qwenproxy["']\r?\n?/m, "");
+          if (/^model\s*=\s*["']qwen/m.test(content)) {
+            content = content.replace(/^model\s*=\s*["']qwen[^"']*["']\r?\n?/m, "");
+          }
+          fs4.writeFileSync(p, content.trimEnd() + "\n", "utf-8");
+          manuallyCleaned = true;
+        }
+      } catch {
+      }
+    }
+  };
+  cleanSingleFile(filePath);
+  const home = os2.homedir();
+  const standardPath = path4.join(home, ".codex", "config.toml");
+  const codexHomePath = process.env.CODEX_HOME ? path4.join(process.env.CODEX_HOME, "config.toml") : void 0;
+  const isStandard = path4.resolve(filePath).toLowerCase() === path4.resolve(standardPath).toLowerCase();
+  const isCodexHome = Boolean(codexHomePath) && path4.resolve(filePath).toLowerCase() === path4.resolve(codexHomePath).toLowerCase();
+  if ((isStandard || isCodexHome) && !isRunningUnderNodeTest()) {
+    const alternatePath = isStandard ? codexHomePath : standardPath;
+    if (alternatePath && path4.resolve(alternatePath).toLowerCase() !== path4.resolve(filePath).toLowerCase()) {
+      cleanSingleFile(alternatePath);
+    }
+  }
+  const success = restoredFromBackup || manuallyCleaned;
+  return {
+    client: "codex",
+    filePath,
+    backupPath,
+    success,
+    action: success ? "restored" : "failed",
+    message: success ? restoredFromBackup ? "Restored Codex config from backup" : "Removed QwenProxy configuration from Codex config" : "Backup file not found"
+  };
+}
+
+// src/sync/opencode.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+function buildOpenCodeProviderObject(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
+  const modelsObj = {};
+  const modelList = Array.from(
+    new Set([primaryModel, ...models && models.length > 0 ? models : [primaryModel, "qwen3.7-plus"]].filter(Boolean))
+  );
+  for (const m of modelList) {
+    modelsObj[m] = {
+      name: formatModelDisplayName(m),
+      limit: { context: 1048576, output: 65536 },
+      modalities: { input: ["text", "image"], output: ["text"] },
+      reasoning: true,
+      variants: {
+        low: { effort: "low" },
+        medium: { effort: "medium" },
+        high: { effort: "high" }
+      }
+    };
+  }
+  return {
+    npm: "@ai-sdk/openai-compatible",
+    name: "QwenProxy",
+    options: {
+      baseURL: baseUrl,
+      apiKey
+    },
+    models: modelsObj
+  };
+}
+function findKeyObjectSpan(content, key) {
+  const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
+  const match = content.match(regex);
+  if (!match || match.index === void 0) return null;
+  const startIndex = match.index;
+  const braceIndex = content.indexOf("{", startIndex + match[0].length - 1);
+  if (braceIndex === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+  for (let i = braceIndex; i < content.length; i++) {
+    const ch = content[i];
+    const nextCh = content[i + 1] || "";
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && nextCh === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && nextCh === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && nextCh === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        let endIndex = i + 1;
+        let hasTrailingComma = false;
+        while (endIndex < content.length && /[\s,]/.test(content[endIndex])) {
+          if (content[endIndex] === ",") {
+            hasTrailingComma = true;
+            endIndex++;
+            break;
+          }
+          if (content[endIndex] === "\n") {
+            break;
+          }
+          endIndex++;
+        }
+        return { start: startIndex, end: endIndex, hasTrailingComma };
+      }
+    }
+  }
+  return null;
+}
+function openCodeModelId(model) {
+  return `qwenproxy/${model}`;
+}
+function applyOpenCodeActiveModel(content, model, setActive) {
+  if (!setActive) return content;
+  const id = openCodeModelId(model);
+  if (/"model"\s*:/.test(content)) {
+    return content.replace(/"model"\s*:\s*("[^"]*"|'[^']*')/, `"model": "${id}"`);
+  }
+  return content.replace(/\{/, `{
+  "model": "${id}",`);
+}
+function syncOpenCode(options) {
+  const {
+    filePath,
+    apiKey,
+    baseUrl,
+    model = "qwen3.8-max",
+    models,
+    setActive = true
+  } = options;
+  try {
+    fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+    let backupPath;
+    let content = "";
+    if (fs5.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs5.readFileSync(filePath, "utf-8");
+    }
+    const providerObj = buildOpenCodeProviderObject(baseUrl, apiKey, model, models);
+    const providerJson = JSON.stringify(providerObj, null, 6).split("\n").map((line, idx) => idx === 0 ? line : `    ${line}`).join("\n");
+    const qwenEntry = `    "qwenproxy": ${providerJson}`;
+    if (!content.trim()) {
+      const initial = {
+        $schema: "https://opencode.ai/config.json"
+      };
+      if (setActive) {
+        initial.model = openCodeModelId(model);
+      }
+      initial.provider = {
+        qwenproxy: providerObj
+      };
+      fs5.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+    } else {
+      const existingSpan = findKeyObjectSpan(content, "qwenproxy");
+      if (existingSpan) {
+        const comma = existingSpan.hasTrailingComma ? "," : "";
+        content = content.slice(0, existingSpan.start) + `"qwenproxy": ${providerJson}${comma}` + content.slice(existingSpan.end);
+      } else {
+        const providerMatch = content.match(/"provider"\s*:\s*\{/);
+        if (providerMatch && providerMatch.index !== void 0) {
+          const insertIdx = providerMatch.index + providerMatch[0].length;
+          content = content.slice(0, insertIdx) + "\n" + qwenEntry + "," + content.slice(insertIdx);
+        } else {
+          const lastBraceIdx = content.lastIndexOf("}");
+          if (lastBraceIdx !== -1) {
+            const comma = content.slice(0, lastBraceIdx).trimEnd().endsWith("{") ? "" : ",";
+            content = content.slice(0, lastBraceIdx).trimEnd() + `${comma}
+  "provider": {
+${qwenEntry}
+  }
+}
+`;
+          }
+        }
+      }
+      fs5.writeFileSync(
+        filePath,
+        applyOpenCodeActiveModel(content, model, setActive),
+        "utf-8"
+      );
+    }
+    return {
+      client: "opencode",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured OpenCode with provider qwenproxy (${baseUrl})`
+    };
+  } catch (err) {
+    return {
+      client: "opencode",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreOpenCode(filePath, backupPath) {
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+  let manuallyCleaned = false;
+  if (fs5.existsSync(filePath)) {
+    try {
+      const data = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+      if (data.provider && data.provider.qwenproxy) {
+        delete data.provider.qwenproxy;
+        if (data.model && data.model.includes("qwen")) {
+          delete data.model;
+        }
+        if (Object.keys(data.provider).length === 0) {
+          delete data.provider;
+        }
+        fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {
+    }
+  }
+  const success = restoredFromBackup || manuallyCleaned;
+  return {
+    client: "opencode",
+    filePath,
+    backupPath,
+    success,
+    action: success ? "restored" : "failed",
+    message: success ? restoredFromBackup ? "Restored OpenCode config from backup" : "Removed QwenProxy configuration from OpenCode config" : "Backup file not found"
+  };
+}
+
+// src/sync/omp.ts
+import fs6 from "node:fs";
+import path6 from "node:path";
+function buildOmpProviderYaml(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
+  const modelList = Array.from(
+    new Set([primaryModel, ...models && models.length > 0 ? models : [primaryModel, "qwen3.7-plus"]].filter(Boolean))
+  );
+  const formattedModels = modelList.map(
+    (m) => `      - id: ${m}
+        name: ${formatModelDisplayName(m).replace(/\s+/g, "")}
+        input: [text, image]
+        contextWindow: 1000000
+        maxTokens: 131072
+        reasoning: true
+        thinking:
+          mode: effort
+          efforts: [low, medium, high]`
+  ).join("\n");
+  return `  qwenproxy:
+    baseUrl: ${baseUrl}
+    api: openai-completions
+    apiKey: "${apiKey}"
+    compat:
+      supportsStore: true
+      supportsReasoningEffort: true
+      maxTokensField: max_completion_tokens
+    models:
+${formattedModels}
+`;
+}
+function syncOmp(options) {
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models } = options;
+  try {
+    fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+    let backupPath;
+    let content = "";
+    if (fs6.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs6.readFileSync(filePath, "utf-8");
+    }
+    const providerBlock = buildOmpProviderYaml(baseUrl, apiKey, model, models);
+    if (!content.trim()) {
+      content = `providers:
+${providerBlock}`;
+    } else {
+      const existingQwenRegex = /^ {2}qwenproxy:[\s\S]*?(?=(?:^ {2}[a-zA-Z0-9_-]+:|\Z))/m;
+      if (existingQwenRegex.test(content)) {
+        content = content.replace(existingQwenRegex, providerBlock);
+      } else {
+        const providersMatch = content.match(/^providers:\s*$/m);
+        if (providersMatch && providersMatch.index !== void 0) {
+          const insertIdx = providersMatch.index + providersMatch[0].length;
+          content = content.slice(0, insertIdx) + "\n" + providerBlock + content.slice(insertIdx);
+        } else {
+          content = content.trimEnd() + "\n\nproviders:\n" + providerBlock;
+        }
+      }
+    }
+    fs6.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+    return {
+      client: "omp",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured OMP with provider qwenproxy (${baseUrl})`
+    };
+  } catch (err) {
+    return {
+      client: "omp",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreOmp(filePath, backupPath) {
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+  let manuallyCleaned = false;
+  if (fs6.existsSync(filePath)) {
+    try {
+      let content = fs6.readFileSync(filePath, "utf-8");
+      if (content.includes("qwenproxy:")) {
+        const regex = /^\s*qwenproxy:\s*\r?\n(?:^[ \t].*\r?\n?)*/m;
+        content = content.replace(regex, "");
+        fs6.writeFileSync(filePath, content, "utf-8");
+        manuallyCleaned = true;
+      }
+    } catch {
+    }
+  }
+  const success = restoredFromBackup || manuallyCleaned;
+  return {
+    client: "omp",
+    filePath,
+    backupPath,
+    success,
+    action: success ? "restored" : "failed",
+    message: success ? restoredFromBackup ? "Restored OMP models config from backup" : "Removed QwenProxy configuration from OMP config" : "Backup file not found"
+  };
+}
+
+// src/sync/hermes.ts
+import fs7 from "node:fs";
+import path7 from "node:path";
+function buildHermesModelBlock(baseUrl, apiKey, model = "qwen3.8-max", reasoningEffort = "high") {
+  return `model:
+  default: "${model}"
+  provider: "custom"
+  base_url: "${baseUrl}"
+  api_key: "${apiKey}"
+  reasoning_effort: "${reasoningEffort}"
+  reasoning_overrides:
+    "qwen3.8-max": "${reasoningEffort}"
+    "qwen3.7-plus": "medium"
+`;
+}
+function buildHermesProviderBlock(baseUrl, apiKey) {
+  return `  qwenproxy:
+    base_url: "${baseUrl}"
+    api_mode: chat_completions
+    api_key: "${apiKey}"
+`;
+}
+function syncHermes(options) {
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = options;
+  try {
+    fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+    let backupPath;
+    let content = "";
+    if (fs7.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs7.readFileSync(filePath, "utf-8");
+    }
+    const modelBlock = buildHermesModelBlock(baseUrl, apiKey, model, reasoningEffort);
+    const providerBlock = buildHermesProviderBlock(baseUrl, apiKey);
+    const modelRegex = /^model:[\s\S]*?(?=(?:^[a-zA-Z0-9_-]+:|\Z))/m;
+    if (modelRegex.test(content)) {
+      content = content.replace(modelRegex, modelBlock);
+    } else {
+      content = modelBlock + "\n" + content.trimStart();
+    }
+    if (!content.includes("providers:")) {
+      content = content.trimEnd() + "\n\nproviders:\n" + providerBlock;
+    } else {
+      const existingQwenRegex = /^ {2}qwenproxy:[\s\S]*?(?=(?:^ {2}[a-zA-Z0-9_-]+:|^[a-zA-Z0-9_-]+:|\Z))/m;
+      if (existingQwenRegex.test(content)) {
+        content = content.replace(existingQwenRegex, providerBlock);
+      } else {
+        const providersMatch = content.match(/^providers:\s*$/m);
+        if (providersMatch && providersMatch.index !== void 0) {
+          const insertIdx = providersMatch.index + providersMatch[0].length;
+          content = content.slice(0, insertIdx) + "\n" + providerBlock + content.slice(insertIdx);
+        } else {
+          content = content.trimEnd() + "\n\nproviders:\n" + providerBlock;
+        }
+      }
+    }
+    fs7.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+    return {
+      client: "hermes",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Hermes Agent with model ${model} and reasoning effort ${reasoningEffort}`
+    };
+  } catch (err) {
+    return {
+      client: "hermes",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreHermes(filePath, backupPath) {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "hermes",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored Hermes config from backup" : "Backup file not found"
+  };
+}
+
+// src/sync/openclaw.ts
+import fs8 from "node:fs";
+import path8 from "node:path";
+function findKeyObjectSpan2(content, key) {
+  const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
+  const match = content.match(regex);
+  if (!match || match.index === void 0) return null;
+  const startIndex = match.index;
+  const braceIndex = content.indexOf("{", startIndex + match[0].length - 1);
+  if (braceIndex === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+  for (let i = braceIndex; i < content.length; i++) {
+    const ch = content[i];
+    const nextCh = content[i + 1] || "";
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && nextCh === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && nextCh === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && nextCh === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        let endIndex = i + 1;
+        let hasTrailingComma = false;
+        while (endIndex < content.length && /[\s,]/.test(content[endIndex])) {
+          if (content[endIndex] === ",") {
+            hasTrailingComma = true;
+            endIndex++;
+            break;
+          }
+          if (content[endIndex] === "\n") {
+            break;
+          }
+          endIndex++;
+        }
+        return { start: startIndex, end: endIndex, hasTrailingComma };
+      }
+    }
+  }
+  return null;
+}
+function buildOpenClawProviderObject(baseUrl, apiKey, model = "qwen3.8-max", models) {
+  const modelList = Array.from(
+    new Set([model, ...models && models.length > 0 ? models : [model, "qwen3.7-plus"]].filter(Boolean))
+  );
+  const modelEntries = modelList.map((m) => ({
+    id: m,
+    name: formatModelDisplayName(m),
+    reasoning: true,
+    supportsReasoningEffort: true,
+    supportedReasoningEfforts: ["low", "medium", "high"],
+    contextWindow: 1e6,
+    maxTokens: 65536
+  }));
+  return {
+    baseUrl,
+    apiKey,
+    api: "openai-completions",
+    models: modelEntries
+  };
+}
+function syncOpenClaw(options) {
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models, reasoningEffort = "high" } = options;
+  try {
+    fs8.mkdirSync(path8.dirname(filePath), { recursive: true });
+    let backupPath;
+    let content = "";
+    if (fs8.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs8.readFileSync(filePath, "utf-8");
+    }
+    const providerObj = buildOpenClawProviderObject(baseUrl, apiKey, model, models);
+    const providerJson = JSON.stringify(providerObj, null, 6).split("\n").map((line, idx) => idx === 0 ? line : `        ${line}`).join("\n");
+    const qwenEntry = `        "qwenproxy": ${providerJson}`;
+    if (!content.trim()) {
+      const initial = {
+        models: {
+          mode: "merge",
+          providers: {
+            qwenproxy: providerObj
+          }
+        },
+        agents: {
+          defaults: {
+            model: {
+              primary: `qwenproxy/${model}`
+            },
+            thinking: {
+              effort: reasoningEffort
+            }
+          }
+        }
+      };
+      fs8.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+    } else {
+      const existingSpan = findKeyObjectSpan2(content, "qwenproxy");
+      if (existingSpan) {
+        const comma = existingSpan.hasTrailingComma ? "," : "";
+        content = content.slice(0, existingSpan.start) + `"qwenproxy": ${providerJson}${comma}` + content.slice(existingSpan.end);
+      } else {
+        const providersMatch = content.match(/"providers"\s*:\s*\{/);
+        if (providersMatch && providersMatch.index !== void 0) {
+          const insertIdx = providersMatch.index + providersMatch[0].length;
+          content = content.slice(0, insertIdx) + "\n" + qwenEntry + "," + content.slice(insertIdx);
+        } else {
+          const modelsMatch = content.match(/"models"\s*:\s*\{/);
+          if (modelsMatch && modelsMatch.index !== void 0) {
+            const insertIdx = modelsMatch.index + modelsMatch[0].length;
+            const providersBlock = `
+    "providers": {
+${qwenEntry}
+    },`;
+            content = content.slice(0, insertIdx) + providersBlock + content.slice(insertIdx);
+          } else {
+            const lastBraceIdx = content.lastIndexOf("}");
+            if (lastBraceIdx !== -1) {
+              const comma = content.slice(0, lastBraceIdx).trimEnd().endsWith("{") ? "" : ",";
+              const modelsBlock = `${comma}
+  "models": {
+    "mode": "merge",
+    "providers": {
+${qwenEntry}
+    }
+  }
+`;
+              content = content.slice(0, lastBraceIdx).trimEnd() + modelsBlock + "}\n";
+            }
+          }
+        }
+      }
+      fs8.writeFileSync(filePath, content, "utf-8");
+    }
+    return {
+      client: "openclaw",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured OpenClaw with provider qwenproxy (${baseUrl}) and reasoning effort ${reasoningEffort}`
+    };
+  } catch (err) {
+    return {
+      client: "openclaw",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreOpenClaw(filePath, backupPath) {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "openclaw",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored OpenClaw config from backup" : "Backup file not found"
+  };
+}
+
+// src/sync/kilo.ts
+import fs9 from "node:fs";
+import path9 from "node:path";
+function findKeyObjectSpan3(content, key) {
+  const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
+  const match = content.match(regex);
+  if (!match || match.index === void 0) return null;
+  const startIndex = match.index;
+  const braceIndex = content.indexOf("{", startIndex + match[0].length - 1);
+  if (braceIndex === -1) return null;
+  let depth = 0;
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+  for (let i = braceIndex; i < content.length; i++) {
+    const ch = content[i];
+    const nextCh = content[i + 1] || "";
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && nextCh === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && nextCh === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && nextCh === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        let endIndex = i + 1;
+        let hasTrailingComma = false;
+        while (endIndex < content.length && /[\s,]/.test(content[endIndex])) {
+          if (content[endIndex] === ",") {
+            hasTrailingComma = true;
+            endIndex++;
+            break;
+          }
+          if (content[endIndex] === "\n") {
+            break;
+          }
+          endIndex++;
+        }
+        return { start: startIndex, end: endIndex, hasTrailingComma };
+      }
+    }
+  }
+  return null;
+}
+function buildKiloProviderObject(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
+  const modelsObj = {};
+  const modelList = Array.from(
+    new Set([primaryModel, ...models && models.length > 0 ? models : [primaryModel, "qwen3.7-plus"]].filter(Boolean))
+  );
+  for (const m of modelList) {
+    modelsObj[m] = {
+      name: formatModelDisplayName(m),
+      limit: { context: 1048576, output: 65536 },
+      modalities: { input: ["text", "image"], output: ["text"] },
+      reasoning: true,
+      variants: {
+        low: { effort: "low" },
+        medium: { effort: "medium" },
+        high: { effort: "high" }
+      }
+    };
+  }
+  return {
+    npm: "@ai-sdk/openai-compatible",
+    name: "QwenProxy",
+    options: {
+      baseURL: baseUrl,
+      apiKey
+    },
+    models: modelsObj
+  };
+}
+function syncKilo(options) {
+  const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models, setActive = true } = options;
+  try {
+    fs9.mkdirSync(path9.dirname(filePath), { recursive: true });
+    let backupPath;
+    let content = "";
+    if (fs9.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      content = fs9.readFileSync(filePath, "utf-8");
+    }
+    const providerObj = buildKiloProviderObject(baseUrl, apiKey, model, models);
+    const providerJson = JSON.stringify(providerObj, null, 6).split("\n").map((line, idx) => idx === 0 ? line : `    ${line}`).join("\n");
+    const qwenEntry = `    "qwenproxy": ${providerJson}`;
+    if (!content.trim()) {
+      const initial = {
+        $schema: "https://kilo.ai/config.json",
+        provider: {
+          qwenproxy: providerObj
+        }
+      };
+      if (setActive) {
+        initial.model = `qwenproxy/${model}`;
+      }
+      fs9.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+    } else {
+      const existingSpan = findKeyObjectSpan3(content, "qwenproxy");
+      if (existingSpan) {
+        const comma = existingSpan.hasTrailingComma ? "," : "";
+        content = content.slice(0, existingSpan.start) + `"qwenproxy": ${providerJson}${comma}` + content.slice(existingSpan.end);
+      } else {
+        const providerMatch = content.match(/"provider"\s*:\s*\{/);
+        if (providerMatch && providerMatch.index !== void 0) {
+          const insertIdx = providerMatch.index + providerMatch[0].length;
+          content = content.slice(0, insertIdx) + "\n" + qwenEntry + "," + content.slice(insertIdx);
+        } else {
+          const lastBraceIdx = content.lastIndexOf("}");
+          if (lastBraceIdx !== -1) {
+            const comma = content.slice(0, lastBraceIdx).trimEnd().endsWith("{") ? "" : ",";
+            content = content.slice(0, lastBraceIdx).trimEnd() + `${comma}
+  "provider": {
+${qwenEntry}
+  }
+}
+`;
+          }
+        }
+      }
+      if (setActive) {
+        const modelRegex = /"model"\s*:\s*"[^"]*"/;
+        if (modelRegex.test(content)) {
+          content = content.replace(modelRegex, `"model": "qwenproxy/${model}"`);
+        }
+      }
+      fs9.writeFileSync(filePath, content, "utf-8");
+    }
+    return {
+      client: "kilo",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Kilo Code with provider qwenproxy (${baseUrl})`
+    };
+  } catch (err) {
+    return {
+      client: "kilo",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreKilo(filePath, backupPath) {
+  const restored = restoreFromBackup(filePath, backupPath);
+  return {
+    client: "kilo",
+    filePath,
+    backupPath,
+    success: restored,
+    action: restored ? "restored" : "failed",
+    message: restored ? "Restored Kilo Code config from backup" : "Backup file not found"
+  };
+}
+
+// src/sync/cline.ts
+import fs10 from "node:fs";
+import path10 from "node:path";
+import Database from "better-sqlite3";
+var TARGET_KEYS = [
+  "saoudrizwan.claude-dev",
+  "ZooCodeOrganization.zoo-code",
+  "RooVeterinaryInc.roo-cline"
+];
+function syncCline(options) {
+  const { filePath, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = options;
+  try {
+    fs10.mkdirSync(path10.dirname(filePath), { recursive: true });
+    let backupPath;
+    if (fs10.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+    }
+    const db = new Database(filePath);
+    db.exec(`CREATE TABLE IF NOT EXISTS ItemTable (key TEXT UNIQUE ON CONFLICT REPLACE, value TEXT)`);
+    const selectStmt = db.prepare(`SELECT value FROM ItemTable WHERE key = ?`);
+    const insertStmt = db.prepare(`INSERT INTO ItemTable (key, value) VALUES (?, ?)`);
+    const updateConfig = (existingVal) => {
+      let parsed = {};
+      if (existingVal) {
+        try {
+          parsed = JSON.parse(existingVal);
+        } catch {
+          parsed = {};
+        }
+      }
+      parsed.apiProvider = "openai";
+      parsed.openAiBaseUrl = baseUrl;
+      parsed.openAiModelId = model;
+      parsed.enableReasoningEffort = true;
+      parsed.reasoningEffort = reasoningEffort;
+      parsed.openAiCustomModelInfo = {
+        ...parsed.openAiCustomModelInfo || {},
+        contextWindow: 1e6,
+        maxTokens: -1,
+        supportsImages: true,
+        supportsPromptCache: false,
+        inputPrice: 0,
+        outputPrice: 0
+      };
+      if (Array.isArray(parsed.listApiConfigMeta)) {
+        if (!parsed.listApiConfigMeta.some((p) => p?.name === "QwenProxy")) {
+          parsed.listApiConfigMeta.push({
+            name: "QwenProxy",
+            id: "qwenproxy-local",
+            apiProvider: "openai",
+            modelId: model
+          });
+        }
+        parsed.currentApiConfigName = "QwenProxy";
+      }
+      return JSON.stringify(parsed);
+    };
+    for (const key of TARGET_KEYS) {
+      const row = selectStmt.get(key);
+      if (row || key === "saoudrizwan.claude-dev" || key === "ZooCodeOrganization.zoo-code") {
+        const newVal = updateConfig(row?.value);
+        insertStmt.run(key, newVal);
+      }
+    }
+    db.close();
+    return {
+      client: "cline",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Cline in state.vscdb with model ${model} and reasoning effort ${reasoningEffort}`
+    };
+  } catch (err) {
+    return {
+      client: "cline",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreCline(filePath, backupPath) {
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+  let manuallyCleaned = false;
+  if (fs10.existsSync(filePath)) {
+    try {
+      const db = new Database(filePath);
+      const rows = db.prepare("SELECT key, value FROM ItemTable WHERE key = 'saoudrizwan.claude-dev' OR key = 'ZooCodeOrganization.zoo-code'").all();
+      for (const row of rows) {
+        try {
+          const parsed = JSON.parse(row.value);
+          if (parsed.openAiBaseUrl?.includes("7936") || parsed.openAiModelId?.includes("qwen")) {
+            delete parsed.openAiBaseUrl;
+            delete parsed.openAiApiKey;
+            delete parsed.openAiModelId;
+            db.prepare("UPDATE ItemTable SET value = ? WHERE key = ?").run(JSON.stringify(parsed), row.key);
+            manuallyCleaned = true;
+          }
+        } catch {
+        }
+      }
+      db.close();
+    } catch {
+    }
+  }
+  const success = restoredFromBackup || manuallyCleaned;
+  return {
+    client: "cline",
+    filePath,
+    backupPath,
+    success,
+    action: success ? "restored" : "failed",
+    message: success ? restoredFromBackup ? "Restored Cline settings from backup" : "Removed QwenProxy configuration from Cline settings" : "Backup file not found"
+  };
+}
+
+// src/sync/zed.ts
+import fs11 from "node:fs";
+import path11 from "node:path";
+function parseJsonWithComments(raw) {
+  let result = "";
+  let inString = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let escape = false;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    const nextCh = raw[i + 1] || "";
+    if (inLineComment) {
+      if (ch === "\n") {
+        inLineComment = false;
+        result += ch;
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && nextCh === "/") {
+        inBlockComment = false;
+        i++;
+      }
+      continue;
+    }
+    if (inString) {
+      result += ch;
+      if (escape) {
+        escape = false;
+      } else if (ch === "\\") {
+        escape = true;
+      } else if (ch === '"') {
+        inString = false;
+      }
+      continue;
+    }
+    if (ch === "/" && nextCh === "/") {
+      inLineComment = true;
+      i++;
+      continue;
+    }
+    if (ch === "/" && nextCh === "*") {
+      inBlockComment = true;
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      result += ch;
+      continue;
+    }
+    result += ch;
+  }
+  const cleaned = result.replace(/,\s*([\}\]])/g, "$1");
+  return JSON.parse(cleaned);
+}
+function buildZedAvailableModels(primaryModel = "qwen3.8-max", models) {
+  const modelList = Array.from(
+    new Set([primaryModel, ...models && models.length > 0 ? models : [primaryModel, "qwen3.7-plus"]].filter(Boolean))
+  );
+  const zedModels = [];
+  for (const m of modelList) {
+    zedModels.push({
+      name: m,
+      max_tokens: 1e6,
+      max_output_tokens: 131072,
+      max_completion_tokens: 131072,
+      capabilities: {
+        tools: true,
+        images: true,
+        parallel_tool_calls: true,
+        prompt_cache_key: true,
+        chat_completions: true,
+        interleaved_reasoning: true
+      }
+    });
+    if (m === primaryModel) {
+      zedModels.push(
+        {
+          name: `${m}-thinking`,
+          max_tokens: 1e6,
+          max_output_tokens: 131072,
+          max_completion_tokens: 131072,
+          capabilities: {
+            tools: true,
+            images: true,
+            parallel_tool_calls: true,
+            prompt_cache_key: true,
+            chat_completions: true,
+            interleaved_reasoning: true
+          }
+        },
+        {
+          name: `${m}-fast`,
+          max_tokens: 1e6,
+          max_output_tokens: 131072,
+          max_completion_tokens: 131072,
+          capabilities: {
+            tools: true,
+            images: true,
+            parallel_tool_calls: true,
+            prompt_cache_key: true,
+            chat_completions: true,
+            interleaved_reasoning: true
+          }
+        }
+      );
+    }
+  }
+  return zedModels;
+}
+function syncZed(options) {
+  const { filePath, baseUrl, model = "qwen3.8-max", models, setActive = true } = options;
+  try {
+    fs11.mkdirSync(path11.dirname(filePath), { recursive: true });
+    let backupPath;
+    let existingSettings = {};
+    if (fs11.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      try {
+        const content = fs11.readFileSync(filePath, "utf-8");
+        existingSettings = parseJsonWithComments(content);
+      } catch {
+        existingSettings = {};
+      }
+    }
+    const languageModels = existingSettings.language_models || {};
+    const openaiCompatible = languageModels.openai_compatible || {};
+    openaiCompatible.QwenProxy = {
+      api_url: baseUrl,
+      available_models: buildZedAvailableModels(model, models)
+    };
+    const updatedSettings = {
+      ...existingSettings,
+      language_models: {
+        ...languageModels,
+        openai_compatible: openaiCompatible
+      }
+    };
+    if (setActive) {
+      const existingAgent = existingSettings.agent || {};
+      updatedSettings.agent = {
+        ...existingAgent,
+        default_model: {
+          provider: "QwenProxy",
+          model,
+          enable_thinking: true
+        }
+      };
+    }
+    fs11.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+    return {
+      client: "zed",
+      filePath,
+      backupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Zed Editor with QwenProxy (${baseUrl}) and model ${model}`
+    };
+  } catch (err) {
+    return {
+      client: "zed",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreZed(filePath, backupPath) {
+  const restoredFromBackup = restoreFromBackup(filePath, backupPath);
+  let manuallyCleaned = false;
+  if (fs11.existsSync(filePath)) {
+    try {
+      let content = fs11.readFileSync(filePath, "utf-8");
+      if (content.includes("127.0.0.1:7936") || content.includes("qwen3.8-max")) {
+        const data = parseJsonWithComments(content);
+        if (data.language_models?.openai?.api_url?.includes("7936")) {
+          delete data.language_models.openai;
+          if (Object.keys(data.language_models).length === 0) {
+            delete data.language_models;
+          }
+          fs11.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+          manuallyCleaned = true;
+        }
+      }
+    } catch {
+    }
+  }
+  const success = restoredFromBackup || manuallyCleaned;
+  return {
+    client: "zed",
+    filePath,
+    backupPath,
+    success,
+    action: success ? "restored" : "failed",
+    message: success ? restoredFromBackup ? "Restored Zed settings from backup" : "Removed QwenProxy configuration from Zed settings" : "Backup file not found"
+  };
+}
+
+// src/sync/aider.ts
+import fs12 from "node:fs";
+import path12 from "node:path";
+function updateYamlKeyValue(content, key, value) {
+  const regex = new RegExp(`^${key}:.*$`, "m");
+  const line = `${key}: ${value}`;
+  if (regex.test(content)) {
+    return content.replace(regex, line);
+  }
+  return content.trimEnd() + (content.length > 0 ? "\n" : "") + line + "\n";
+}
+function syncAider(options) {
+  const {
+    filePath,
+    apiKey,
+    baseUrl,
+    model = "qwen3.8-max",
+    reasoningEffort = "high",
+    modelSettingsPath
+  } = options;
+  try {
+    fs12.mkdirSync(path12.dirname(filePath), { recursive: true });
+    let backupPath;
+    let confContent = "";
+    if (fs12.existsSync(filePath)) {
+      backupPath = createTimestampBackup(filePath);
+      confContent = fs12.readFileSync(filePath, "utf-8");
+    }
+    const fullModelName = model.startsWith("openai/") ? model : `openai/${model}`;
+    const weakModelName = "openai/qwen3.7-plus";
+    confContent = updateYamlKeyValue(confContent, "openai-api-base", baseUrl);
+    confContent = updateYamlKeyValue(confContent, "openai-api-key", apiKey);
+    confContent = updateYamlKeyValue(confContent, "model", fullModelName);
+    confContent = updateYamlKeyValue(confContent, "editor-model", fullModelName);
+    confContent = updateYamlKeyValue(confContent, "weak-model", weakModelName);
+    fs12.writeFileSync(filePath, confContent.trimEnd() + "\n", "utf-8");
+    let extraBackupPath;
+    const resolvedSettingsPath = modelSettingsPath || path12.join(path12.dirname(filePath), ".aider.model.settings.yml");
+    if (resolvedSettingsPath) {
+      fs12.mkdirSync(path12.dirname(resolvedSettingsPath), { recursive: true });
+      let settingsContent = "";
+      if (fs12.existsSync(resolvedSettingsPath)) {
+        extraBackupPath = createTimestampBackup(resolvedSettingsPath);
+        settingsContent = fs12.readFileSync(resolvedSettingsPath, "utf-8");
+      }
+      const modelBlock = `- name: ${fullModelName}
+  extra_params:
+    extra_body:
+      reasoning_effort: ${reasoningEffort}
+  streaming: true
+`;
+      const existingModelRegex = new RegExp(`- name: ${fullModelName}[\\s\\S]*?(?=(?:^-[ \\t]+name:|\\Z))`, "m");
+      if (existingModelRegex.test(settingsContent)) {
+        settingsContent = settingsContent.replace(existingModelRegex, modelBlock.trimEnd() + "\n");
+      } else {
+        settingsContent = settingsContent.trimEnd() + (settingsContent.length > 0 ? "\n\n" : "") + modelBlock;
+      }
+      fs12.writeFileSync(resolvedSettingsPath, settingsContent.trimEnd() + "\n", "utf-8");
+    }
+    return {
+      client: "aider",
+      filePath,
+      backupPath,
+      extraBackupPath,
+      success: true,
+      action: backupPath ? "updated" : "created",
+      message: `Configured Aider with model ${fullModelName} and reasoning effort ${reasoningEffort}`
+    };
+  } catch (err) {
+    return {
+      client: "aider",
+      filePath,
+      success: false,
+      action: "failed",
+      error: err?.message || String(err)
+    };
+  }
+}
+function restoreAider(filePath, backupPath, modelSettingsPath, extraBackupPath) {
+  const mainRestored = restoreFromBackup(filePath, backupPath);
+  if (modelSettingsPath && extraBackupPath) {
+    restoreFromBackup(modelSettingsPath, extraBackupPath);
+  }
+  return {
+    client: "aider",
+    filePath,
+    backupPath,
+    extraBackupPath,
+    success: mainRestored,
+    action: mainRestored ? "restored" : "failed",
+    message: mainRestored ? "Restored Aider settings from backup" : "Backup file not found"
+  };
+}
+
+// src/sync/index.ts
+function resolveApiKey(overrideKey, configKey, host = "127.0.0.1") {
+  if (overrideKey && overrideKey.trim().length > 0) {
+    if (isPlaceholderApiKey(overrideKey) && !isLoopbackHost(host)) {
+      throw new Error(
+        `Refusing to sync clients with placeholder API key ${PLACEHOLDER_API_KEY}. Set API_KEY first.`
+      );
+    }
+    return overrideKey.trim();
+  }
+  const envKey = (!isPlaceholderApiKey(process.env.API_KEY) ? process.env.API_KEY : void 0) || (!isPlaceholderApiKey(process.env.ADMIN_PASSWORD) ? process.env.ADMIN_PASSWORD : void 0) || configKey;
+  if (envKey && !isPlaceholderApiKey(envKey)) {
+    return envKey.trim();
+  }
+  if (isLoopbackHost(host)) return PLACEHOLDER_API_KEY;
+  throw new Error(
+    `Refusing to sync clients with placeholder API key ${PLACEHOLDER_API_KEY}. Set API_KEY or start the proxy once to generate one.`
+  );
+}
+function normalizeClientName(name) {
+  const clean = name.trim().toLowerCase().replace(/[-_ ]/g, "");
+  if (clean === "claude" || clean === "claudecode" || clean === "anthropic") return "claude-code";
+  if (clean === "codex" || clean === "codexcli" || clean === "openai") return "codex";
+  if (clean === "opencode") return "opencode";
+  if (clean === "omp" || clean === "ohmypi" || clean === "pi") return "omp";
+  if (clean === "hermes" || clean === "hermesagent" || clean === "nous" || clean === "nousresearch") return "hermes";
+  if (clean === "openclaw" || clean === "claw" || clean === "clawdbot" || clean === "moltbot") return "openclaw";
+  if (clean === "kilo" || clean === "kilocode") return "kilo";
+  if (clean === "cline" || clean === "claudedev" || clean === "zoo" || clean === "zoocode" || clean === "roo" || clean === "roocode" || clean === "roocline") {
+    return "cline";
+  }
+  if (clean === "zed" || clean === "zededitor") return "zed";
+  if (clean === "aider" || clean === "aiderchat") return "aider";
+  return null;
+}
+function resolveBaseUrls(port = 7936, host = "127.0.0.1") {
+  const cleanHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+  return {
+    anthropicBaseUrl: `http://${cleanHost}:${port}`,
+    openaiBaseUrl: `http://${cleanHost}:${port}/v1`
+  };
+}
+function getDefaultPaths() {
+  const home = os3.homedir();
+  const isWindows = process.platform === "win32";
+  const isMac = process.platform === "darwin";
+  const appData = process.env.APPDATA || (isWindows ? path13.join(home, "AppData", "Roaming") : "");
+  const openCodeCandidates = [
+    path13.join(home, ".config", "opencode", "opencode.jsonc"),
+    path13.join(home, ".config", "opencode", "opencode.json"),
+    path13.join(home, ".opencode", "opencode.jsonc"),
+    path13.join(home, ".opencode", "opencode.json")
+  ];
+  const existingOpenCode = openCodeCandidates.find((p) => fs13.existsSync(p));
+  const kiloCandidates = [
+    path13.join(home, ".config", "kilo", "kilo.json"),
+    path13.join(home, ".kilo", "kilo.json"),
+    path13.join(home, ".config", "kilo", "config.json"),
+    path13.join(home, ".kilo", "config.json")
+  ];
+  const existingKilo = kiloCandidates.find((p) => fs13.existsSync(p));
+  let clinePath;
+  if (isWindows) {
+    clinePath = path13.join(appData, "Code", "User", "globalStorage", "state.vscdb");
+  } else if (isMac) {
+    clinePath = path13.join(home, "Library", "Application Support", "Code", "User", "globalStorage", "state.vscdb");
+  } else {
+    clinePath = path13.join(home, ".config", "Code", "User", "globalStorage", "state.vscdb");
+  }
+  let zedPath;
+  if (isWindows) {
+    zedPath = path13.join(appData, "Zed", "settings.json");
+  } else {
+    zedPath = path13.join(home, ".config", "zed", "settings.json");
+  }
+  return {
+    claudeCode: path13.join(home, ".claude", "settings.json"),
+    codex: fs13.existsSync(path13.join(home, ".codex", "config.toml")) ? path13.join(home, ".codex", "config.toml") : process.env.CODEX_HOME ? path13.join(process.env.CODEX_HOME, "config.toml") : path13.join(home, ".codex", "config.toml"),
+    openCode: existingOpenCode || openCodeCandidates[0],
+    omp: path13.join(home, ".omp", "agent", "models.yml"),
+    hermes: path13.join(home, ".hermes", "config.yaml"),
+    openClaw: path13.join(home, ".openclaw", "openclaw.json"),
+    kilo: existingKilo || kiloCandidates[0],
+    cline: clinePath,
+    zed: zedPath,
+    aider: path13.join(home, ".aider.conf.yml")
+  };
+}
+function getDefaultStateFilePath() {
+  return getSyncStatePath();
+}
+function isExecutableInPath(name) {
+  const envPath2 = process.env.PATH || "";
+  const dirs = envPath2.split(path13.delimiter).filter(Boolean);
+  const extensions = process.platform === "win32" ? (process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.toLowerCase()) : [""];
+  for (const dir of dirs) {
+    for (const ext of extensions) {
+      const fullPath = path13.join(dir, name + ext);
+      try {
+        if (fs13.existsSync(fullPath) && !fs13.statSync(fullPath).isDirectory()) {
+          return true;
+        }
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function isVscodeExtensionInstalled(pattern) {
+  const home = os3.homedir();
+  const candidateDirs = [
+    path13.join(home, ".vscode", "extensions"),
+    path13.join(home, ".vscode-insiders", "extensions"),
+    path13.join(home, ".cursor", "extensions"),
+    path13.join(home, ".windsurf", "extensions")
+  ];
+  for (const d of candidateDirs) {
+    if (fs13.existsSync(d)) {
+      try {
+        const entries = fs13.readdirSync(d);
+        if (entries.some((e) => pattern.test(e))) return true;
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function isZedInstalled() {
+  if (isExecutableInPath("zed")) return true;
+  if (process.platform === "win32") {
+    const local = process.env.LOCALAPPDATA || "";
+    if (fs13.existsSync(path13.join(local, "Programs", "Zed"))) return true;
+  } else if (process.platform === "darwin") {
+    if (fs13.existsSync("/Applications/Zed.app")) return true;
+  }
+  return false;
+}
+function isMatchingLocalHost(text, port = 7936) {
+  if (!text) return false;
+  const configuredPort = config.server?.port || 7936;
+  const ports = /* @__PURE__ */ new Set([String(port), String(configuredPort), "7936", "3000"]);
+  const isLocal = text.includes("127.0.0.1") || text.includes("localhost") || text.includes("0.0.0.0");
+  return isLocal && Array.from(ports).some((p) => text.includes(`:${p}`));
+}
+function isClientToolInstalled(id, targetPath, isCustomTestPath = false) {
+  if (isCustomTestPath) {
+    return fs13.existsSync(targetPath);
+  }
+  switch (id) {
+    case "hermes":
+      return isExecutableInPath("hermes");
+    case "openclaw":
+      return isExecutableInPath("openclaw") || isExecutableInPath("clawdbot") || isExecutableInPath("moltbot");
+    case "aider":
+      return isExecutableInPath("aider");
+    case "kilo":
+      return isExecutableInPath("kilo") || isVscodeExtensionInstalled(/kilo/i);
+    case "cline":
+      return isExecutableInPath("cline") || isVscodeExtensionInstalled(/cline|zoo-code|roo-cline/i);
+    case "zed":
+      return isZedInstalled();
+    case "claude-code":
+      return isExecutableInPath("claude") || fs13.existsSync(targetPath);
+    case "codex":
+      return isExecutableInPath("codex") || fs13.existsSync(targetPath);
+    case "opencode":
+      return isExecutableInPath("opencode") || fs13.existsSync(targetPath);
+    case "omp":
+      return isExecutableInPath("omp") || fs13.existsSync(targetPath);
+    default:
+      return fs13.existsSync(targetPath);
+  }
+}
+function inspectClientSyncStatus(id, filePath, port = 7936) {
+  const defaultPaths = getDefaultPaths();
+  const defaultTarget = defaultPaths[id] || "";
+  const isCustomTestPath = Boolean(
+    filePath && defaultTarget && path13.resolve(filePath) !== path13.resolve(defaultTarget)
+  );
+  const targetPath = filePath || defaultTarget;
+  if (!fs13.existsSync(targetPath)) {
+    return { id, installed: false, synced: false };
+  }
+  const toolInstalled = isClientToolInstalled(id, targetPath, isCustomTestPath);
+  if (!toolInstalled) {
+    return { id, installed: false, synced: false };
+  }
+  try {
+    if (id === "cline") {
+      let isSynced = false;
+      let model;
+      let rowExists = false;
+      try {
+        const db = new Database2(targetPath, { readonly: true });
+        const row = db.prepare(
+          `SELECT value FROM ItemTable WHERE key = 'saoudrizwan.claude-dev' OR key = 'ZooCodeOrganization.zoo-code' LIMIT 1`
+        ).get();
+        db.close();
+        if (row && row.value) {
+          rowExists = true;
+          const parsed = JSON.parse(row.value);
+          const url = parsed.openAiBaseUrl || "";
+          model = parsed.openAiModelId;
+          isSynced = isMatchingLocalHost(url, port);
+        }
+      } catch {
+      }
+      const isInstalled = isCustomTestPath ? true : rowExists || isExecutableInPath("cline") || isVscodeExtensionInstalled(/cline|zoo-code|roo-cline/i);
+      return { id, installed: isInstalled, synced: isInstalled && isSynced, model };
+    }
+    const raw = fs13.readFileSync(targetPath, "utf-8");
+    if (id === "claude-code") {
+      const data = JSON.parse(raw);
+      const url = data?.env?.ANTHROPIC_BASE_URL || "";
+      const model = data?.env?.ANTHROPIC_MODEL || data?.model || "";
+      const isSynced = isMatchingLocalHost(url, port) && (model.toLowerCase().includes("qwen") || Boolean(data?.env?.ANTHROPIC_AUTH_TOKEN));
+      return {
+        id,
+        installed: true,
+        synced: isSynced,
+        model: model || void 0,
+        url: url || void 0
+      };
+    }
+    if (id === "codex") {
+      const hasProvider = raw.includes("[model_providers.qwenproxy]");
+      const isProviderActive = /^model_provider\s*=\s*["']qwenproxy["']/m.test(raw);
+      const modelMatch = raw.match(/^model\s*=\s*["']([^"']+)["']/m);
+      const model = modelMatch ? modelMatch[1] : void 0;
+      const urlMatch = raw.match(/\[model_providers\.qwenproxy\][\s\S]*?base_url\s*=\s*["']([^"']+)["']/);
+      const url = urlMatch ? urlMatch[1] : "";
+      const isSynced = hasProvider && isProviderActive && isMatchingLocalHost(url, port);
+      return {
+        id,
+        installed: true,
+        synced: isSynced,
+        model
+      };
+    }
+    if (id === "opencode") {
+      let isSynced = false;
+      try {
+        const data = JSON.parse(raw);
+        const provider = data?.provider?.qwenproxy;
+        const url = provider?.options?.baseURL || "";
+        const isSynced2 = Boolean(provider && isMatchingLocalHost(url, port));
+        return { id, installed: true, synced: isSynced2 };
+      } catch {
+        const qwenBlockMatch = raw.match(/"qwenproxy"\s*:\s*\{[\s\S]*?"baseURL"\s*:\s*"([^"]+)"/);
+        const url = qwenBlockMatch ? qwenBlockMatch[1] : "";
+        const isSynced2 = Boolean(url && isMatchingLocalHost(url, port));
+        return { id, installed: true, synced: isSynced2 };
+      }
+      return {
+        id,
+        installed: true,
+        synced: isSynced
+      };
+    }
+    if (id === "omp") {
+      const ompMatch = raw.match(/^[ \t]*qwenproxy:\s*\r?\n((?:[ \t]{4,}.*\r?\n?)*)/m);
+      let isSynced = false;
+      let url;
+      if (ompMatch) {
+        const urlMatch = ompMatch[1].match(/baseUrl:\s*(\S+)/);
+        url = urlMatch ? urlMatch[1].replace(/['"]/g, "") : void 0;
+        isSynced = Boolean(url && isMatchingLocalHost(url, port));
+      }
+      return {
+        id,
+        installed: true,
+        synced: isSynced,
+        url
+      };
+    }
+    if (id === "hermes") {
+      const isSynced = isMatchingLocalHost(raw, port) && (raw.includes("qwenproxy") || raw.includes("qwen"));
+      return { id, installed: true, synced: isSynced };
+    }
+    if (id === "openclaw") {
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("qwenproxy");
+      return { id, installed: true, synced: isSynced };
+    }
+    if (id === "kilo") {
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("qwenproxy");
+      return { id, installed: true, synced: isSynced };
+    }
+    if (id === "zed") {
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("QwenProxy");
+      return { id, installed: true, synced: isSynced };
+    }
+    if (id === "aider") {
+      const isSynced = isMatchingLocalHost(raw, port) && raw.includes("qwen");
+      return { id, installed: true, synced: isSynced };
+    }
+  } catch {
+    return { id, installed: true, synced: false };
+  }
+  return { id, installed: true, synced: false };
+}
+function syncAllClients(options = {}) {
+  const defaultPaths = getDefaultPaths();
+  const paths = {
+    claudeCode: options.customPaths?.claudeCode || defaultPaths.claudeCode,
+    codex: options.customPaths?.codex || defaultPaths.codex,
+    openCode: options.customPaths?.openCode || defaultPaths.openCode,
+    omp: options.customPaths?.omp || defaultPaths.omp,
+    hermes: options.customPaths?.hermes || defaultPaths.hermes,
+    openClaw: options.customPaths?.openClaw || defaultPaths.openClaw,
+    kilo: options.customPaths?.kilo || defaultPaths.kilo,
+    cline: options.customPaths?.cline || defaultPaths.cline,
+    zed: options.customPaths?.zed || defaultPaths.zed,
+    aider: options.customPaths?.aider || defaultPaths.aider
+  };
+  const port = options.port ?? (config.server?.port || 7936);
+  const configuredHost = config.server?.host;
+  const host = options.host ?? (configuredHost && configuredHost !== "0.0.0.0" ? configuredHost : "127.0.0.1");
+  const authHost = options.host ?? configuredHost ?? host;
+  const apiKey = resolveApiKey(options.apiKey, config.apiKey, authHost);
+  const { anthropicBaseUrl, openaiBaseUrl } = resolveBaseUrls(port, host);
+  const stateFilePath = options.stateFilePath || getDefaultStateFilePath();
+  const selectedModel = options.model || "qwen3.8-max";
+  const allModels = options.models && options.models.length > 0 ? options.models : void 0;
+  const syncModels = options.syncAllModels !== false && allModels ? allModels : [selectedModel];
+  const results = {
+    apiKey,
+    port,
+    host,
+    clients: {}
+  };
+  const stateRecords = {};
+  const shouldSync = (client) => {
+    if (!options.targets || options.targets.length === 0) return true;
+    return options.targets.includes(client);
+  };
+  if (shouldSync("claude-code")) {
+    const claudeExisted = fs13.existsSync(paths.claudeCode);
+    const claudeRes = syncClaudeCode({
+      filePath: paths.claudeCode,
+      apiKey,
+      baseUrl: anthropicBaseUrl,
+      model: selectedModel
+    });
+    results.clients.claudeCode = claudeRes;
+    if (claudeRes.success && claudeRes.backupPath) {
+      stateRecords.claudeCode = {
+        filePath: paths.claudeCode,
+        backupPath: claudeRes.backupPath,
+        existedBefore: claudeExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("codex")) {
+    const codexExisted = fs13.existsSync(paths.codex);
+    const codexRes = syncCodex({
+      filePath: paths.codex,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      setActive: options.setActive ?? true,
+      model: selectedModel
+    });
+    results.clients.codex = codexRes;
+    if (codexRes.success && codexRes.backupPath) {
+      stateRecords.codex = {
+        filePath: paths.codex,
+        backupPath: codexRes.backupPath,
+        existedBefore: codexExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("opencode")) {
+    const openCodeExisted = fs13.existsSync(paths.openCode);
+    const openCodeRes = syncOpenCode({
+      filePath: paths.openCode,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      model: selectedModel,
+      models: syncModels,
+      setActive: options.setActive ?? true
+    });
+    results.clients.openCode = openCodeRes;
+    if (openCodeRes.success && openCodeRes.backupPath) {
+      stateRecords.openCode = {
+        filePath: paths.openCode,
+        backupPath: openCodeRes.backupPath,
+        existedBefore: openCodeExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("omp")) {
+    const ompExisted = fs13.existsSync(paths.omp);
+    const ompRes = syncOmp({
+      filePath: paths.omp,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      model: selectedModel,
+      models: syncModels
+    });
+    results.clients.omp = ompRes;
+    if (ompRes.success && ompRes.backupPath) {
+      stateRecords.omp = {
+        filePath: paths.omp,
+        backupPath: ompRes.backupPath,
+        existedBefore: ompExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("hermes")) {
+    const hermesExisted = fs13.existsSync(paths.hermes);
+    const hermesRes = syncHermes({
+      filePath: paths.hermes,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      model: selectedModel
+    });
+    results.clients.hermes = hermesRes;
+    if (hermesRes.success && hermesRes.backupPath) {
+      stateRecords.hermes = {
+        filePath: paths.hermes,
+        backupPath: hermesRes.backupPath,
+        existedBefore: hermesExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("openclaw")) {
+    const openClawExisted = fs13.existsSync(paths.openClaw);
+    const openClawRes = syncOpenClaw({
+      filePath: paths.openClaw,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      model: selectedModel,
+      models: syncModels
+    });
+    results.clients.openClaw = openClawRes;
+    if (openClawRes.success && openClawRes.backupPath) {
+      stateRecords.openClaw = {
+        filePath: paths.openClaw,
+        backupPath: openClawRes.backupPath,
+        existedBefore: openClawExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("kilo")) {
+    const kiloExisted = fs13.existsSync(paths.kilo);
+    const kiloRes = syncKilo({
+      filePath: paths.kilo,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      setActive: options.setActive ?? true,
+      model: selectedModel,
+      models: syncModels
+    });
+    results.clients.kilo = kiloRes;
+    if (kiloRes.success && kiloRes.backupPath) {
+      stateRecords.kilo = {
+        filePath: paths.kilo,
+        backupPath: kiloRes.backupPath,
+        existedBefore: kiloExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("cline")) {
+    const clineExisted = fs13.existsSync(paths.cline);
+    const clineRes = syncCline({
+      filePath: paths.cline,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      model: selectedModel
+    });
+    results.clients.cline = clineRes;
+    if (clineRes.success && clineRes.backupPath) {
+      stateRecords.cline = {
+        filePath: paths.cline,
+        backupPath: clineRes.backupPath,
+        existedBefore: clineExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("zed")) {
+    const zedExisted = fs13.existsSync(paths.zed);
+    const zedRes = syncZed({
+      filePath: paths.zed,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      setActive: options.setActive ?? true,
+      model: selectedModel,
+      models: syncModels
+    });
+    results.clients.zed = zedRes;
+    if (zedRes.success && zedRes.backupPath) {
+      stateRecords.zed = {
+        filePath: paths.zed,
+        backupPath: zedRes.backupPath,
+        existedBefore: zedExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  if (shouldSync("aider")) {
+    const aiderExisted = fs13.existsSync(paths.aider);
+    const aiderRes = syncAider({
+      filePath: paths.aider,
+      apiKey,
+      baseUrl: openaiBaseUrl,
+      model: selectedModel
+    });
+    results.clients.aider = aiderRes;
+    if (aiderRes.success && aiderRes.backupPath) {
+      stateRecords.aider = {
+        filePath: paths.aider,
+        backupPath: aiderRes.backupPath,
+        existedBefore: aiderExisted,
+        syncedAt: Date.now()
+      };
+    }
+  }
+  try {
+    fs13.mkdirSync(path13.dirname(stateFilePath), { recursive: true });
+    let existingClients = {};
+    if (fs13.existsSync(stateFilePath)) {
+      try {
+        const raw = fs13.readFileSync(stateFilePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed?.clients && typeof parsed.clients === "object") {
+          existingClients = parsed.clients;
+        }
+      } catch {
+      }
+    }
+    const stateContent = {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      apiKey,
+      port,
+      host,
+      clients: {
+        ...existingClients,
+        ...stateRecords
+      }
+    };
+    fs13.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
+  } catch (err) {
+    console.error("Warning: could not write sync state file:", err);
+  }
+  return results;
+}
+function restoreAllClients(options = {}) {
+  const defaultPaths = getDefaultPaths();
+  const stateFilePath = options.stateFilePath || getDefaultStateFilePath();
+  const details = [];
+  let restoredCount = 0;
+  let state = null;
+  if (fs13.existsSync(stateFilePath)) {
+    try {
+      const raw = fs13.readFileSync(stateFilePath, "utf-8");
+      state = JSON.parse(raw);
+    } catch {
+    }
+  }
+  const shouldRestore = (client) => {
+    if (!options.targets || options.targets.length === 0) return true;
+    return options.targets.includes(client);
+  };
+  const restoreClientsList = [
+    { id: "claude-code", stateKey: "claudeCode", defaultPath: defaultPaths.claudeCode, stateRecord: state?.clients?.claudeCode, restoreFn: restoreClaudeCode },
+    { id: "codex", stateKey: "codex", defaultPath: defaultPaths.codex, stateRecord: state?.clients?.codex, restoreFn: restoreCodex },
+    { id: "opencode", stateKey: "openCode", defaultPath: defaultPaths.openCode, stateRecord: state?.clients?.openCode, restoreFn: restoreOpenCode },
+    { id: "omp", stateKey: "omp", defaultPath: defaultPaths.omp, stateRecord: state?.clients?.omp, restoreFn: restoreOmp },
+    { id: "hermes", stateKey: "hermes", defaultPath: defaultPaths.hermes, stateRecord: state?.clients?.hermes, restoreFn: restoreHermes },
+    { id: "openclaw", stateKey: "openClaw", defaultPath: defaultPaths.openClaw, stateRecord: state?.clients?.openClaw, restoreFn: restoreOpenClaw },
+    { id: "kilo", stateKey: "kilo", defaultPath: defaultPaths.kilo, stateRecord: state?.clients?.kilo, restoreFn: restoreKilo },
+    { id: "cline", stateKey: "cline", defaultPath: defaultPaths.cline, stateRecord: state?.clients?.cline, restoreFn: restoreCline },
+    { id: "zed", stateKey: "zed", defaultPath: defaultPaths.zed, stateRecord: state?.clients?.zed, restoreFn: restoreZed },
+    { id: "aider", stateKey: "aider", defaultPath: defaultPaths.aider, stateRecord: state?.clients?.aider, restoreFn: restoreAider }
+  ];
+  for (const c of restoreClientsList) {
+    if (!shouldRestore(c.id)) continue;
+    const filePath = c.stateRecord?.filePath || c.defaultPath;
+    const backupPath = c.stateRecord?.backupPath;
+    const canAttempt = options.stateFilePath ? Boolean(c.stateRecord) : Boolean(c.stateRecord || fs13.existsSync(filePath));
+    if (canAttempt) {
+      const res = c.restoreFn(filePath, backupPath);
+      details.push(res);
+      if (res.success) {
+        restoredCount++;
+        if (state?.clients) {
+          delete state.clients[c.stateKey];
+          delete state.clients[c.id];
+        }
+      }
+    }
+  }
+  if (stateFilePath && fs13.existsSync(stateFilePath)) {
+    try {
+      if (state && state.clients && Object.keys(state.clients).length > 0) {
+        fs13.writeFileSync(stateFilePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+      } else {
+        fs13.unlinkSync(stateFilePath);
+      }
+    } catch {
+    }
+  }
+  return { restoredCount, details };
+}
+
+// src/sync-clients.ts
+process.env.DOTENV_CONFIG_QUIET = "true";
+ensureDataDirs();
+var envPath = getEnvFilePath();
+if (fs14.existsSync(envPath)) {
+  dotenv.config({ path: envPath, quiet: true });
+} else {
+  dotenv.config({ quiet: true });
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    restore: false,
+    list: false,
+    help: false,
+    setActive: true,
+    targets: []
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--restore" || arg === "restore") {
+      options.restore = true;
+    } else if (arg === "--list" || arg === "list") {
+      options.list = true;
+    } else if (arg === "--help" || arg === "-h" || arg === "help") {
+      options.help = true;
+    } else if (arg === "--api-key" && args[i + 1]) {
+      options.apiKey = args[++i];
+    } else if (arg === "--port" && args[i + 1]) {
+      options.port = parseInt(args[++i], 10);
+    } else if (arg === "--host" && args[i + 1]) {
+      options.host = args[++i];
+    } else if (arg === "--no-active") {
+      options.setActive = false;
+    } else if ((arg === "--model" || arg === "-m") && args[i + 1]) {
+      options.model = args[++i];
+    } else if (arg === "--client" && args[i + 1]) {
+      const normalized = normalizeClientName(args[++i]);
+      if (normalized) options.targets.push(normalized);
+    } else if (!arg.startsWith("-")) {
+      const normalized = normalizeClientName(arg);
+      if (normalized) options.targets.push(normalized);
+    }
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`
+Uso:
+  npm run sync [clientes...] [op\xE7\xF5es]
+
+Exemplos:
+  npm run sync                # Sincroniza todos os 10 clientes detectados
+  npm run sync hermes         # Sincroniza apenas o Hermes Agent
+  npm run sync opencode       # Sincroniza apenas o OpenCode
+  npm run sync claude         # Sincroniza apenas o Claude Code
+  npm run sync openclaw       # Sincroniza apenas o OpenClaw
+  npm run sync kilo           # Sincroniza apenas o Kilo Code
+  npm run sync cline          # Sincroniza apenas o Cline
+  npm run sync omp            # Sincroniza apenas o OMP (Oh My Pi)
+  npm run sync codex          # Sincroniza apenas o Codex CLI
+  npm run sync zed            # Sincroniza apenas o Zed Editor
+  npm run sync aider          # Sincroniza apenas o Aider
+  npm run sync claude codex   # Sincroniza m\xFAltiplos clientes espec\xEDficos
+  npm run sync --list         # Lista status de detec\xE7\xE3o de todos os 10 clientes (ou qpx sync --list)
+  npm run sync --restore      # Restaura as configura\xE7\xF5es originais (ou qpx sync --restore)
+
+Op\xE7\xF5es:
+  --client <nome>    Nome do cliente (hermes, opencode, claude, openclaw, kilo, cline, omp, codex, zed, aider)
+  --model <modelo>   Modelo padr\xE3o a configurar (padr\xE3o: qwen3.8-max)
+  --api-key <chave>  Sobrescrever chave de API (obrigat\xF3ria; n\xE3o usa placeholder)
+  --port <porta>     Sobrescrever porta do servidor (padr\xE3o: l\xEA do .env ou usa 7936)
+  --host <host>      Sobrescrever host do servidor (padr\xE3o: 127.0.0.1)
+  --no-active        N\xE3o definir o modelo ativo como padr\xE3o (apenas adiciona o provider)
+  --restore          Desfaz altera\xE7\xF5es restaurando backups
+  --list             Mostra status de detec\xE7\xE3o dos arquivos de configura\xE7\xE3o
+`);
+}
+async function main() {
+  const options = parseArgs();
+  console.log("==================================================");
+  console.log(" \u{1F680} QwenProxy - Top 10 Client Configuration Sync");
+  console.log("==================================================");
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  if (options.list) {
+    console.log("\n\u{1F4C1} Status de detec\xE7\xE3o dos 10 clientes no seu computador:\n");
+    const defaultPaths = getDefaultPaths();
+    const clients = [
+      { id: "hermes", name: "1. Hermes Agent", path: defaultPaths.hermes },
+      { id: "opencode", name: "2. OpenCode", path: defaultPaths.openCode },
+      { id: "claude-code", name: "3. Claude Code", path: defaultPaths.claudeCode },
+      { id: "openclaw", name: "4. OpenClaw", path: defaultPaths.openClaw },
+      { id: "kilo", name: "5. Kilo Code", path: defaultPaths.kilo },
+      { id: "cline", name: "6. Cline", path: defaultPaths.cline },
+      { id: "omp", name: "7. OMP (Oh My Pi)", path: defaultPaths.omp },
+      { id: "codex", name: "8. Codex CLI", path: defaultPaths.codex },
+      { id: "zed", name: "9. Zed Editor", path: defaultPaths.zed },
+      { id: "aider", name: "10. Aider", path: defaultPaths.aider }
+    ];
+    for (const c of clients) {
+      const status = inspectClientSyncStatus(c.id, c.path);
+      let badge = "";
+      let icon = "\u26AA";
+      if (status.synced) {
+        icon = "\u2705";
+        badge = status.model ? `[Sincronizado: ${status.model}]` : "[Sincronizado]";
+      } else if (status.installed) {
+        icon = "\u26A0\uFE0F ";
+        badge = "[Detectado - Outro provedor]";
+      } else {
+        icon = "\u26AA";
+        badge = "[N\xE3o instalado]";
+      }
+      console.log(`  ${icon} ${c.name.padEnd(20)} ${badge}`);
+      console.log(`     ${c.path}`);
+    }
+    console.log("\nPara sincronizar um ou todos, execute:");
+    console.log("  npm run sync");
+    console.log("  npm run sync hermes");
+    console.log("  npm run sync claude cline zed\n");
+    return;
+  }
+  if (options.restore) {
+    console.log("\n\u{1F504} Restaurando configura\xE7\xF5es originais a partir dos backups...\n");
+    const result2 = restoreAllClients();
+    if (result2.restoredCount === 0) {
+      console.log("\u2139\uFE0F Nenhum backup ou arquivo de estado anterior encontrado para restaurar.");
+    } else {
+      for (const item of result2.details) {
+        console.log(`  \u2713 Restaurado [${item.client}]: ${item.filePath}`);
+      }
+      console.log(`
+\u2705 ${result2.restoredCount} configura\xE7\xE3o(\xF5es) restaurada(s) com sucesso!`);
+    }
+    return;
+  }
+  const targetNames = options.targets.length > 0 ? options.targets.join(", ") : "todos os detectados";
+  console.log(`
+\u{1F4E1} Sincronizando clientes: [${targetNames}]...
+`);
+  const result = syncAllClients({
+    apiKey: options.apiKey,
+    port: options.port,
+    host: options.host,
+    setActive: options.setActive,
+    targets: options.targets.length > 0 ? options.targets : void 0,
+    model: options.model
+  });
+  console.log(`\u{1F511} Chave API:   ${result.apiKey}`);
+  console.log(`\u{1F310} Porta:       ${result.port}`);
+  console.log(`\u{1F3E0} Host:        ${result.host}
+`);
+  let count = 0;
+  for (const client of Object.values(result.clients)) {
+    if (!client) continue;
+    count++;
+    const icon = client.success ? "\u2705" : "\u274C";
+    console.log(`${icon} [${client.client}]`);
+    console.log(`   Arquivo: ${client.filePath}`);
+    if (client.backupPath) {
+      console.log(`   Backup:  ${client.backupPath}`);
+    }
+    if (client.message) {
+      console.log(`   Status:  ${client.message}`);
+    }
+    if (client.error) {
+      console.log(`   Erro:    ${client.error}`);
+    }
+    console.log("");
+  }
+  console.log("--------------------------------------------------");
+  console.log(`\u2728 ${count} cliente(s) sincronizado(s) com zero perda de outras configs/provedores!`);
+  console.log("\u{1F4A1} Para desfazer e restaurar a qualquer momento:");
+  console.log("   qpx sync --restore (ou npm run sync --restore)");
+}
+main().catch((err) => {
+  console.error("\u274C Erro fatal durante a sincroniza\xE7\xE3o:", err);
+  process.exit(1);
+});