qwenproxy-cli 1.4.0 → 1.4.2

package/dist/sync-clients.js

@@ -1,6 +1,6 @@
 // src/sync-clients.ts
-import fs14 from "node:fs";
-import dotenv from "dotenv";
+import fs15 from "node:fs";
+import dotenv2 from "dotenv";
 
 // src/core/paths.ts
 import fs from "node:fs";
@@ -88,13 +88,23 @@ function ensureDataDirs(targetDataDir) {
 
 // src/sync/index.ts
 import "dotenv/config";
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import path13 from "node:path";
 import os3 from "node:os";
 import Database2 from "better-sqlite3";
 
 // src/core/config.ts
+import fs2 from "node:fs";
+import dotenv from "dotenv";
 import { z } from "zod";
+if (!isRunningUnderNodeTest()) {
+  const envPath2 = getEnvFilePath();
+  if (fs2.existsSync(envPath2)) {
+    dotenv.config({ path: envPath2, quiet: true });
+  } else {
+    dotenv.config({ quiet: true });
+  }
+}
 var envSchema = z.object({
   PORT: z.string().regex(/^\d+$/, "PORT must be a number").refine((value) => {
     const port = Number(value);
@@ -484,11 +494,11 @@ function isLoopbackHost(host) {
 }
 
 // src/sync/claude-code.ts
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import path3 from "node:path";
 
 // src/sync/utils.ts
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import path2 from "node:path";
 function createTimestampBackup(filePath) {
   const dir = path2.dirname(filePath);
@@ -498,19 +508,19 @@ function createTimestampBackup(filePath) {
   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);
+  fs3.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;
+  if (!fs3.existsSync(dir)) return void 0;
   try {
-    const files = fs2.readdirSync(dir);
+    const files = fs3.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;
+        return fs3.statSync(b).mtimeMs - fs3.statSync(a).mtimeMs;
       } catch {
         return 0;
       }
@@ -521,13 +531,13 @@ function findLatestBackup(filePath) {
   }
 }
 function restoreFromBackup(filePath, backupPath) {
-  const targetBackup = backupPath && fs2.existsSync(backupPath) ? backupPath : findLatestBackup(filePath);
-  if (!targetBackup || !fs2.existsSync(targetBackup)) {
+  const targetBackup = backupPath && fs3.existsSync(backupPath) ? backupPath : findLatestBackup(filePath);
+  if (!targetBackup || !fs3.existsSync(targetBackup)) {
     return false;
   }
-  fs2.copyFileSync(targetBackup, filePath);
+  fs3.copyFileSync(targetBackup, filePath);
   try {
-    fs2.unlinkSync(targetBackup);
+    fs3.unlinkSync(targetBackup);
   } catch {
   }
   return true;
@@ -544,13 +554,13 @@ function formatModelDisplayName(model) {
 function syncClaudeCode(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max" } = options;
   try {
-    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
+    fs4.mkdirSync(path3.dirname(filePath), { recursive: true });
     let backupPath;
     let existingSettings = {};
-    if (fs3.existsSync(filePath)) {
+    if (fs4.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
       try {
-        const content = fs3.readFileSync(filePath, "utf-8");
+        const content = fs4.readFileSync(filePath, "utf-8");
         existingSettings = JSON.parse(content);
       } catch {
         existingSettings = {};
@@ -576,7 +586,7 @@ function syncClaudeCode(options) {
       model,
       enableArtifact: false
     };
-    fs3.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+    fs4.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
     return {
       client: "claude-code",
       filePath,
@@ -598,9 +608,9 @@ function syncClaudeCode(options) {
 function restoreClaudeCode(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs3.existsSync(filePath)) {
+  if (fs4.existsSync(filePath)) {
     try {
-      const data = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+      const data = JSON.parse(fs4.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;
@@ -620,7 +630,7 @@ function restoreClaudeCode(filePath, backupPath) {
         if (Object.keys(data.env).length === 0) {
           delete data.env;
         }
-        fs3.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        fs4.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
         manuallyCleaned = true;
       }
     } catch {
@@ -638,7 +648,7 @@ function restoreClaudeCode(filePath, backupPath) {
 }
 
 // src/sync/codex.ts
-import fs4 from "node:fs";
+import fs5 from "node:fs";
 import path4 from "node:path";
 import os2 from "node:os";
 function removeTomlSection(content, sectionHeader) {
@@ -679,12 +689,12 @@ function updateTopLevelKey(content, key, value) {
   return newTopPart + restPart;
 }
 function syncCodexSingleFile(targetPath, options) {
-  fs4.mkdirSync(path4.dirname(targetPath), { recursive: true });
+  fs5.mkdirSync(path4.dirname(targetPath), { recursive: true });
   let backupPath;
   let content = "";
-  if (fs4.existsSync(targetPath)) {
+  if (fs5.existsSync(targetPath)) {
     backupPath = createTimestampBackup(targetPath);
-    content = fs4.readFileSync(targetPath, "utf-8");
+    content = fs5.readFileSync(targetPath, "utf-8");
   }
   const { apiKey, baseUrl, model = "qwen3.8-max", setActive = true } = options;
   const providerBlock = `[model_providers.qwenproxy]
@@ -705,8 +715,8 @@ experimental_bearer_token = "${apiKey}"
     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 (fs5.existsSync(catalogPath)) {
+        const catalog = JSON.parse(fs5.readFileSync(catalogPath, "utf-8"));
         if (Array.isArray(catalog.models)) {
           const hasModel = catalog.models.some((m) => m?.slug === model);
           if (!hasModel) {
@@ -719,14 +729,14 @@ experimental_bearer_token = "${apiKey}"
               context_window: 1e6,
               max_context_window: 1e6
             });
-            fs4.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
+            fs5.writeFileSync(catalogPath, JSON.stringify(catalog, null, 2), "utf-8");
           }
         }
       }
     } catch {
     }
   }
-  fs4.writeFileSync(targetPath, content.trimEnd() + "\n", "utf-8");
+  fs5.writeFileSync(targetPath, content.trimEnd() + "\n", "utf-8");
   return { backupPath };
 }
 function syncCodex(options) {
@@ -742,7 +752,7 @@ function syncCodex(options) {
       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))) {
+          if (fs5.existsSync(alternatePath) || fs5.existsSync(path4.dirname(alternatePath))) {
             syncCodexSingleFile(alternatePath, options);
           }
         } catch {
@@ -771,16 +781,16 @@ function restoreCodex(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
   const cleanSingleFile = (p) => {
-    if (fs4.existsSync(p)) {
+    if (fs5.existsSync(p)) {
       try {
-        let content = fs4.readFileSync(p, "utf-8");
+        let content = fs5.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");
+          fs5.writeFileSync(p, content.trimEnd() + "\n", "utf-8");
           manuallyCleaned = true;
         }
       } catch {
@@ -811,7 +821,7 @@ function restoreCodex(filePath, backupPath) {
 }
 
 // src/sync/opencode.ts
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import path5 from "node:path";
 function buildOpenCodeProviderObject(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
   const modelsObj = {};
@@ -937,12 +947,12 @@ function syncOpenCode(options) {
     setActive = true
   } = options;
   try {
-    fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+    fs6.mkdirSync(path5.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs5.existsSync(filePath)) {
+    if (fs6.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs5.readFileSync(filePath, "utf-8");
+      content = fs6.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");
@@ -957,7 +967,7 @@ function syncOpenCode(options) {
       initial.provider = {
         qwenproxy: providerObj
       };
-      fs5.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+      fs6.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
     } else {
       const existingSpan = findKeyObjectSpan(content, "qwenproxy");
       if (existingSpan) {
@@ -981,7 +991,7 @@ ${qwenEntry}
           }
         }
       }
-      fs5.writeFileSync(
+      fs6.writeFileSync(
         filePath,
         applyOpenCodeActiveModel(content, model, setActive),
         "utf-8"
@@ -1008,9 +1018,9 @@ ${qwenEntry}
 function restoreOpenCode(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs5.existsSync(filePath)) {
+  if (fs6.existsSync(filePath)) {
     try {
-      const data = JSON.parse(fs5.readFileSync(filePath, "utf-8"));
+      const data = JSON.parse(fs6.readFileSync(filePath, "utf-8"));
       if (data.provider && data.provider.qwenproxy) {
         delete data.provider.qwenproxy;
         if (data.model && data.model.includes("qwen")) {
@@ -1019,7 +1029,7 @@ function restoreOpenCode(filePath, backupPath) {
         if (Object.keys(data.provider).length === 0) {
           delete data.provider;
         }
-        fs5.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+        fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
         manuallyCleaned = true;
       }
     } catch {
@@ -1037,7 +1047,7 @@ function restoreOpenCode(filePath, backupPath) {
 }
 
 // src/sync/omp.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import path6 from "node:path";
 function buildOmpProviderYaml(baseUrl, apiKey, primaryModel = "qwen3.8-max", models) {
   const modelList = Array.from(
@@ -1069,12 +1079,12 @@ ${formattedModels}
 function syncOmp(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max", models } = options;
   try {
-    fs6.mkdirSync(path6.dirname(filePath), { recursive: true });
+    fs7.mkdirSync(path6.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs6.existsSync(filePath)) {
+    if (fs7.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs6.readFileSync(filePath, "utf-8");
+      content = fs7.readFileSync(filePath, "utf-8");
     }
     const providerBlock = buildOmpProviderYaml(baseUrl, apiKey, model, models);
     if (!content.trim()) {
@@ -1094,7 +1104,7 @@ ${providerBlock}`;
         }
       }
     }
-    fs6.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+    fs7.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
     return {
       client: "omp",
       filePath,
@@ -1116,13 +1126,13 @@ ${providerBlock}`;
 function restoreOmp(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs6.existsSync(filePath)) {
+  if (fs7.existsSync(filePath)) {
     try {
-      let content = fs6.readFileSync(filePath, "utf-8");
+      let content = fs7.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");
+        fs7.writeFileSync(filePath, content, "utf-8");
         manuallyCleaned = true;
       }
     } catch {
@@ -1140,7 +1150,7 @@ function restoreOmp(filePath, backupPath) {
 }
 
 // src/sync/hermes.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path7 from "node:path";
 function buildHermesModelBlock(baseUrl, apiKey, model = "qwen3.8-max", reasoningEffort = "high") {
   return `model:
@@ -1164,12 +1174,12 @@ function buildHermesProviderBlock(baseUrl, apiKey) {
 function syncHermes(options) {
   const { filePath, apiKey, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = options;
   try {
-    fs7.mkdirSync(path7.dirname(filePath), { recursive: true });
+    fs8.mkdirSync(path7.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs7.existsSync(filePath)) {
+    if (fs8.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs7.readFileSync(filePath, "utf-8");
+      content = fs8.readFileSync(filePath, "utf-8");
     }
     const modelBlock = buildHermesModelBlock(baseUrl, apiKey, model, reasoningEffort);
     const providerBlock = buildHermesProviderBlock(baseUrl, apiKey);
@@ -1195,7 +1205,7 @@ function syncHermes(options) {
         }
       }
     }
-    fs7.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
+    fs8.writeFileSync(filePath, content.trimEnd() + "\n", "utf-8");
     return {
       client: "hermes",
       filePath,
@@ -1227,7 +1237,7 @@ function restoreHermes(filePath, backupPath) {
 }
 
 // src/sync/openclaw.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path8 from "node:path";
 function findKeyObjectSpan2(content, key) {
   const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
@@ -1326,12 +1336,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 {
-    fs8.mkdirSync(path8.dirname(filePath), { recursive: true });
+    fs9.mkdirSync(path8.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs8.existsSync(filePath)) {
+    if (fs9.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs8.readFileSync(filePath, "utf-8");
+      content = fs9.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");
@@ -1355,7 +1365,7 @@ function syncOpenClaw(options) {
           }
         }
       };
-      fs8.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+      fs9.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
     } else {
       const existingSpan = findKeyObjectSpan2(content, "qwenproxy");
       if (existingSpan) {
@@ -1392,7 +1402,7 @@ ${qwenEntry}
           }
         }
       }
-      fs8.writeFileSync(filePath, content, "utf-8");
+      fs9.writeFileSync(filePath, content, "utf-8");
     }
     return {
       client: "openclaw",
@@ -1425,7 +1435,7 @@ function restoreOpenClaw(filePath, backupPath) {
 }
 
 // src/sync/kilo.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import path9 from "node:path";
 function findKeyObjectSpan3(content, key) {
   const regex = new RegExp(`"${key}"\\s*:\\s*\\{`);
@@ -1532,12 +1542,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 {
-    fs9.mkdirSync(path9.dirname(filePath), { recursive: true });
+    fs10.mkdirSync(path9.dirname(filePath), { recursive: true });
     let backupPath;
     let content = "";
-    if (fs9.existsSync(filePath)) {
+    if (fs10.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      content = fs9.readFileSync(filePath, "utf-8");
+      content = fs10.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");
@@ -1552,7 +1562,7 @@ function syncKilo(options) {
       if (setActive) {
         initial.model = `qwenproxy/${model}`;
       }
-      fs9.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
+      fs10.writeFileSync(filePath, JSON.stringify(initial, null, 2) + "\n", "utf-8");
     } else {
       const existingSpan = findKeyObjectSpan3(content, "qwenproxy");
       if (existingSpan) {
@@ -1582,7 +1592,7 @@ ${qwenEntry}
           content = content.replace(modelRegex, `"model": "qwenproxy/${model}"`);
         }
       }
-      fs9.writeFileSync(filePath, content, "utf-8");
+      fs10.writeFileSync(filePath, content, "utf-8");
     }
     return {
       client: "kilo",
@@ -1615,7 +1625,7 @@ function restoreKilo(filePath, backupPath) {
 }
 
 // src/sync/cline.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import path10 from "node:path";
 import Database from "better-sqlite3";
 var TARGET_KEYS = [
@@ -1626,9 +1636,9 @@ var TARGET_KEYS = [
 function syncCline(options) {
   const { filePath, baseUrl, model = "qwen3.8-max", reasoningEffort = "high" } = options;
   try {
-    fs10.mkdirSync(path10.dirname(filePath), { recursive: true });
+    fs11.mkdirSync(path10.dirname(filePath), { recursive: true });
     let backupPath;
-    if (fs10.existsSync(filePath)) {
+    if (fs11.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
     }
     const db = new Database(filePath);
@@ -1700,7 +1710,7 @@ function syncCline(options) {
 function restoreCline(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs10.existsSync(filePath)) {
+  if (fs11.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();
@@ -1733,7 +1743,7 @@ function restoreCline(filePath, backupPath) {
 }
 
 // src/sync/zed.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import path11 from "node:path";
 function parseJsonWithComments(raw) {
   let result = "";
@@ -1847,13 +1857,13 @@ function buildZedAvailableModels(primaryModel = "qwen3.8-max", models) {
 function syncZed(options) {
   const { filePath, baseUrl, model = "qwen3.8-max", models, setActive = true } = options;
   try {
-    fs11.mkdirSync(path11.dirname(filePath), { recursive: true });
+    fs12.mkdirSync(path11.dirname(filePath), { recursive: true });
     let backupPath;
     let existingSettings = {};
-    if (fs11.existsSync(filePath)) {
+    if (fs12.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
       try {
-        const content = fs11.readFileSync(filePath, "utf-8");
+        const content = fs12.readFileSync(filePath, "utf-8");
         existingSettings = parseJsonWithComments(content);
       } catch {
         existingSettings = {};
@@ -1883,7 +1893,7 @@ function syncZed(options) {
         }
       };
     }
-    fs11.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
+    fs12.writeFileSync(filePath, JSON.stringify(updatedSettings, null, 2) + "\n", "utf-8");
     return {
       client: "zed",
       filePath,
@@ -1905,9 +1915,9 @@ function syncZed(options) {
 function restoreZed(filePath, backupPath) {
   const restoredFromBackup = restoreFromBackup(filePath, backupPath);
   let manuallyCleaned = false;
-  if (fs11.existsSync(filePath)) {
+  if (fs12.existsSync(filePath)) {
     try {
-      let content = fs11.readFileSync(filePath, "utf-8");
+      let content = fs12.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")) {
@@ -1915,7 +1925,7 @@ function restoreZed(filePath, backupPath) {
           if (Object.keys(data.language_models).length === 0) {
             delete data.language_models;
           }
-          fs11.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+          fs12.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
           manuallyCleaned = true;
         }
       }
@@ -1934,7 +1944,7 @@ function restoreZed(filePath, backupPath) {
 }
 
 // src/sync/aider.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import path12 from "node:path";
 function updateYamlKeyValue(content, key, value) {
   const regex = new RegExp(`^${key}:.*$`, "m");
@@ -1954,12 +1964,12 @@ function syncAider(options) {
     modelSettingsPath
   } = options;
   try {
-    fs12.mkdirSync(path12.dirname(filePath), { recursive: true });
+    fs13.mkdirSync(path12.dirname(filePath), { recursive: true });
     let backupPath;
     let confContent = "";
-    if (fs12.existsSync(filePath)) {
+    if (fs13.existsSync(filePath)) {
       backupPath = createTimestampBackup(filePath);
-      confContent = fs12.readFileSync(filePath, "utf-8");
+      confContent = fs13.readFileSync(filePath, "utf-8");
     }
     const fullModelName = model.startsWith("openai/") ? model : `openai/${model}`;
     const weakModelName = "openai/qwen3.7-plus";
@@ -1968,15 +1978,15 @@ function syncAider(options) {
     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");
+    fs13.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 });
+      fs13.mkdirSync(path12.dirname(resolvedSettingsPath), { recursive: true });
       let settingsContent = "";
-      if (fs12.existsSync(resolvedSettingsPath)) {
+      if (fs13.existsSync(resolvedSettingsPath)) {
         extraBackupPath = createTimestampBackup(resolvedSettingsPath);
-        settingsContent = fs12.readFileSync(resolvedSettingsPath, "utf-8");
+        settingsContent = fs13.readFileSync(resolvedSettingsPath, "utf-8");
       }
       const modelBlock = `- name: ${fullModelName}
   extra_params:
@@ -1990,7 +2000,7 @@ function syncAider(options) {
       } else {
         settingsContent = settingsContent.trimEnd() + (settingsContent.length > 0 ? "\n\n" : "") + modelBlock;
       }
-      fs12.writeFileSync(resolvedSettingsPath, settingsContent.trimEnd() + "\n", "utf-8");
+      fs13.writeFileSync(resolvedSettingsPath, settingsContent.trimEnd() + "\n", "utf-8");
     }
     return {
       client: "aider",
@@ -2080,14 +2090,14 @@ function getDefaultPaths() {
     path13.join(home, ".opencode", "opencode.jsonc"),
     path13.join(home, ".opencode", "opencode.json")
   ];
-  const existingOpenCode = openCodeCandidates.find((p) => fs13.existsSync(p));
+  const existingOpenCode = openCodeCandidates.find((p) => fs14.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));
+  const existingKilo = kiloCandidates.find((p) => fs14.existsSync(p));
   let clinePath;
   if (isWindows) {
     clinePath = path13.join(appData, "Code", "User", "globalStorage", "state.vscdb");
@@ -2104,7 +2114,7 @@ function getDefaultPaths() {
   }
   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"),
+    codex: fs14.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"),
@@ -2126,7 +2136,7 @@ function isExecutableInPath(name) {
     for (const ext of extensions) {
       const fullPath = path13.join(dir, name + ext);
       try {
-        if (fs13.existsSync(fullPath) && !fs13.statSync(fullPath).isDirectory()) {
+        if (fs14.existsSync(fullPath) && !fs14.statSync(fullPath).isDirectory()) {
           return true;
         }
       } catch {
@@ -2144,9 +2154,9 @@ function isVscodeExtensionInstalled(pattern) {
     path13.join(home, ".windsurf", "extensions")
   ];
   for (const d of candidateDirs) {
-    if (fs13.existsSync(d)) {
+    if (fs14.existsSync(d)) {
       try {
-        const entries = fs13.readdirSync(d);
+        const entries = fs14.readdirSync(d);
         if (entries.some((e) => pattern.test(e))) return true;
       } catch {
       }
@@ -2158,9 +2168,9 @@ 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;
+    if (fs14.existsSync(path13.join(local, "Programs", "Zed"))) return true;
   } else if (process.platform === "darwin") {
-    if (fs13.existsSync("/Applications/Zed.app")) return true;
+    if (fs14.existsSync("/Applications/Zed.app")) return true;
   }
   return false;
 }
@@ -2173,7 +2183,7 @@ function isMatchingLocalHost(text, port = 7936) {
 }
 function isClientToolInstalled(id, targetPath, isCustomTestPath = false) {
   if (isCustomTestPath) {
-    return fs13.existsSync(targetPath);
+    return fs14.existsSync(targetPath);
   }
   switch (id) {
     case "hermes":
@@ -2189,15 +2199,15 @@ function isClientToolInstalled(id, targetPath, isCustomTestPath = false) {
     case "zed":
       return isZedInstalled();
     case "claude-code":
-      return isExecutableInPath("claude") || fs13.existsSync(targetPath);
+      return isExecutableInPath("claude") || fs14.existsSync(targetPath);
     case "codex":
-      return isExecutableInPath("codex") || fs13.existsSync(targetPath);
+      return isExecutableInPath("codex") || fs14.existsSync(targetPath);
     case "opencode":
-      return isExecutableInPath("opencode") || fs13.existsSync(targetPath);
+      return isExecutableInPath("opencode") || fs14.existsSync(targetPath);
     case "omp":
-      return isExecutableInPath("omp") || fs13.existsSync(targetPath);
+      return isExecutableInPath("omp") || fs14.existsSync(targetPath);
     default:
-      return fs13.existsSync(targetPath);
+      return fs14.existsSync(targetPath);
   }
 }
 function inspectClientSyncStatus(id, filePath, port = 7936) {
@@ -2207,7 +2217,7 @@ function inspectClientSyncStatus(id, filePath, port = 7936) {
     filePath && defaultTarget && path13.resolve(filePath) !== path13.resolve(defaultTarget)
   );
   const targetPath = filePath || defaultTarget;
-  if (!fs13.existsSync(targetPath)) {
+  if (!fs14.existsSync(targetPath)) {
     return { id, installed: false, synced: false };
   }
   const toolInstalled = isClientToolInstalled(id, targetPath, isCustomTestPath);
@@ -2237,7 +2247,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 = fs13.readFileSync(targetPath, "utf-8");
+    const raw = fs14.readFileSync(targetPath, "utf-8");
     if (id === "claude-code") {
       const data = JSON.parse(raw);
       const url = data?.env?.ANTHROPIC_BASE_URL || "";
@@ -2363,7 +2373,7 @@ function syncAllClients(options = {}) {
     return options.targets.includes(client);
   };
   if (shouldSync("claude-code")) {
-    const claudeExisted = fs13.existsSync(paths.claudeCode);
+    const claudeExisted = fs14.existsSync(paths.claudeCode);
     const claudeRes = syncClaudeCode({
       filePath: paths.claudeCode,
       apiKey,
@@ -2381,7 +2391,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("codex")) {
-    const codexExisted = fs13.existsSync(paths.codex);
+    const codexExisted = fs14.existsSync(paths.codex);
     const codexRes = syncCodex({
       filePath: paths.codex,
       apiKey,
@@ -2400,7 +2410,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("opencode")) {
-    const openCodeExisted = fs13.existsSync(paths.openCode);
+    const openCodeExisted = fs14.existsSync(paths.openCode);
     const openCodeRes = syncOpenCode({
       filePath: paths.openCode,
       apiKey,
@@ -2420,7 +2430,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("omp")) {
-    const ompExisted = fs13.existsSync(paths.omp);
+    const ompExisted = fs14.existsSync(paths.omp);
     const ompRes = syncOmp({
       filePath: paths.omp,
       apiKey,
@@ -2439,7 +2449,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("hermes")) {
-    const hermesExisted = fs13.existsSync(paths.hermes);
+    const hermesExisted = fs14.existsSync(paths.hermes);
     const hermesRes = syncHermes({
       filePath: paths.hermes,
       apiKey,
@@ -2457,7 +2467,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("openclaw")) {
-    const openClawExisted = fs13.existsSync(paths.openClaw);
+    const openClawExisted = fs14.existsSync(paths.openClaw);
     const openClawRes = syncOpenClaw({
       filePath: paths.openClaw,
       apiKey,
@@ -2476,7 +2486,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("kilo")) {
-    const kiloExisted = fs13.existsSync(paths.kilo);
+    const kiloExisted = fs14.existsSync(paths.kilo);
     const kiloRes = syncKilo({
       filePath: paths.kilo,
       apiKey,
@@ -2496,7 +2506,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("cline")) {
-    const clineExisted = fs13.existsSync(paths.cline);
+    const clineExisted = fs14.existsSync(paths.cline);
     const clineRes = syncCline({
       filePath: paths.cline,
       apiKey,
@@ -2514,7 +2524,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("zed")) {
-    const zedExisted = fs13.existsSync(paths.zed);
+    const zedExisted = fs14.existsSync(paths.zed);
     const zedRes = syncZed({
       filePath: paths.zed,
       apiKey,
@@ -2534,7 +2544,7 @@ function syncAllClients(options = {}) {
     }
   }
   if (shouldSync("aider")) {
-    const aiderExisted = fs13.existsSync(paths.aider);
+    const aiderExisted = fs14.existsSync(paths.aider);
     const aiderRes = syncAider({
       filePath: paths.aider,
       apiKey,
@@ -2552,11 +2562,11 @@ function syncAllClients(options = {}) {
     }
   }
   try {
-    fs13.mkdirSync(path13.dirname(stateFilePath), { recursive: true });
+    fs14.mkdirSync(path13.dirname(stateFilePath), { recursive: true });
     let existingClients = {};
-    if (fs13.existsSync(stateFilePath)) {
+    if (fs14.existsSync(stateFilePath)) {
       try {
-        const raw = fs13.readFileSync(stateFilePath, "utf-8");
+        const raw = fs14.readFileSync(stateFilePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.clients && typeof parsed.clients === "object") {
           existingClients = parsed.clients;
@@ -2575,7 +2585,7 @@ function syncAllClients(options = {}) {
         ...stateRecords
       }
     };
-    fs13.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
+    fs14.writeFileSync(stateFilePath, JSON.stringify(stateContent, null, 2) + "\n", "utf-8");
   } catch (err) {
     console.error("Warning: could not write sync state file:", err);
   }
@@ -2587,9 +2597,9 @@ function restoreAllClients(options = {}) {
   const details = [];
   let restoredCount = 0;
   let state = null;
-  if (fs13.existsSync(stateFilePath)) {
+  if (fs14.existsSync(stateFilePath)) {
     try {
-      const raw = fs13.readFileSync(stateFilePath, "utf-8");
+      const raw = fs14.readFileSync(stateFilePath, "utf-8");
       state = JSON.parse(raw);
     } catch {
     }
@@ -2614,7 +2624,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 || fs13.existsSync(filePath));
+    const canAttempt = options.stateFilePath ? Boolean(c.stateRecord) : Boolean(c.stateRecord || fs14.existsSync(filePath));
     if (canAttempt) {
       const res = c.restoreFn(filePath, backupPath);
       details.push(res);
@@ -2627,12 +2637,12 @@ function restoreAllClients(options = {}) {
       }
     }
   }
-  if (stateFilePath && fs13.existsSync(stateFilePath)) {
+  if (stateFilePath && fs14.existsSync(stateFilePath)) {
     try {
       if (state && state.clients && Object.keys(state.clients).length > 0) {
-        fs13.writeFileSync(stateFilePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+        fs14.writeFileSync(stateFilePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
       } else {
-        fs13.unlinkSync(stateFilePath);
+        fs14.unlinkSync(stateFilePath);
       }
     } catch {
     }
@@ -2644,10 +2654,10 @@ function restoreAllClients(options = {}) {
 process.env.DOTENV_CONFIG_QUIET = "true";
 ensureDataDirs();
 var envPath = getEnvFilePath();
-if (fs14.existsSync(envPath)) {
-  dotenv.config({ path: envPath, quiet: true });
+if (fs15.existsSync(envPath)) {
+  dotenv2.config({ path: envPath, quiet: true });
 } else {
-  dotenv.config({ quiet: true });
+  dotenv2.config({ quiet: true });
 }
 function parseArgs() {
   const args = process.argv.slice(2);