qwenproxy-cli 1.4.0 → 1.4.2

package/dist/index.js

@@ -151,6 +151,8 @@ var init_paths = __esm({
 });
 
 // src/core/config.ts
+import fs2 from "node:fs";
+import dotenv from "dotenv";
 import { z } from "zod";
 function isStatelessChatMode(mode) {
   if (!mode) return false;
@@ -200,6 +202,15 @@ var envSchema, env, config;
 var init_config = __esm({
   "src/core/config.ts"() {
     "use strict";
+    init_paths();
+    if (!isRunningUnderNodeTest()) {
+      const envPath2 = getEnvFilePath();
+      if (fs2.existsSync(envPath2)) {
+        dotenv.config({ path: envPath2, quiet: true });
+      } else {
+        dotenv.config({ quiet: true });
+      }
+    }
     envSchema = z.object({
       PORT: z.string().regex(/^\d+$/, "PORT must be a number").refine((value) => {
         const port = Number(value);
@@ -566,7 +577,7 @@ var init_config = __esm({
 });
 
 // src/tui/settings.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import path2 from "node:path";
 function loadTuiSettings() {
   if (cachedSettings) {
@@ -578,8 +589,8 @@ function loadTuiSettings() {
   }
   const filePath = getTuiSettingsPath();
   try {
-    if (fs2.existsSync(filePath)) {
-      const raw = fs2.readFileSync(filePath, "utf-8");
+    if (fs3.existsSync(filePath)) {
+      const raw = fs3.readFileSync(filePath, "utf-8");
       const parsed = JSON.parse(raw);
       const loaded = {
         ...defaultSettings,
@@ -620,10 +631,10 @@ function saveTuiSettings(updates) {
     cachedSettings = merged;
     const filePath = getTuiSettingsPath();
     const dir = path2.dirname(filePath);
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
+    if (!fs3.existsSync(dir)) {
+      fs3.mkdirSync(dir, { recursive: true });
     }
-    fs2.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
+    fs3.writeFileSync(filePath, JSON.stringify(merged, null, 2), "utf-8");
   } catch {
   }
 }
@@ -1379,7 +1390,7 @@ var init_memory_cache = __esm({
 
 // src/core/crypto-utils.ts
 import crypto2 from "crypto";
-import fs3 from "fs";
+import fs4 from "fs";
 function getOrCreateKey() {
   if (cachedKey) return cachedKey;
   const envKey = process.env.ENCRYPTION_KEY;
@@ -1387,15 +1398,15 @@ function getOrCreateKey() {
     cachedKey = crypto2.scryptSync(envKey, "qwenproxy-salt", KEY_LENGTH);
     return cachedKey;
   }
-  if (fs3.existsSync(KEY_PATH)) {
-    cachedKey = Buffer.from(fs3.readFileSync(KEY_PATH, "utf-8"), "hex");
+  if (fs4.existsSync(KEY_PATH)) {
+    cachedKey = Buffer.from(fs4.readFileSync(KEY_PATH, "utf-8"), "hex");
     return cachedKey;
   }
-  if (!fs3.existsSync(DATA_DIR)) {
-    fs3.mkdirSync(DATA_DIR, { recursive: true, mode: 493 });
+  if (!fs4.existsSync(DATA_DIR)) {
+    fs4.mkdirSync(DATA_DIR, { recursive: true, mode: 493 });
   }
   const key = crypto2.randomBytes(KEY_LENGTH);
-  fs3.writeFileSync(KEY_PATH, key.toString("hex"), { mode: 384 });
+  fs4.writeFileSync(KEY_PATH, key.toString("hex"), { mode: 384 });
   cachedKey = key;
   return cachedKey;
 }
@@ -1459,21 +1470,21 @@ __export(database_exports, {
 });
 import Database from "better-sqlite3";
 import path3 from "path";
-import fs4 from "fs";
+import fs5 from "fs";
 function getDatabase() {
   if (db) return db;
   try {
-    if (!fs4.existsSync(DB_DIR)) {
-      fs4.mkdirSync(DB_DIR, { recursive: true, mode: 493 });
+    if (!fs5.existsSync(DB_DIR)) {
+      fs5.mkdirSync(DB_DIR, { recursive: true, mode: 493 });
     }
     const migrateLegacyDatabase = (legacyPath, legacyWalPath, legacyShmPath) => {
-      if (fs4.existsSync(legacyPath) && !fs4.existsSync(DB_PATH)) {
-        fs4.renameSync(legacyPath, DB_PATH);
-        if (fs4.existsSync(legacyWalPath) && !fs4.existsSync(DB_WAL_PATH)) {
-          fs4.renameSync(legacyWalPath, DB_WAL_PATH);
+      if (fs5.existsSync(legacyPath) && !fs5.existsSync(DB_PATH)) {
+        fs5.renameSync(legacyPath, DB_PATH);
+        if (fs5.existsSync(legacyWalPath) && !fs5.existsSync(DB_WAL_PATH)) {
+          fs5.renameSync(legacyWalPath, DB_WAL_PATH);
         }
-        if (fs4.existsSync(legacyShmPath) && !fs4.existsSync(DB_SHM_PATH)) {
-          fs4.renameSync(legacyShmPath, DB_SHM_PATH);
+        if (fs5.existsSync(legacyShmPath) && !fs5.existsSync(DB_SHM_PATH)) {
+          fs5.renameSync(legacyShmPath, DB_SHM_PATH);
         }
         console.log(`\u{1F4E6} [Database] Migrated legacy database to ${DB_PATH}`);
       }
@@ -1488,12 +1499,12 @@ function getDatabase() {
       LEGACY_DB_IN_DIR_WAL_PATH,
       LEGACY_DB_IN_DIR_SHM_PATH
     );
-    if (fs4.existsSync(LEGACY_JSON_BAK_PATH) && !fs4.existsSync(DB_JSON_BAK_PATH)) {
-      fs4.renameSync(LEGACY_JSON_BAK_PATH, DB_JSON_BAK_PATH);
+    if (fs5.existsSync(LEGACY_JSON_BAK_PATH) && !fs5.existsSync(DB_JSON_BAK_PATH)) {
+      fs5.renameSync(LEGACY_JSON_BAK_PATH, DB_JSON_BAK_PATH);
     }
     const testFile = path3.join(DB_DIR, ".write-test");
-    fs4.writeFileSync(testFile, "");
-    fs4.unlinkSync(testFile);
+    fs5.writeFileSync(testFile, "");
+    fs5.unlinkSync(testFile);
   } catch (err) {
     console.error(
       `\u274C [Database] Cannot access database directory '${DB_DIR}':`,
@@ -1633,12 +1644,12 @@ function encryptPlaintextPasswords(db2) {
 }
 function migrateFromJson(db2) {
   const jsonPath = LEGACY_JSON_PATH;
-  if (!fs4.existsSync(jsonPath)) return;
+  if (!fs5.existsSync(jsonPath)) return;
   try {
-    const raw = fs4.readFileSync(jsonPath, "utf-8");
+    const raw = fs5.readFileSync(jsonPath, "utf-8");
     const accounts = JSON.parse(raw);
     if (!Array.isArray(accounts) || accounts.length === 0) {
-      fs4.renameSync(jsonPath, DB_JSON_BAK_PATH);
+      fs5.renameSync(jsonPath, DB_JSON_BAK_PATH);
       return;
     }
     const insert = db2.prepare(`
@@ -1652,7 +1663,7 @@ function migrateFromJson(db2) {
       }
     });
     migrate();
-    fs4.renameSync(jsonPath, DB_JSON_BAK_PATH);
+    fs5.renameSync(jsonPath, DB_JSON_BAK_PATH);
     console.log(
       `[Database] Migrated ${accounts.length} account(s) from accounts.json to SQLite`
     );
@@ -1766,7 +1777,7 @@ var init_database = __esm({
 
 // src/core/local-auth.ts
 import crypto3 from "node:crypto";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 function isPlaceholderApiKey(key) {
   const value = (key || "").trim();
   return value.length === 0 || value === PLACEHOLDER_API_KEY;
@@ -1793,7 +1804,7 @@ function assertBindAllowed(host, apiKey) {
 }
 function updateEnvVariable(key, value, envPath2 = getEnvFilePath()) {
   try {
-    const existing = fs5.existsSync(envPath2) ? fs5.readFileSync(envPath2, "utf-8") : "";
+    const existing = fs6.existsSync(envPath2) ? fs6.readFileSync(envPath2, "utf-8") : "";
     const regex = new RegExp(`^([ \\t]*)${key}[ \\t]*=.*$`, "m");
     const assignment = regex.exec(existing);
     let updated;
@@ -1806,7 +1817,7 @@ function updateEnvVariable(key, value, envPath2 = getEnvFilePath()) {
       const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : lineEnding;
       updated = `${existing}${prefix}${key}=${value}${lineEnding}`;
     }
-    fs5.writeFileSync(envPath2, updated, { encoding: "utf-8", mode: 384 });
+    fs6.writeFileSync(envPath2, updated, { encoding: "utf-8", mode: 384 });
   } catch (err) {
     console.warn(
       `\u26A0\uFE0F  [Config] Could not update ${key} in .env:`,
@@ -1824,7 +1835,7 @@ function persistCustomApiKey(apiKey, envPath2 = getEnvFilePath()) {
 }
 function persistApiKey(apiKey, envPath2 = getEnvFilePath()) {
   try {
-    const existing = fs5.existsSync(envPath2) ? fs5.readFileSync(envPath2, "utf-8") : "";
+    const existing = fs6.existsSync(envPath2) ? fs6.readFileSync(envPath2, "utf-8") : "";
     const assignment = /^([ \t]*)API_KEY[ \t]*=[ \t]*(.*)$/m.exec(existing);
     if (assignment?.[2].trim()) return;
     let updated;
@@ -1837,7 +1848,7 @@ function persistApiKey(apiKey, envPath2 = getEnvFilePath()) {
       const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : lineEnding;
       updated = `${existing}${prefix}API_KEY=${apiKey}${lineEnding}`;
     }
-    fs5.writeFileSync(
+    fs6.writeFileSync(
       envPath2,
       updated,
       { encoding: "utf-8", mode: 384 }
@@ -1889,7 +1900,7 @@ __export(accounts_exports, {
 });
 import "dotenv/config";
 import crypto4 from "crypto";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import path4 from "node:path";
 function isPlaceholderAccountEmail(email, password) {
   if (!email || typeof email !== "string") return false;
@@ -2136,20 +2147,20 @@ function addAccount(email, password, id) {
 function wipeAccountSessionFiles(id) {
   const profilePath = getAccountProfilePath(id);
   try {
-    fs6.rmSync(profilePath, { recursive: true, force: true });
+    fs7.rmSync(profilePath, { recursive: true, force: true });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error ?? "");
     if (message.includes("EPERM") || message.includes("EBUSY") || message.includes("Permission denied")) {
       try {
         const stalePath = `${profilePath}.stale-${Date.now()}`;
-        fs6.renameSync(profilePath, stalePath);
+        fs7.renameSync(profilePath, stalePath);
       } catch {
       }
     }
   }
   const siblingState = path4.join(getProfilesDir(), `${id}_state.json`);
   try {
-    fs6.rmSync(siblingState, { force: true });
+    fs7.rmSync(siblingState, { force: true });
   } catch {
   }
 }
@@ -4050,7 +4061,7 @@ __export(clean_cache_exports, {
   getDirStats: () => getDirStats
 });
 import "dotenv/config";
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path5 from "node:path";
 import os3 from "node:os";
 import { chromium } from "patchright";
@@ -4065,14 +4076,14 @@ function getDirStats(dir) {
   let files = 0;
   function walk(d) {
     try {
-      const entries = fs7.readdirSync(d, { withFileTypes: true });
+      const entries = fs8.readdirSync(d, { withFileTypes: true });
       for (const e of entries) {
         const full = path5.join(d, e.name);
         if (e.isDirectory()) {
           walk(full);
         } else if (e.isFile()) {
           try {
-            bytes += fs7.statSync(full).size;
+            bytes += fs8.statSync(full).size;
             files++;
           } catch {
           }
@@ -4101,17 +4112,17 @@ async function cleanPlaywrightBrowsers(cleanUnused) {
     }
   } catch {
   }
-  if (!msPlaywrightDir || !fs7.existsSync(msPlaywrightDir)) {
+  if (!msPlaywrightDir || !fs8.existsSync(msPlaywrightDir)) {
     const defaultPlaywrightDir = process.env.PLAYWRIGHT_BROWSERS_PATH || (process.platform === "win32" ? path5.join(os3.homedir(), "AppData", "Local", "ms-playwright") : process.platform === "darwin" ? path5.join(os3.homedir(), "Library", "Caches", "ms-playwright") : path5.join(os3.homedir(), ".cache", "ms-playwright"));
-    if (fs7.existsSync(defaultPlaywrightDir)) {
+    if (fs8.existsSync(defaultPlaywrightDir)) {
       msPlaywrightDir = defaultPlaywrightDir;
     }
   }
   const unusedDirs = [];
   let freedBytes = 0;
-  if (msPlaywrightDir && fs7.existsSync(msPlaywrightDir)) {
+  if (msPlaywrightDir && fs8.existsSync(msPlaywrightDir)) {
     try {
-      const entries = fs7.readdirSync(msPlaywrightDir, { withFileTypes: true });
+      const entries = fs8.readdirSync(msPlaywrightDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const folderName = entry.name;
@@ -4134,7 +4145,7 @@ async function cleanPlaywrightBrowsers(cleanUnused) {
       if (cleanUnused && unusedDirs.length > 0) {
         for (const item of unusedDirs) {
           try {
-            fs7.rmSync(item.path, { recursive: true, force: true });
+            fs8.rmSync(item.path, { recursive: true, force: true });
             freedBytes += item.bytes;
           } catch (err) {
             console.warn(`[CleanCache] Warning: could not remove ${item.name}:`, err);
@@ -4270,7 +4281,7 @@ __export(playwright_exports, {
 });
 import { chromium as chromium2 } from "patchright";
 import path6 from "path";
-import fs8 from "fs";
+import fs9 from "fs";
 import crypto5 from "crypto";
 import { spawnSync } from "child_process";
 import { createRequire } from "module";
@@ -4284,7 +4295,7 @@ function autoInstallPlaywrightChromium() {
     try {
       const patchrightEntry = requireLocal.resolve("patchright");
       const cliPath = path6.join(path6.dirname(patchrightEntry), "cli.js");
-      if (fs8.existsSync(cliPath)) {
+      if (fs9.existsSync(cliPath)) {
         console.log("\u23F3 [Playwright] Navegador Chromium n\xE3o encontrado. Instalando automaticamente...");
         const res2 = spawnSync(process.execPath, [cliPath, "install", "chromium"], {
           stdio: "inherit",
@@ -4420,10 +4431,10 @@ function getStorageStatePath(accountId) {
 function loadStorageState(accountId) {
   const p1 = getStorageStatePath(accountId);
   const p2 = path6.join(path6.dirname(p1), `${accountId}_state.json`);
-  const chosenPath = fs8.existsSync(p1) ? p1 : fs8.existsSync(p2) ? p2 : void 0;
+  const chosenPath = fs9.existsSync(p1) ? p1 : fs9.existsSync(p2) ? p2 : void 0;
   if (!chosenPath) return void 0;
   try {
-    const raw = fs8.readFileSync(chosenPath, "utf8");
+    const raw = fs9.readFileSync(chosenPath, "utf8");
     const state = JSON.parse(raw);
     if (!state || typeof state !== "object" || !Array.isArray(state.cookies)) {
       return void 0;
@@ -4437,8 +4448,8 @@ async function saveStorageState(context, accountId, timeoutMs = 5e3) {
   try {
     const stateFile = getStorageStatePath(accountId);
     const dir = path6.dirname(stateFile);
-    if (!fs8.existsSync(dir)) {
-      fs8.mkdirSync(dir, { recursive: true });
+    if (!fs9.existsSync(dir)) {
+      fs9.mkdirSync(dir, { recursive: true });
     }
     await withTimeout(
       context.storageState({ path: stateFile }),
@@ -4547,7 +4558,7 @@ async function isPageLoggedIn(page, timeoutMs = SESSION_PROBE_NAVIGATION_TIMEOUT
     return false;
   }
 }
-async function getOrLaunchSharedBrowser(browserType = "chromium", headless = true) {
+async function getOrLaunchSharedBrowser(browserType = "chromium", headless = config.playwright.headless) {
   if (sharedBrowser && sharedBrowser.isConnected()) {
     return sharedBrowser;
   }
@@ -4607,13 +4618,40 @@ async function getOrLaunchSharedBrowser(browserType = "chromium", headless = tru
   }
 }
 async function clearVisibleChallenge(page) {
-  if (!config.captcha.enabled) return;
-  await solveBaxiaCaptcha(page, {
-    waitForMs: 0,
-    maxAttempts: config.captcha.maxAttempts,
-    retryDelayMs: config.captcha.retryDelayMs,
-    settleMs: config.captcha.settleMs
-  }).catch(() => false);
+  if (page.isClosed()) return;
+  if (config.captcha.enabled) {
+    await solveBaxiaCaptcha(page, {
+      waitForMs: 0,
+      maxAttempts: config.captcha.maxAttempts,
+      retryDelayMs: config.captcha.retryDelayMs,
+      settleMs: config.captcha.settleMs
+    }).catch(() => false);
+  }
+  try {
+    const modalCloseSelectors = [
+      ".ant-modal-close",
+      ".ant-modal-close-x",
+      "button.ant-modal-close",
+      "button[aria-label*='Close' i]",
+      "button[aria-label*='Fechar' i]",
+      ".index-module__whats-new-modal-close",
+      "button:has-text('Cancel')",
+      "button:has-text('Cancelar')",
+      "button:has-text('I understand')",
+      "button:has-text('Entendi')",
+      "button:has-text('OK')"
+    ];
+    for (const sel of modalCloseSelectors) {
+      if (page.isClosed()) return;
+      const btn = page.locator(sel).first();
+      if (await btn.isVisible({ timeout: 150 }).catch(() => false)) {
+        await btn.click({ timeout: 500 }).catch(() => {
+        });
+        await sleep2(200);
+      }
+    }
+  } catch {
+  }
 }
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5041,6 +5079,21 @@ function getStealthScript(profile) {
           spoofedFunctions.add(window.performance.getEntriesByType);
         }
       } catch(e) {}
+
+      // --- Auto-resolve birthday compliance & eliminate false logout markers ---
+      try {
+        localStorage.removeItem("qwen_token_logged_out_marker");
+        const b = localStorage.getItem("qwen_account_birthday");
+        if (b) {
+          try {
+            const parsed = JSON.parse(b);
+            if (!parsed.birthday) {
+              parsed.birthday = "1995-06-15";
+              localStorage.setItem("qwen_account_birthday", JSON.stringify(parsed));
+            }
+          } catch {}
+        }
+      } catch(e) {}
     })();
   `;
 }
@@ -5339,7 +5392,7 @@ async function resolveAccountCredentials(account) {
   }
   return account;
 }
-async function initPlaywrightForAccount(rawAccount, headless = true, browserType = "chromium", options = {}) {
+async function initPlaywrightForAccount(rawAccount, headless = config.playwright.headless, browserType = "chromium", options = {}) {
   const account = await resolveAccountCredentials(rawAccount);
   if (accountPages.has(account.id)) {
     console.log(
@@ -5465,7 +5518,7 @@ async function initPlaywrightForAccount(rawAccount, headless = true, browserType
         const storageState = loadStorageState(account.id);
         if (storageState) {
           try {
-            const raw = fs8.readFileSync(storageState, "utf8");
+            const raw = fs9.readFileSync(storageState, "utf8");
             const parsed = JSON.parse(raw);
             if (Array.isArray(parsed.cookies) && parsed.cookies.length > 0) {
               const currentCookies = await acctContext.cookies();
@@ -5552,11 +5605,19 @@ async function initPlaywrightForAccount(rawAccount, headless = true, browserType
         }
         if (restoredFromDb) {
           if (!acctPage.isClosed() && (acctPage.url() === "about:blank" || !acctPage.url().startsWith(qwenOrigin()))) {
-            void acctPage.goto(qwenUrl("/"), {
-              waitUntil: "domcontentloaded",
-              timeout: config.timeouts.navigation
-            }).catch(() => {
-            });
+            try {
+              await acctPage.goto(qwenUrl("/"), {
+                waitUntil: "domcontentloaded",
+                timeout: config.timeouts.navigation
+              });
+              await sleep2(300);
+            } catch (err) {
+              if (!err?.message?.includes("ERR_ABORTED")) {
+                console.warn(
+                  `\u26A0\uFE0F  [Playwright] Background navigation warning for ${maskEmail(account.email)}: ${err.message}`
+                );
+              }
+            }
           }
           return;
         }
@@ -5677,7 +5738,7 @@ async function validateAccountLogin(rawAccount, headless = true, browserType = "
       const storageState = loadStorageState(account.id);
       if (storageState) {
         try {
-          const raw = fs8.readFileSync(storageState, "utf8");
+          const raw = fs9.readFileSync(storageState, "utf8");
           const parsed = JSON.parse(raw);
           if (Array.isArray(parsed.cookies) && parsed.cookies.length > 0) {
             const currentCookies = await acctContext.cookies();
@@ -5796,18 +5857,34 @@ async function loginToQwen(accountId, email, password) {
     const apiResult = await loginViaApi(page, email, password);
     if (apiResult.success) {
       cookieCaches.delete(accountId);
-      const cache3 = headerCaches.get(accountId);
-      if (cache3) {
-        cache3.headers = {};
-        cache3.lastRefresh = 0;
-      }
-      unmarkAccountHeadersReady(accountId);
+      await saveStorageState(page.context(), accountId);
       try {
-        const { deleteAuthSession: deleteAuthSession2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-        deleteAuthSession2(accountId);
+        const liveCookies = await page.context().cookies();
+        const tokenCookie = liveCookies.find((c) => c.name === "token");
+        if (tokenCookie) {
+          const cookieStr = liveCookies.map((c) => `${c.name}=${c.value}`).join("; ");
+          const cache3 = getHeaderCache(accountId);
+          cache3.headers.cookie = cookieStr;
+          cache3.lastRefresh = Date.now();
+          markAccountHeadersReady(accountId);
+          const { saveAuthSession: saveAuthSession2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+          const exp = parseJwtExpiry(tokenCookie.value);
+          saveAuthSession2(accountId, {
+            cookie: cookieStr,
+            userAgent: cache3.headers["user-agent"] || "",
+            bxV: cache3.headers["bx-v"] || "2.5.37",
+            bxUa: cache3.headers["bx-ua"] || "",
+            bxUmidtoken: cache3.headers["bx-umidtoken"] || "",
+            secChUa: cache3.headers["sec-ch-ua"] || void 0,
+            secChUaMobile: cache3.headers["sec-ch-ua-mobile"] || void 0,
+            secChUaPlatform: cache3.headers["sec-ch-ua-platform"] || void 0,
+            version: cache3.headers["version"] || void 0,
+            tokenExpiresAt: exp || void 0,
+            capturedAt: Date.now()
+          });
+        }
       } catch {
       }
-      await saveStorageState(page.context(), accountId);
       return true;
     }
     if (apiResult.permanentFailure) {
@@ -5824,18 +5901,34 @@ async function loginToQwen(accountId, email, password) {
     const uiResult = await loginViaUi(page, email, password);
     if (uiResult.success) {
       cookieCaches.delete(accountId);
-      const cache3 = headerCaches.get(accountId);
-      if (cache3) {
-        cache3.headers = {};
-        cache3.lastRefresh = 0;
-      }
-      unmarkAccountHeadersReady(accountId);
+      await saveStorageState(page.context(), accountId);
       try {
-        const { deleteAuthSession: deleteAuthSession2 } = await Promise.resolve().then(() => (init_database(), database_exports));
-        deleteAuthSession2(accountId);
+        const liveCookies = await page.context().cookies();
+        const tokenCookie = liveCookies.find((c) => c.name === "token");
+        if (tokenCookie) {
+          const cookieStr = liveCookies.map((c) => `${c.name}=${c.value}`).join("; ");
+          const cache3 = getHeaderCache(accountId);
+          cache3.headers.cookie = cookieStr;
+          cache3.lastRefresh = Date.now();
+          markAccountHeadersReady(accountId);
+          const { saveAuthSession: saveAuthSession2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+          const exp = parseJwtExpiry(tokenCookie.value);
+          saveAuthSession2(accountId, {
+            cookie: cookieStr,
+            userAgent: cache3.headers["user-agent"] || "",
+            bxV: cache3.headers["bx-v"] || "2.5.37",
+            bxUa: cache3.headers["bx-ua"] || "",
+            bxUmidtoken: cache3.headers["bx-umidtoken"] || "",
+            secChUa: cache3.headers["sec-ch-ua"] || void 0,
+            secChUaMobile: cache3.headers["sec-ch-ua-mobile"] || void 0,
+            secChUaPlatform: cache3.headers["sec-ch-ua-platform"] || void 0,
+            version: cache3.headers["version"] || void 0,
+            tokenExpiresAt: exp || void 0,
+            capturedAt: Date.now()
+          });
+        }
       } catch {
       }
-      await saveStorageState(page.context(), accountId);
       return true;
     }
     if (uiResult.permanentFailure) {
@@ -6034,10 +6127,16 @@ async function loginViaUi(page, email, password) {
       );
       return { success: false, reason: "Campo de e-mail n\xE3o encontrado (poss\xEDvel captcha)" };
     }
+    await clearVisibleChallenge(page);
+    const findPasswordModeButton = () => {
+      return page.locator('button, [role="button"], a, div').filter({
+        hasText: /(?:log\s*in\s*with\s*(?:a\s*)?password|fazer\s*login\s*com\s*senha|entrar\s*com\s*(?:uma\s*)?senha|iniciar\s*sesi[oó]n\s*con\s*contrase[nñ]a|密码登录)/i
+      }).first();
+    };
     try {
-      const pwdModeBtn = page.getByText(/Log in with a password/i).first();
-      if (await pwdModeBtn.isVisible({ timeout: 1500 }).catch(() => false)) {
-        await pwdModeBtn.click().catch(() => {
+      const pwdModeBtn = findPasswordModeButton();
+      if (await pwdModeBtn.isVisible({ timeout: 2e3 }).catch(() => false)) {
+        await pwdModeBtn.click({ timeout: 2e3 }).catch(() => {
         });
         await sleep2(500);
       }
@@ -6046,9 +6145,9 @@ async function loginViaUi(page, email, password) {
     await page.fill(emailSelector, email);
     await sleep2(300);
     try {
-      const pwdModeBtn = page.getByText(/Log in with a password/i).first();
-      if (await pwdModeBtn.isVisible({ timeout: 1e3 }).catch(() => false)) {
-        await pwdModeBtn.click().catch(() => {
+      const pwdModeBtn = findPasswordModeButton();
+      if (await pwdModeBtn.isVisible({ timeout: 1500 }).catch(() => false)) {
+        await pwdModeBtn.click({ timeout: 2e3 }).catch(() => {
         });
         await sleep2(500);
       }
@@ -6073,7 +6172,7 @@ async function loginViaUi(page, email, password) {
     }
     await page.fill(passwordSelector, password);
     await sleep2(500);
-    const submitSelector = 'button.qwenchat-auth-pc-submit-button, button[type="submit"], button:has-text("Log in"), button:has-text("Sign in")';
+    const submitSelector = 'button.qwenchat-auth-pc-submit-button, button[type="submit"], button:has-text("Log in"), button:has-text("Sign in"), button:has-text("Fazer login"), button:has-text("Entrar"), button:has-text("Iniciar sesi\xF3n"), button:has-text("\u767B\u5F55")';
     const submitButton = page.locator(submitSelector).first();
     try {
       await page.waitForSelector('button[type="submit"]:not([disabled])', {
@@ -6678,7 +6777,7 @@ async function refreshHeadersInternal(accountId, timeoutMs = config.timeouts.hea
           await executeReauth();
         }
       }
-      if (reauthExecuted && hasRequiredQwenHeaders(cache3.headers)) {
+      if (hasRequiredQwenHeaders(cache3.headers)) {
         const liveCookies = await page.context().cookies();
         if (liveCookies.some((c) => c.name === "token")) {
           const cookieStr = liveCookies.map((c) => `${c.name}=${c.value}`).join("; ");
@@ -6794,12 +6893,12 @@ async function resetPlaywrightProfileLocked(accountId) {
   removePlaywrightProfile(profilePath);
   const stateFile2 = path6.join(path6.dirname(profilePath), `${accountId}_state.json`);
   try {
-    fs8.rmSync(stateFile2, { force: true });
+    fs9.rmSync(stateFile2, { force: true });
   } catch {
   }
 }
 function removePlaywrightProfile(profilePath, rmSyncOverride) {
-  const doRemove = rmSyncOverride ?? ((p, opts) => fs8.rmSync(p, opts));
+  const doRemove = rmSyncOverride ?? ((p, opts) => fs9.rmSync(p, opts));
   try {
     doRemove(profilePath, { recursive: true, force: true });
   } catch (error) {
@@ -6808,7 +6907,7 @@ function removePlaywrightProfile(profilePath, rmSyncOverride) {
     if (message.includes("EPERM") || message.includes("EBUSY") || message.includes("Permission denied")) {
       try {
         const stalePath = `${profilePath}.stale-${Date.now()}`;
-        fs8.renameSync(profilePath, stalePath);
+        fs9.renameSync(profilePath, stalePath);
       } catch {
       }
       return;
@@ -6831,23 +6930,23 @@ function prunePlaywrightProfileCaches(profilePath) {
   let freedFiles = 0;
   try {
     const defaultDir = path6.join(profilePath, "Default");
-    if (!fs8.existsSync(defaultDir)) {
+    if (!fs9.existsSync(defaultDir)) {
       return { freedBytes, freedFiles };
     }
     for (const dirName of transientDirNames) {
       const targetDir = path6.join(defaultDir, dirName);
-      if (fs8.existsSync(targetDir)) {
+      if (fs9.existsSync(targetDir)) {
         try {
           const countAndRemove = (d) => {
             try {
-              const entries = fs8.readdirSync(d, { withFileTypes: true });
+              const entries = fs9.readdirSync(d, { withFileTypes: true });
               for (const e of entries) {
                 const full = path6.join(d, e.name);
                 if (e.isDirectory()) {
                   countAndRemove(full);
                 } else if (e.isFile()) {
                   try {
-                    freedBytes += fs8.statSync(full).size;
+                    freedBytes += fs9.statSync(full).size;
                     freedFiles++;
                   } catch {
                   }
@@ -6857,7 +6956,7 @@ function prunePlaywrightProfileCaches(profilePath) {
             }
           };
           countAndRemove(targetDir);
-          fs8.rmSync(targetDir, { recursive: true, force: true });
+          fs9.rmSync(targetDir, { recursive: true, force: true });
         } catch {
         }
       }
@@ -6871,10 +6970,10 @@ function pruneAllPlaywrightProfiles(baseDir = getProfilesDir()) {
   let totalFreedFiles = 0;
   let profilesCleaned = 0;
   try {
-    if (!fs8.existsSync(baseDir)) {
+    if (!fs9.existsSync(baseDir)) {
       return { totalFreedBytes, totalFreedFiles, profilesCleaned };
     }
-    const entries = fs8.readdirSync(baseDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const profilePath = path6.join(baseDir, entry.name);
@@ -6894,11 +6993,11 @@ function cleanupOrphanProfiles(baseDir = getProfilesDir(), activeAccountIds) {
   let removedCount = 0;
   let freedBytes = 0;
   try {
-    if (!fs8.existsSync(baseDir)) {
+    if (!fs9.existsSync(baseDir)) {
       return { removedCount, freedBytes };
     }
     const activeIds = activeAccountIds ?? new Set(loadAccounts().map((a) => a.id));
-    const entries = fs8.readdirSync(baseDir, { withFileTypes: true });
+    const entries = fs9.readdirSync(baseDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const isStale = entry.name.includes(".stale-");
@@ -6909,13 +7008,13 @@ function cleanupOrphanProfiles(baseDir = getProfilesDir(), activeAccountIds) {
           let bytes = 0;
           const countSize = (d) => {
             try {
-              const subEntries = fs8.readdirSync(d, { withFileTypes: true });
+              const subEntries = fs9.readdirSync(d, { withFileTypes: true });
               for (const e of subEntries) {
                 const full = path6.join(d, e.name);
                 if (e.isDirectory()) countSize(full);
                 else if (e.isFile()) {
                   try {
-                    bytes += fs8.statSync(full).size;
+                    bytes += fs9.statSync(full).size;
                   } catch {
                   }
                 }
@@ -6925,7 +7024,7 @@ function cleanupOrphanProfiles(baseDir = getProfilesDir(), activeAccountIds) {
           };
           countSize(targetPath);
           removePlaywrightProfile(targetPath);
-          if (!fs8.existsSync(targetPath)) {
+          if (!fs9.existsSync(targetPath)) {
             removedCount++;
             freedBytes += bytes;
           }
@@ -11083,10 +11182,17 @@ async function withQwenBrowserPage(accountId, fn, targetPath, operationTimeoutMs
       }
       const needsNavigation = currentOrigin !== targetOrigin || normalizedTargetPath !== null && currentPath !== normalizedTargetPath;
       if (needsNavigation) {
-        await page.goto(targetUrl, {
-          waitUntil: "domcontentloaded",
-          timeout: Math.min(config.timeouts.navigation, operationTimeoutMs)
-        });
+        try {
+          await page.goto(targetUrl, {
+            waitUntil: "domcontentloaded",
+            timeout: Math.min(config.timeouts.navigation, operationTimeoutMs)
+          });
+        } catch (err) {
+          if (err?.message?.includes("ERR_ABORTED") && page.url().startsWith(targetOrigin)) {
+          } else {
+            throw err;
+          }
+        }
       }
       return fn(page);
     },
@@ -11138,7 +11244,7 @@ async function requestQwenTextInBrowser(accountId, method, path21, headers, body
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
       try {
-        const response2 = await fetch(url2, {
+        let response2 = await fetch(url2, {
           method: method2,
           credentials: "include",
           headers: headers2,
@@ -11146,6 +11252,36 @@ async function requestQwenTextInBrowser(accountId, method, path21, headers, body
           signal: controller.signal,
           ...referrer ? { referrer } : {}
         });
+        if (response2.status === 401) {
+          try {
+            const refreshRes = await fetch("https://auth.qwen.ai/api/v2/auths/refresh", {
+              method: "GET",
+              credentials: "include",
+              signal: AbortSignal.timeout(3e3)
+            });
+            if (refreshRes.status === 200) {
+              const refreshJson = await refreshRes.json().catch(() => null);
+              if (refreshJson && refreshJson.success === true && refreshJson.data?.token) {
+                const freshTok = refreshJson.data.token;
+                localStorage.setItem("token", freshTok);
+                document.cookie = `token=${encodeURIComponent(freshTok)}; path=/; domain=.qwen.ai; max-age=31536000`;
+                if (headers2["authorization"] || headers2["Authorization"]) {
+                  headers2["authorization"] = `Bearer ${freshTok}`;
+                  headers2["Authorization"] = `Bearer ${freshTok}`;
+                }
+                response2 = await fetch(url2, {
+                  method: method2,
+                  credentials: "include",
+                  headers: headers2,
+                  body: body2,
+                  signal: controller.signal,
+                  ...referrer ? { referrer } : {}
+                });
+              }
+            }
+          } catch {
+          }
+        }
         return {
           status: response2.status,
           contentType: response2.headers.get("content-type") || "",
@@ -11247,18 +11383,6 @@ async function requestQwenSettingsDirectFetch(accountId, method, path21, headers
   }
 }
 async function requestQwenPersonalizationInBrowser(accountId, method, path21, headers, payload) {
-  if (!config.qwen.browserOnlyFetch && !isAuthMockEnabled()) {
-    const direct = await requestQwenSettingsDirectFetch(
-      accountId,
-      method,
-      path21,
-      headers,
-      payload
-    );
-    if (direct) {
-      return direct;
-    }
-  }
   const response = await requestQwenTextInBrowser(
     accountId,
     method,
@@ -21907,6 +22031,7 @@ async function chatCompletions(c) {
     )) {
       c.header(name, value);
     }
+    c.header("X-QwenProxy-Account", streamResult.activeAccountLabel);
     const replayed = streamResult.replayedFullContext === true;
     console.log(
       `\u{1F4E4} [${routeLabel}] Request | req=${reqId} | ${streamResult.activeAccountLabel} | ${body.model} | ${replayed ? parsed.messageCount : msgCount} msg(s) | ${replayed ? fullPromptForRequest.length : finalPrompt.length} chars${replayed ? " | full-replay" : ""} | chat=${streamResult.uiSessionId.substring(0, 12)}${declaredTools.length ? ` | ${declaredTools.length} tool(s)` : ""}${files.length ? ` | ${files.length} file(s)` : ""} | +${Date.now() - reqStartedAt}ms`
@@ -25160,18 +25285,18 @@ var init_theme = __esm({
 });
 
 // src/core/server-log-buffer.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 function appendServerLogToFile(time, level, message) {
   if (isRunningUnderNodeTest()) return;
   try {
     const filePath = getServerLogFilePath();
-    if (fs9.existsSync(filePath)) {
-      const stats = fs9.statSync(filePath);
+    if (fs10.existsSync(filePath)) {
+      const stats = fs10.statSync(filePath);
       if (stats.size > 20 * 1024 * 1024) {
         const oldPath = filePath + ".old";
         try {
-          if (fs9.existsSync(oldPath)) fs9.unlinkSync(oldPath);
-          fs9.renameSync(filePath, oldPath);
+          if (fs10.existsSync(oldPath)) fs10.unlinkSync(oldPath);
+          fs10.renameSync(filePath, oldPath);
         } catch {
         }
       }
@@ -25181,7 +25306,7 @@ function appendServerLogToFile(time, level, message) {
     const dateStr = (/* @__PURE__ */ new Date()).toLocaleDateString("pt-BR");
     const line = `[${dateStr} ${time}] [${level}] ${message}
 `;
-    fs9.appendFileSync(filePath, line, "utf-8");
+    fs10.appendFileSync(filePath, line, "utf-8");
   } catch {
   }
 }
@@ -25356,7 +25481,7 @@ var version_exports = {};
 __export(version_exports, {
   getAppVersion: () => getAppVersion
 });
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 function getAppVersion() {
@@ -25364,8 +25489,8 @@ function getAppVersion() {
   try {
     const currentDir = path7.dirname(fileURLToPath(import.meta.url));
     const pkgPath = path7.resolve(currentDir, "../../package.json");
-    if (fs10.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
+    if (fs11.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs11.readFileSync(pkgPath, "utf-8"));
       if (pkg.version) {
         cachedVersion = `v${pkg.version}`;
         return cachedVersion;
@@ -25373,7 +25498,7 @@ function getAppVersion() {
     }
   } catch {
   }
-  cachedVersion = "v1.4.0";
+  cachedVersion = "v1.4.2";
   return cachedVersion;
 }
 var cachedVersion;
@@ -26486,7 +26611,7 @@ var init_server_manager = __esm({
 
 // src/tui/screen.ts
 import readline from "node:readline";
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 var Screen;
 var init_screen = __esm({
   "src/tui/screen.ts"() {
@@ -26706,7 +26831,7 @@ var init_screen = __esm({
         this.lastHoverTime = 0;
         const restoreSeq = ANSI.disableMouse + ANSI.exitAltScreen + ANSI.showCursor + ANSI.reset;
         try {
-          fs11.writeSync(1, restoreSeq);
+          fs12.writeSync(1, restoreSeq);
         } catch {
           try {
             ServerManager.getInstance().withTuiRendering(() => {
@@ -29151,7 +29276,7 @@ var init_chat_view = __esm({
 });
 
 // src/sync/utils.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import path8 from "node:path";
 function createTimestampBackup(filePath) {
   const dir = path8.dirname(filePath);
@@ -29161,19 +29286,19 @@ function createTimestampBackup(filePath) {
   const pad2 = (n) => String(n).padStart(2, "0");
   const timestamp = `${now.getFullYear()}${pad2(now.getMonth() + 1)}${pad2(now.getDate())}_${pad2(now.getHours())}${pad2(now.getMinutes())}${pad2(now.getSeconds())}`;
   const backupPath = path8.join(dir, `${base}.qwenproxy.${timestamp}${ext}.bak`);
-  fs12.copyFileSync(filePath, backupPath);
+  fs13.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 function findLatestBackup(filePath) {
   const dir = path8.dirname(filePath);
   const ext = path8.extname(filePath);
   const base = path8.basename(filePath, ext);
-  if (!fs12.existsSync(dir)) return void 0;
+  if (!fs13.existsSync(dir)) return void 0;
   try {
-    const files = fs12.readdirSync(dir);
+    const files = fs13.readdirSync(dir);
     const candidates = files.filter((f) => f.startsWith(base) && f.includes("qwenproxy") && f.endsWith(".bak")).map((f) => path8.join(dir, f)).sort((a, b) => {
       try {
-        return fs12.statSync(b).mtimeMs - fs12.statSync(a).mtimeMs;
+        return fs13.statSync(b).mtimeMs - fs13.statSync(a).mtimeMs;
       } catch {
         return 0;
       }
@@ -29184,13 +29309,13 @@ function findLatestBackup(filePath) {
   }
 }
 function restoreFromBackup(filePath, backupPath) {
-  const targetBackup = backupPath && fs12.existsSync(backupPath) ? backupPath : findLatestBackup(filePath);
-  if (!targetBackup || !fs12.existsSync(targetBackup)) {
+  const targetBackup = backupPath && fs13.existsSync(backupPath) ? backupPath : findLatestBackup(filePath);
+  if (!targetBackup || !fs13.existsSync(targetBackup)) {
     return false;
   }
-  fs12.copyFileSync(targetBackup, filePath);
+  fs13.copyFileSync(targetBackup, filePath);
   try {
-    fs12.unlinkSync(targetBackup);
+    fs13.unlinkSync(targetBackup);
   } catch {
   }
   return true;
@@ -29209,18 +29334,18 @@ var init_utils = __esm({
 });
 
 // src/sync/claude-code.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import path9 from "node:path";
 function syncClaudeCode(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max" } = options;
   try {
-    fs13.mkdirSync(path9.dirname(filePath), { recursive: true });
+    fs14.mkdirSync(path9.dirname(filePath), { recursive: true });
     let backupPath;
     let existingSettings = {};
-    if (fs13.existsSync(filePath)) {
+    if (fs14.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
       try {
-        const content = fs13.readFileSync(filePath, "utf-8");
+        const content = fs14.readFileSync(filePath, "utf-8");
         existingSettings = JSON.parse(content);
       } catch {
         existingSettings = {};
@@ -29246,7 +29371,7 @@ function syncClaudeCode(options) {
       model,
       enableArtifact: false
     };
-    fs13.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+    fs14.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
     return {
       client: "claude-code",
       filePath,
@@ -29268,9 +29393,9 @@ function syncClaudeCode(options) {
 function restoreClaudeCode(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs13.existsSync(filePath)) {
+  if (fs14.existsSync(filePath)) {
     try {
-      const data = JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+      const data = JSON.parse(fs14.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;
@@ -29290,7 +29415,7 @@ function restoreClaudeCode(filePath, backupPath) {
         if (Object.keys(data.env).length === 0) {
           delete data.env;
         }
-        fs13.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        fs14.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
         manuallyCleaned = true;
       }
     } catch {
@@ -29314,7 +29439,7 @@ var init_claude_code = __esm({
 });
 
 // src/sync/codex.ts
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 import path10 from "node:path";
 import os4 from "node:os";
 function removeTomlSection(content, sectionHeader) {
@@ -29355,12 +29480,12 @@ function updateTopLevelKey(content, key, value) {
   return newTopPart + restPart;
 }
 function syncCodexSingleFile(targetPath, options) {
-  fs14.mkdirSync(path10.dirname(targetPath), { recursive: true });
+  fs15.mkdirSync(path10.dirname(targetPath), { recursive: true });
   let backupPath;
   let content = "";
-  if (fs14.existsSync(targetPath)) {
+  if (fs15.existsSync(targetPath)) {
     backupPath = createTimestampBackup(targetPath);
-    content = fs14.readFileSync(targetPath, "utf-8");
+    content = fs15.readFileSync(targetPath, "utf-8");
   }
   const { apiKey, baseUrl, model = "qwen3.8-max", setActive = true } = options;
   const providerBlock = `[model_providers.qwenproxy]
@@ -29381,8 +29506,8 @@ experimental_bearer_token = "${apiKey}"
     try {
       const rawCatalogPath = catalogMatch[1];
       const catalogPath = path10.isAbsolute(rawCatalogPath) ? rawCatalogPath : path10.resolve(path10.dirname(targetPath), rawCatalogPath);
-      if (fs14.existsSync(catalogPath)) {
-        const catalog = JSON.parse(fs14.readFileSync(catalogPath, "utf-8"));
+      if (fs15.existsSync(catalogPath)) {
+        const catalog = JSON.parse(fs15.readFileSync(catalogPath, "utf-8"));
         if (Array.isArray(catalog.models)) {
           const hasModel = catalog.models.some((m) => m?.slug === model);
           if (!hasModel) {
@@ -29395,14 +29520,14 @@ experimental_bearer_token = "${apiKey}"
               context_window: 1e6,
               max_context_window: 1e6
             });
-            fs14.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
+            fs15.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
           }
         }
       }
     } catch {
     }
   }
-  fs14.writeFileSync(targetPath, content.trimEnd() + "\n", "utf-8");
+  fs15.writeFileSync(targetPath, content.trimEnd() + "\n", "utf-8");
   return { backupPath };
 }
 function syncCodex(options) {
@@ -29418,7 +29543,7 @@ function syncCodex(options) {
       const alternatePath = isStandard ? codexHomePath : standardPath;
       if (alternatePath && path10.resolve(alternatePath).toLowerCase() !== path10.resolve(filePath).toLowerCase()) {
         try {
-          if (fs14.existsSync(alternatePath) || fs14.existsSync(path10.dirname(alternatePath))) {
+          if (fs15.existsSync(alternatePath) || fs15.existsSync(path10.dirname(alternatePath))) {
             syncCodexSingleFile(alternatePath, options);
           }
         } catch {
@@ -29447,16 +29572,16 @@ function restoreCodex(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
   const cleanSingleFile = (p) => {
-    if (fs14.existsSync(p)) {
+    if (fs15.existsSync(p)) {
       try {
-        let content = fs14.readFileSync(p, "utf-8");
+        let content = fs15.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, "");
           }
-          fs14.writeFileSync(p, content.trimEnd() + "\n", "utf-8");
+          fs15.writeFileSync(p, content.trimEnd() + "\n", "utf-8");
           manuallyCleaned = true;
         }
       } catch {
@@ -29494,7 +29619,7 @@ var init_codex = __esm({
 });
 
 // src/sync/opencode.ts
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import path11 from "node:path";
 function buildOpenCodeProviderObject(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
   const modelsObj = {};
@@ -29620,12 +29745,12 @@ function syncOpenCode(options) {
     setActive = true
   } = options;
   try {
-    fs15.mkdirSync(path11.dirname(filePath), { recursive: true });
+    fs16.mkdirSync(path11.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs15.existsSync(filePath)) {
+    if (fs16.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs15.readFileSync(filePath, "utf-8");
+      content = fs16.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");
@@ -29640,7 +29765,7 @@ function syncOpenCode(options) {
       initial.provider = {
         qwenproxy: providerObj
       };
-      fs15.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+      fs16.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
     } else {
       const existingSpan = findKeyObjectSpan(content, "qwenproxy");
       if (existingSpan) {
@@ -29664,7 +29789,7 @@ ${qwenEntry}
           }
         }
       }
-      fs15.writeFileSync(
+      fs16.writeFileSync(
         filePath,
         applyOpenCodeActiveModel(content, model, setActive),
         "utf-8"
@@ -29691,9 +29816,9 @@ ${qwenEntry}
 function restoreOpenCode(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs15.existsSync(filePath)) {
+  if (fs16.existsSync(filePath)) {
     try {
-      const data = JSON.parse(fs15.readFileSync(filePath, "utf-8"));
+      const data = JSON.parse(fs16.readFileSync(filePath, "utf-8"));
       if (data.provider && data.provider.qwenproxy) {
         delete data.provider.qwenproxy;
         if (data.model && data.model.includes("qwen")) {
@@ -29702,7 +29827,7 @@ function restoreOpenCode(filePath, backupPath) {
         if (Object.keys(data.provider).length === 0) {
           delete data.provider;
         }
-        fs15.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        fs16.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
         manuallyCleaned = true;
       }
     } catch {
@@ -29726,7 +29851,7 @@ var init_opencode = __esm({
 });
 
 // src/sync/omp.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import path12 from "node:path";
 function buildOmpProviderYaml(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
   const modelList = Array.from(
@@ -29758,12 +29883,12 @@ ${formattedModels}
 function syncOmp(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models } = options;
   try {
-    fs16.mkdirSync(path12.dirname(filePath), { recursive: true });
+    fs17.mkdirSync(path12.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs16.existsSync(filePath)) {
+    if (fs17.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs16.readFileSync(filePath, "utf-8");
+      content = fs17.readFileSync(filePath, "utf-8");
     }
     const providerBlock = buildOmpProviderYaml(baseUrl, apiKey, model, models);
     if (!content.trim()) {
@@ -29783,7 +29908,7 @@ ${providerBlock}`;
         }
       }
     }
-    fs16.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+    fs17.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
     return {
       client: "omp",
       filePath,
@@ -29805,13 +29930,13 @@ ${providerBlock}`;
 function restoreOmp(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs16.existsSync(filePath)) {
+  if (fs17.existsSync(filePath)) {
     try {
-      let content = fs16.readFileSync(filePath, "utf-8");
+      let content = fs17.readFileSync(filePath, "utf-8");
       if (content.includes("qwenproxy:")) {
         const regex = /^\s*qwenproxy:\s*\r?\n(?:^[ \t].*\r?\n?)*/m;
         content = content.replace(regex, "");
-        fs16.writeFileSync(filePath, content, "utf-8");
+        fs17.writeFileSync(filePath, content, "utf-8");
         manuallyCleaned = true;
       }
     } catch {
@@ -29835,7 +29960,7 @@ var init_omp = __esm({
 });
 
 // src/sync/hermes.ts
-import fs17 from "node:fs";
+import fs18 from "node:fs";
 import path13 from "node:path";
 function buildHermesModelBlock(baseUrl, apiKey, model = "qwen3.8-max", reasoningEffort = "high") {
   return `model:
@@ -29859,12 +29984,12 @@ function buildHermesProviderBlock(baseUrl, apiKey) {
 function syncHermes(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = options;
   try {
-    fs17.mkdirSync(path13.dirname(filePath), { recursive: true });
+    fs18.mkdirSync(path13.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs17.existsSync(filePath)) {
+    if (fs18.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs17.readFileSync(filePath, "utf-8");
+      content = fs18.readFileSync(filePath, "utf-8");
     }
     const modelBlock = buildHermesModelBlock(baseUrl, apiKey, model, reasoningEffort);
     const providerBlock = buildHermesProviderBlock(baseUrl, apiKey);
@@ -29890,7 +30015,7 @@ function syncHermes(options) {
         }
       }
     }
-    fs17.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+    fs18.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
     return {
       client: "hermes",
       filePath,
@@ -29928,7 +30053,7 @@ var init_hermes = __esm({
 });
 
 // src/sync/openclaw.ts
-import fs18 from "node:fs";
+import fs19 from "node:fs";
 import path14 from "node:path";
 function findKeyObjectSpan2(content, key) {
   const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
@@ -30027,12 +30152,12 @@ function buildOpenClawProviderObject(baseUrl, apiKey, model = "qwen3.8-max", mod
 function syncOpenClaw(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models, reasoningEffort = "high" } = options;
   try {
-    fs18.mkdirSync(path14.dirname(filePath), { recursive: true });
+    fs19.mkdirSync(path14.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs18.existsSync(filePath)) {
+    if (fs19.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs18.readFileSync(filePath, "utf-8");
+      content = fs19.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");
@@ -30056,7 +30181,7 @@ function syncOpenClaw(options) {
           }
         }
       };
-      fs18.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+      fs19.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
     } else {
       const existingSpan = findKeyObjectSpan2(content, "qwenproxy");
       if (existingSpan) {
@@ -30093,7 +30218,7 @@ ${qwenEntry}
           }
         }
       }
-      fs18.writeFileSync(filePath, content, "utf-8");
+      fs19.writeFileSync(filePath, content, "utf-8");
     }
     return {
       client: "openclaw",
@@ -30132,7 +30257,7 @@ var init_openclaw = __esm({
 });
 
 // src/sync/kilo.ts
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 import path15 from "node:path";
 function findKeyObjectSpan3(content, key) {
   const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
@@ -30239,12 +30364,12 @@ function buildKiloProviderObject(baseUrl, apiKey, primaryModel = "qwen3.8-max",
 function syncKilo(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models, setActive = true } = options;
   try {
-    fs19.mkdirSync(path15.dirname(filePath), { recursive: true });
+    fs20.mkdirSync(path15.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs19.existsSync(filePath)) {
+    if (fs20.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs19.readFileSync(filePath, "utf-8");
+      content = fs20.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");
@@ -30259,7 +30384,7 @@ function syncKilo(options) {
       if (setActive) {
         initial.model = `qwenproxy/${model}`;
       }
-      fs19.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+      fs20.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
     } else {
       const existingSpan = findKeyObjectSpan3(content, "qwenproxy");
       if (existingSpan) {
@@ -30289,7 +30414,7 @@ ${qwenEntry}
           content = content.replace(modelRegex, `"model": "qwenproxy/${model}"`);
         }
       }
-      fs19.writeFileSync(filePath, content, "utf-8");
+      fs20.writeFileSync(filePath, content, "utf-8");
     }
     return {
       client: "kilo",
@@ -30328,15 +30453,15 @@ var init_kilo = __esm({
 });
 
 // src/sync/cline.ts
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import path16 from "node:path";
 import Database2 from "better-sqlite3";
 function syncCline(options) {
   const { filePath, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = options;
   try {
-    fs20.mkdirSync(path16.dirname(filePath), { recursive: true });
+    fs21.mkdirSync(path16.dirname(filePath), { recursive: true });
     let backupPath;
-    if (fs20.existsSync(filePath)) {
+    if (fs21.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
     }
     const db2 = new Database2(filePath);
@@ -30408,7 +30533,7 @@ function syncCline(options) {
 function restoreCline(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs20.existsSync(filePath)) {
+  if (fs21.existsSync(filePath)) {
     try {
       const db2 = new Database2(filePath);
       const rows = db2.prepare("SELECT key, value FROM ItemTable WHERE key = 'saoudrizwan.claude-dev' OR key = 'ZooCodeOrganization.zoo-code'").all();
@@ -30453,7 +30578,7 @@ var init_cline = __esm({
 });
 
 // src/sync/zed.ts
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 import path17 from "node:path";
 function parseJsonWithComments(raw) {
   let result = "";
@@ -30567,13 +30692,13 @@ function buildZedAvailableModels(primaryModel = "qwen3.8-max", models) {
 function syncZed(options) {
   const { filePath, baseUrl, model = "qwen3.8-max", models, setActive = true } = options;
   try {
-    fs21.mkdirSync(path17.dirname(filePath), { recursive: true });
+    fs22.mkdirSync(path17.dirname(filePath), { recursive: true });
     let backupPath;
     let existingSettings = {};
-    if (fs21.existsSync(filePath)) {
+    if (fs22.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
       try {
-        const content = fs21.readFileSync(filePath, "utf-8");
+        const content = fs22.readFileSync(filePath, "utf-8");
         existingSettings = parseJsonWithComments(content);
       } catch {
         existingSettings = {};
@@ -30603,7 +30728,7 @@ function syncZed(options) {
         }
       };
     }
-    fs21.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+    fs22.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
     return {
       client: "zed",
       filePath,
@@ -30625,9 +30750,9 @@ function syncZed(options) {
 function restoreZed(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs21.existsSync(filePath)) {
+  if (fs22.existsSync(filePath)) {
     try {
-      let content = fs21.readFileSync(filePath, "utf-8");
+      let content = fs22.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")) {
@@ -30635,7 +30760,7 @@ function restoreZed(filePath, backupPath) {
           if (Object.keys(data.language_models).length === 0) {
             delete data.language_models;
           }
-          fs21.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+          fs22.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
           manuallyCleaned = true;
         }
       }
@@ -30660,7 +30785,7 @@ var init_zed = __esm({
 });
 
 // src/sync/aider.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import path18 from "node:path";
 function updateYamlKeyValue(content, key, value) {
   const regex = new RegExp(`^${key}:.*$`, "m");
@@ -30680,12 +30805,12 @@ function syncAider(options) {
     modelSettingsPath
   } = options;
   try {
-    fs22.mkdirSync(path18.dirname(filePath), { recursive: true });
+    fs23.mkdirSync(path18.dirname(filePath), { recursive: true });
     let backupPath;
     let confContent = "";
-    if (fs22.existsSync(filePath)) {
+    if (fs23.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      confContent = fs22.readFileSync(filePath, "utf-8");
+      confContent = fs23.readFileSync(filePath, "utf-8");
     }
     const fullModelName = model.startsWith("openai/") ? model : `openai/${model}`;
     const weakModelName = "openai/qwen3.7-plus";
@@ -30694,15 +30819,15 @@ function syncAider(options) {
     confContent = updateYamlKeyValue(confContent, "model", fullModelName);
     confContent = updateYamlKeyValue(confContent, "editor-model", fullModelName);
     confContent = updateYamlKeyValue(confContent, "weak-model", weakModelName);
-    fs22.writeFileSync(filePath, confContent.trimEnd() + "\n", "utf-8");
+    fs23.writeFileSync(filePath, confContent.trimEnd() + "\n", "utf-8");
     let extraBackupPath;
     const resolvedSettingsPath = modelSettingsPath || path18.join(path18.dirname(filePath), ".aider.model.settings.yml");
     if (resolvedSettingsPath) {
-      fs22.mkdirSync(path18.dirname(resolvedSettingsPath), { recursive: true });
+      fs23.mkdirSync(path18.dirname(resolvedSettingsPath), { recursive: true });
       let settingsContent = "";
-      if (fs22.existsSync(resolvedSettingsPath)) {
+      if (fs23.existsSync(resolvedSettingsPath)) {
         extraBackupPath = createTimestampBackup(resolvedSettingsPath);
-        settingsContent = fs22.readFileSync(resolvedSettingsPath, "utf-8");
+        settingsContent = fs23.readFileSync(resolvedSettingsPath, "utf-8");
       }
       const modelBlock = `- name: ${fullModelName}
   extra_params:
@@ -30716,7 +30841,7 @@ function syncAider(options) {
       } else {
         settingsContent = settingsContent.trimEnd() + (settingsContent.length > 0 ? "\n\n" : "") + modelBlock;
       }
-      fs22.writeFileSync(resolvedSettingsPath, settingsContent.trimEnd() + "\n", "utf-8");
+      fs23.writeFileSync(resolvedSettingsPath, settingsContent.trimEnd() + "\n", "utf-8");
     }
     return {
       client: "aider",
@@ -30761,7 +30886,7 @@ var init_aider = __esm({
 
 // src/sync/index.ts
 import "dotenv/config";
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 import path19 from "node:path";
 import os5 from "node:os";
 import Database3 from "better-sqlite3";
@@ -30801,14 +30926,14 @@ function getDefaultPaths() {
     path19.join(home, ".opencode", "opencode.jsonc"),
     path19.join(home, ".opencode", "opencode.json")
   ];
-  const existingOpenCode = openCodeCandidates.find((p) => fs23.existsSync(p));
+  const existingOpenCode = openCodeCandidates.find((p) => fs24.existsSync(p));
   const kiloCandidates = [
     path19.join(home, ".config", "kilo", "kilo.json"),
     path19.join(home, ".kilo", "kilo.json"),
     path19.join(home, ".config", "kilo", "config.json"),
     path19.join(home, ".kilo", "config.json")
   ];
-  const existingKilo = kiloCandidates.find((p) => fs23.existsSync(p));
+  const existingKilo = kiloCandidates.find((p) => fs24.existsSync(p));
   let clinePath;
   if (isWindows) {
     clinePath = path19.join(appData, "Code", "User", "globalStorage", "state.vscdb");
@@ -30825,7 +30950,7 @@ function getDefaultPaths() {
   }
   return {
     claudeCode: path19.join(home, ".claude", "settings.json"),
-    codex: fs23.existsSync(path19.join(home, ".codex", "config.toml")) ? path19.join(home, ".codex", "config.toml") : process.env.CODEX_HOME ? path19.join(process.env.CODEX_HOME, "config.toml") : path19.join(home, ".codex", "config.toml"),
+    codex: fs24.existsSync(path19.join(home, ".codex", "config.toml")) ? path19.join(home, ".codex", "config.toml") : process.env.CODEX_HOME ? path19.join(process.env.CODEX_HOME, "config.toml") : path19.join(home, ".codex", "config.toml"),
     openCode: existingOpenCode || openCodeCandidates[0],
     omp: path19.join(home, ".omp", "agent", "models.yml"),
     hermes: path19.join(home, ".hermes", "config.yaml"),
@@ -30847,7 +30972,7 @@ function isExecutableInPath(name) {
     for (const ext of extensions) {
       const fullPath = path19.join(dir, name + ext);
       try {
-        if (fs23.existsSync(fullPath) && !fs23.statSync(fullPath).isDirectory()) {
+        if (fs24.existsSync(fullPath) && !fs24.statSync(fullPath).isDirectory()) {
           return true;
         }
       } catch {
@@ -30865,9 +30990,9 @@ function isVscodeExtensionInstalled(pattern) {
     path19.join(home, ".windsurf", "extensions")
   ];
   for (const d of candidateDirs) {
-    if (fs23.existsSync(d)) {
+    if (fs24.existsSync(d)) {
       try {
-        const entries = fs23.readdirSync(d);
+        const entries = fs24.readdirSync(d);
         if (entries.some((e) => pattern.test(e))) return true;
       } catch {
       }
@@ -30879,9 +31004,9 @@ function isZedInstalled() {
   if (isExecutableInPath("zed")) return true;
   if (process.platform === "win32") {
     const local = process.env.LOCALAPPDATA || "";
-    if (fs23.existsSync(path19.join(local, "Programs", "Zed"))) return true;
+    if (fs24.existsSync(path19.join(local, "Programs", "Zed"))) return true;
   } else if (process.platform === "darwin") {
-    if (fs23.existsSync("/Applications/Zed.app")) return true;
+    if (fs24.existsSync("/Applications/Zed.app")) return true;
   }
   return false;
 }
@@ -30894,7 +31019,7 @@ function isMatchingLocalHost(text, port = 7936) {
 }
 function isClientToolInstalled(id, targetPath, isCustomTestPath = false) {
   if (isCustomTestPath) {
-    return fs23.existsSync(targetPath);
+    return fs24.existsSync(targetPath);
   }
   switch (id) {
     case "hermes":
@@ -30910,15 +31035,15 @@ function isClientToolInstalled(id, targetPath, isCustomTestPath = false) {
     case "zed":
       return isZedInstalled();
     case "claude-code":
-      return isExecutableInPath("claude") || fs23.existsSync(targetPath);
+      return isExecutableInPath("claude") || fs24.existsSync(targetPath);
     case "codex":
-      return isExecutableInPath("codex") || fs23.existsSync(targetPath);
+      return isExecutableInPath("codex") || fs24.existsSync(targetPath);
     case "opencode":
-      return isExecutableInPath("opencode") || fs23.existsSync(targetPath);
+      return isExecutableInPath("opencode") || fs24.existsSync(targetPath);
     case "omp":
-      return isExecutableInPath("omp") || fs23.existsSync(targetPath);
+      return isExecutableInPath("omp") || fs24.existsSync(targetPath);
     default:
-      return fs23.existsSync(targetPath);
+      return fs24.existsSync(targetPath);
   }
 }
 function inspectClientSyncStatus(id, filePath, port = 7936) {
@@ -30928,7 +31053,7 @@ function inspectClientSyncStatus(id, filePath, port = 7936) {
     filePath && defaultTarget && path19.resolve(filePath) !== path19.resolve(defaultTarget)
   );
   const targetPath = filePath || defaultTarget;
-  if (!fs23.existsSync(targetPath)) {
+  if (!fs24.existsSync(targetPath)) {
     return { id, installed: false, synced: false };
   }
   const toolInstalled = isClientToolInstalled(id, targetPath, isCustomTestPath);
@@ -30958,7 +31083,7 @@ function inspectClientSyncStatus(id, filePath, port = 7936) {
       const isInstalled = isCustomTestPath ? true : rowExists || isExecutableInPath("cline") || isVscodeExtensionInstalled(/cline|zoo-code|roo-cline/i);
       return { id, installed: isInstalled, synced: isInstalled && isSynced, model };
     }
-    const raw = fs23.readFileSync(targetPath, "utf-8");
+    const raw = fs24.readFileSync(targetPath, "utf-8");
     if (id === "claude-code") {
       const data = JSON.parse(raw);
       const url = data?.env?.ANTHROPIC_BASE_URL || "";
@@ -31084,7 +31209,7 @@ function syncAllClients(options = {}) {
     return options.targets.includes(client);
   };
   if (shouldSync("claude-code")) {
-    const claudeExisted = fs23.existsSync(paths.claudeCode);
+    const claudeExisted = fs24.existsSync(paths.claudeCode);
     const claudeRes = syncClaudeCode({
       filePath: paths.claudeCode,
       apiKey,
@@ -31102,7 +31227,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("codex")) {
-    const codexExisted = fs23.existsSync(paths.codex);
+    const codexExisted = fs24.existsSync(paths.codex);
     const codexRes = syncCodex({
       filePath: paths.codex,
       apiKey,
@@ -31121,7 +31246,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("opencode")) {
-    const openCodeExisted = fs23.existsSync(paths.openCode);
+    const openCodeExisted = fs24.existsSync(paths.openCode);
     const openCodeRes = syncOpenCode({
       filePath: paths.openCode,
       apiKey,
@@ -31141,7 +31266,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("omp")) {
-    const ompExisted = fs23.existsSync(paths.omp);
+    const ompExisted = fs24.existsSync(paths.omp);
     const ompRes = syncOmp({
       filePath: paths.omp,
       apiKey,
@@ -31160,7 +31285,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("hermes")) {
-    const hermesExisted = fs23.existsSync(paths.hermes);
+    const hermesExisted = fs24.existsSync(paths.hermes);
     const hermesRes = syncHermes({
       filePath: paths.hermes,
       apiKey,
@@ -31178,7 +31303,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("openclaw")) {
-    const openClawExisted = fs23.existsSync(paths.openClaw);
+    const openClawExisted = fs24.existsSync(paths.openClaw);
     const openClawRes = syncOpenClaw({
       filePath: paths.openClaw,
       apiKey,
@@ -31197,7 +31322,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("kilo")) {
-    const kiloExisted = fs23.existsSync(paths.kilo);
+    const kiloExisted = fs24.existsSync(paths.kilo);
     const kiloRes = syncKilo({
       filePath: paths.kilo,
       apiKey,
@@ -31217,7 +31342,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("cline")) {
-    const clineExisted = fs23.existsSync(paths.cline);
+    const clineExisted = fs24.existsSync(paths.cline);
     const clineRes = syncCline({
       filePath: paths.cline,
       apiKey,
@@ -31235,7 +31360,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("zed")) {
-    const zedExisted = fs23.existsSync(paths.zed);
+    const zedExisted = fs24.existsSync(paths.zed);
     const zedRes = syncZed({
       filePath: paths.zed,
       apiKey,
@@ -31255,7 +31380,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("aider")) {
-    const aiderExisted = fs23.existsSync(paths.aider);
+    const aiderExisted = fs24.existsSync(paths.aider);
     const aiderRes = syncAider({
       filePath: paths.aider,
       apiKey,
@@ -31273,11 +31398,11 @@ function syncAllClients(options = {}) {
     }
   }
   try {
-    fs23.mkdirSync(path19.dirname(stateFilePath), { recursive: true });
+    fs24.mkdirSync(path19.dirname(stateFilePath), { recursive: true });
     let existingClients = {};
-    if (fs23.existsSync(stateFilePath)) {
+    if (fs24.existsSync(stateFilePath)) {
       try {
-        const raw = fs23.readFileSync(stateFilePath, "utf-8");
+        const raw = fs24.readFileSync(stateFilePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.clients && typeof parsed.clients === "object") {
           existingClients = parsed.clients;
@@ -31296,7 +31421,7 @@ function syncAllClients(options = {}) {
         ...stateRecords
       }
     };
-    fs23.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
+    fs24.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
   } catch (err) {
     console.error("Warning: could not write sync state file:", err);
   }
@@ -31308,9 +31433,9 @@ function restoreAllClients(options = {}) {
   const details = [];
   let restoredCount = 0;
   let state = null;
-  if (fs23.existsSync(stateFilePath)) {
+  if (fs24.existsSync(stateFilePath)) {
     try {
-      const raw = fs23.readFileSync(stateFilePath, "utf-8");
+      const raw = fs24.readFileSync(stateFilePath, "utf-8");
       state = JSON.parse(raw);
     } catch {
     }
@@ -31335,7 +31460,7 @@ function restoreAllClients(options = {}) {
     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 || fs23.existsSync(filePath));
+    const canAttempt = options.stateFilePath ? Boolean(c.stateRecord) : Boolean(c.stateRecord || fs24.existsSync(filePath));
     if (canAttempt) {
       const res = c.restoreFn(filePath, backupPath);
       details.push(res);
@@ -31348,12 +31473,12 @@ function restoreAllClients(options = {}) {
       }
     }
   }
-  if (stateFilePath && fs23.existsSync(stateFilePath)) {
+  if (stateFilePath && fs24.existsSync(stateFilePath)) {
     try {
       if (state && state.clients && Object.keys(state.clients).length > 0) {
-        fs23.writeFileSync(stateFilePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+        fs24.writeFileSync(stateFilePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
       } else {
-        fs23.unlinkSync(stateFilePath);
+        fs24.unlinkSync(stateFilePath);
       }
     } catch {
     }
@@ -31790,7 +31915,7 @@ var init_sync_view = __esm({
 });
 
 // src/tui/views/storage-view.ts
-import fs24 from "node:fs";
+import fs25 from "node:fs";
 import path20 from "node:path";
 var StorageView;
 var init_storage_view = __esm({
@@ -31856,8 +31981,8 @@ var init_storage_view = __esm({
           let totalBytes = 0;
           let count = 0;
           this.profileStats = [];
-          if (fs24.existsSync(profilesDir)) {
-            const entries = fs24.readdirSync(profilesDir, { withFileTypes: true });
+          if (fs25.existsSync(profilesDir)) {
+            const entries = fs25.readdirSync(profilesDir, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.isDirectory()) {
                 count++;
@@ -33892,8 +34017,8 @@ var init_app = __esm({
 // src/index.ts
 init_paths();
 init_server();
-import dotenv from "dotenv";
-import fs25 from "node:fs";
+import dotenv2 from "dotenv";
+import fs26 from "node:fs";
 try {
   process.title = "QwenProxy";
 } catch {
@@ -33901,10 +34026,10 @@ try {
 process.env.DOTENV_CONFIG_QUIET = "true";
 ensureDataDirs();
 var envPath = getEnvFilePath();
-if (fs25.existsSync(envPath)) {
-  dotenv.config({ path: envPath, quiet: true });
+if (fs26.existsSync(envPath)) {
+  dotenv2.config({ path: envPath, quiet: true });
 } else {
-  dotenv.config({ quiet: true });
+  dotenv2.config({ quiet: true });
 }
 process.on("uncaughtException", async (error) => {
   const { isPlaywrightAlreadyClosedError: isPlaywrightAlreadyClosedError2 } = await Promise.resolve().then(() => (init_playwright(), playwright_exports));