@kenkaiiii/gg-core 5.87.2 → 5.87.3

package/dist/index.cjs

@@ -70,8 +70,8 @@ __export(index_exports, {
   getAuthProvider: () => getAuthProvider,
   getAuthStorageKey: () => getAuthStorageKey,
   getAuthStorageKeys: () => getAuthStorageKeys,
-  getClaudeCliUserAgent: () => getClaudeCliUserAgent,
-  getClaudeCodeVersion: () => getClaudeCodeVersion,
+  getClaudeCliUserAgent: () => import_gg_ai.getClaudeCliUserAgent,
+  getClaudeCodeVersion: () => import_gg_ai.getClaudeCodeVersion,
   getContextWindow: () => getContextWindow,
   getDefaultModel: () => getDefaultModel,
   getDefaultThinkingLevel: () => getDefaultThinkingLevel,
@@ -108,7 +108,7 @@ __export(index_exports, {
   oauthStorageKey: () => oauthStorageKey,
   openLog: () => openLog,
   parseLocalModelId: () => parseLocalModelId,
-  pendingClaudeCodeVersionRefresh: () => pendingClaudeCodeVersionRefresh,
+  pendingClaudeCodeVersionRefresh: () => import_gg_ai.pendingClaudeCodeVersionRefresh,
   probeEndpoint: () => probeEndpoint,
   providerStorageKeys: () => providerStorageKeys,
   readStoredBaseUrlSync: () => readStoredBaseUrlSync,
@@ -384,12 +384,12 @@ async function refreshKimiToken(refreshToken) {
 }
 
 // src/auth-storage.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_node_fs3 = require("fs");
 var import_node_crypto6 = __toESM(require("crypto"), 1);
 
 // src/oauth/anthropic.ts
-var import_node_crypto3 = __toESM(require("crypto"), 1);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
 
 // src/oauth/pkce.ts
 function base64urlEncode(bytes) {
@@ -410,283 +410,7 @@ async function generatePKCE() {
 }
 
 // src/claude-code-version.ts
-var import_promises = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-
-// src/logger.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var import_node_crypto2 = require("crypto");
 var import_gg_ai = require("@kenkaiiii/gg-ai");
-var MAX_BYTES = 10 * 1024 * 1024;
-var MIN_HEADROOM_BYTES = 64 * 1024;
-var fd = null;
-var logPath = null;
-var fileBytes = 0;
-var processBytes = 0;
-var rotationFailed = false;
-var capped = false;
-var sessionId = "";
-var appName = "app";
-var cleanups = [];
-var exactSecrets = [];
-function rotateIfNeeded(filePath, force = false) {
-  try {
-    const st = import_node_fs2.default.statSync(filePath);
-    if (!force && st.size <= MAX_BYTES - MIN_HEADROOM_BYTES) return;
-    const rotated = `${filePath}.1`;
-    try {
-      import_node_fs2.default.unlinkSync(rotated);
-    } catch {
-    }
-    import_node_fs2.default.renameSync(filePath, rotated);
-  } catch {
-  }
-}
-function rotateOpenLog() {
-  if (fd === null || logPath === null) return false;
-  const sizeBefore = fileBytes;
-  try {
-    import_node_fs2.default.closeSync(fd);
-  } catch {
-  }
-  fd = null;
-  rotateIfNeeded(logPath, true);
-  try {
-    fd = import_node_fs2.default.openSync(logPath, "a");
-    fileBytes = import_node_fs2.default.fstatSync(fd).size;
-  } catch {
-    if (fd !== null) {
-      try {
-        import_node_fs2.default.closeSync(fd);
-      } catch {
-      }
-    }
-    fd = null;
-    capped = true;
-    return false;
-  }
-  if (fileBytes >= sizeBefore) rotationFailed = true;
-  return true;
-}
-function openLog(filePath, name) {
-  if (fd !== null || capped) return false;
-  appName = name;
-  exactSecrets = (0, import_gg_ai.environmentSecrets)(process.env);
-  try {
-    import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(filePath), { recursive: true, mode: 448 });
-  } catch {
-  }
-  rotateIfNeeded(filePath);
-  try {
-    fd = import_node_fs2.default.openSync(filePath, "a");
-  } catch {
-    fd = null;
-    fileBytes = 0;
-    return false;
-  }
-  try {
-    fileBytes = import_node_fs2.default.fstatSync(fd).size;
-  } catch {
-    try {
-      import_node_fs2.default.closeSync(fd);
-    } catch {
-    }
-    fd = null;
-    fileBytes = 0;
-    return false;
-  }
-  logPath = filePath;
-  processBytes = 0;
-  rotationFailed = false;
-  sessionId = (0, import_node_crypto2.randomBytes)(4).toString("hex");
-  try {
-    if (fileBytes < MAX_BYTES) {
-      const written = import_node_fs2.default.writeSync(fd, "\n");
-      fileBytes += written;
-      processBytes += written;
-    }
-  } catch {
-  }
-  return true;
-}
-function getSessionId() {
-  return sessionId;
-}
-function isLoggerOpen() {
-  return fd !== null;
-}
-function log(level, category, message, data) {
-  if (fd === null) return;
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const safeMessage = (0, import_gg_ai.redactText)(message, { secrets: exactSecrets });
-  let line = `[${ts}] [sid=${sessionId}] [${level}] [${category}] ${safeMessage}`;
-  if (data) {
-    const safeData = (0, import_gg_ai.redactValue)(data, { secrets: exactSecrets });
-    const pairs = Object.entries(safeData).map(([k, v]) => {
-      if (typeof v === "string") return `${k}=${v}`;
-      if (typeof v === "bigint") return `${k}=${String(v)}`;
-      return `${k}=${JSON.stringify(v)}`;
-    }).join(" ");
-    if (pairs) line += ` ${pairs}`;
-  }
-  line += "\n";
-  const lineBytes = Buffer.byteLength(line);
-  if (processBytes + lineBytes > MAX_BYTES) {
-    const capLine = `[${ts}] [sid=${sessionId}] [WARN] [logger] Log cap reached; file logging disabled until restart
-`;
-    try {
-      if (fileBytes + Buffer.byteLength(capLine) <= MAX_BYTES) {
-        fileBytes += import_node_fs2.default.writeSync(fd, capLine);
-      }
-      import_node_fs2.default.closeSync(fd);
-    } catch {
-    }
-    fd = null;
-    capped = true;
-    return;
-  }
-  if (fileBytes + lineBytes > MAX_BYTES && !rotationFailed && !rotateOpenLog()) return;
-  if (fd === null) return;
-  try {
-    const written = import_node_fs2.default.writeSync(fd, line);
-    fileBytes += written;
-    processBytes += written;
-  } catch {
-  }
-}
-function registerLogCleanup(fn) {
-  cleanups.push(fn);
-}
-function closeLogger(opts) {
-  if (fd !== null) {
-    if (opts?.shutdownLine !== false) log("INFO", "shutdown", `${appName} shutting down`);
-    try {
-      if (fd !== null) import_node_fs2.default.closeSync(fd);
-    } catch {
-    }
-  }
-  fd = null;
-  logPath = null;
-  fileBytes = 0;
-  processBytes = 0;
-  rotationFailed = false;
-  capped = false;
-  exactSecrets = [];
-  for (const unsub of cleanups) unsub();
-  cleanups = [];
-}
-
-// src/claude-code-version.ts
-var NPM_LATEST_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code/latest";
-var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var FETCH_TIMEOUT_MS = 3e3;
-var FALLBACK_VERSION = "2.1.88";
-var memoryCache = null;
-var inflight = null;
-function cachePath() {
-  return import_node_path4.default.join(getAppPaths().agentDir, "claude-code-version.json");
-}
-async function readDiskCache() {
-  try {
-    const raw = await import_promises.default.readFile(cachePath(), "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.version === "string" && typeof parsed.fetchedAt === "number") {
-      return parsed;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function writeDiskCache(data) {
-  try {
-    await import_promises.default.mkdir(getAppPaths().agentDir, { recursive: true, mode: 448 });
-    await import_promises.default.writeFile(cachePath(), JSON.stringify(data), { mode: 384 });
-  } catch (err) {
-    log(
-      "WARN",
-      "claude-code-version",
-      `Failed to write cache: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-async function fetchLatest() {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-  try {
-    const response = await fetch(NPM_LATEST_URL, { signal: controller.signal });
-    if (!response.ok) return null;
-    const data = await response.json();
-    if (typeof data.version === "string" && /^\d/.test(data.version)) {
-      return data.version;
-    }
-    return null;
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-var refreshing = null;
-function refreshInBackground() {
-  refreshing ??= (async () => {
-    try {
-      const fetched = await fetchLatest();
-      if (!fetched) return;
-      await writeDiskCache({ version: fetched, fetchedAt: Date.now() });
-      memoryCache = { version: fetched, expiresAt: Date.now() + CACHE_TTL_MS };
-    } finally {
-      refreshing = null;
-    }
-  })();
-  return refreshing;
-}
-function pendingClaudeCodeVersionRefresh() {
-  return refreshing;
-}
-async function getClaudeCodeVersion() {
-  if (memoryCache && Date.now() < memoryCache.expiresAt) {
-    return memoryCache.version;
-  }
-  if (inflight) return inflight;
-  inflight = (async () => {
-    const disk = await readDiskCache();
-    const diskFresh = disk && Date.now() - disk.fetchedAt < CACHE_TTL_MS;
-    if (disk && diskFresh) {
-      memoryCache = { version: disk.version, expiresAt: Date.now() + CACHE_TTL_MS };
-      return disk.version;
-    }
-    if (disk) {
-      memoryCache = { version: disk.version, expiresAt: Date.now() + 5 * 60 * 1e3 };
-      void refreshInBackground();
-      return disk.version;
-    }
-    const fetched = await fetchLatest();
-    if (fetched) {
-      await writeDiskCache({ version: fetched, fetchedAt: Date.now() });
-      memoryCache = { version: fetched, expiresAt: Date.now() + CACHE_TTL_MS };
-      return fetched;
-    }
-    const resolved = FALLBACK_VERSION;
-    memoryCache = { version: resolved, expiresAt: Date.now() + 5 * 60 * 1e3 };
-    log(
-      "WARN",
-      "claude-code-version",
-      `Failed to fetch latest Claude Code version; using ${resolved}`
-    );
-    return resolved;
-  })();
-  try {
-    return await inflight;
-  } finally {
-    inflight = null;
-  }
-}
-async function getClaudeCliUserAgent() {
-  const version = await getClaudeCodeVersion();
-  return `claude-cli/${version} (external, cli)`;
-}
 
 // src/oauth/anthropic.ts
 var CLIENT_ID2 = atob("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
@@ -701,7 +425,7 @@ async function postTokenRequest(body, label) {
   const encoded = JSON.stringify(body);
   const headers = {
     "Content-Type": "application/json",
-    "User-Agent": await getClaudeCliUserAgent(),
+    "User-Agent": await (0, import_gg_ai.getClaudeCliUserAgent)(),
     "anthropic-beta": "oauth-2025-04-20"
   };
   let lastError = null;
@@ -738,7 +462,7 @@ function toCredentials(data) {
 }
 async function loginAnthropic(callbacks) {
   const { verifier, challenge } = await generatePKCE();
-  const state = import_node_crypto3.default.randomBytes(16).toString("hex");
+  const state = import_node_crypto2.default.randomBytes(16).toString("hex");
   const params = new URLSearchParams({
     code: "true",
     client_id: CLIENT_ID2,
@@ -786,7 +510,7 @@ async function refreshAnthropicToken(refreshToken) {
 
 // src/oauth/openai.ts
 var import_node_http = __toESM(require("http"), 1);
-var import_node_crypto4 = __toESM(require("crypto"), 1);
+var import_node_crypto3 = __toESM(require("crypto"), 1);
 var CLIENT_ID3 = "app_EMoamEEZ73f0CkXaXp7hrann";
 var AUTHORIZE_URL2 = "https://auth.openai.com/oauth/authorize";
 var TOKEN_URL = "https://auth.openai.com/oauth/token";
@@ -798,7 +522,7 @@ var MAX_PASTE_ATTEMPTS = 3;
 var MIN_RAW_CODE_LENGTH = 10;
 async function loginOpenAI(callbacks) {
   const { verifier, challenge } = await generatePKCE();
-  const state = import_node_crypto4.default.randomBytes(16).toString("hex");
+  const state = import_node_crypto3.default.randomBytes(16).toString("hex");
   const url = new URL(AUTHORIZE_URL2);
   url.searchParams.set("response_type", "code");
   url.searchParams.set("client_id", CLIENT_ID3);
@@ -1006,7 +730,7 @@ async function refreshOpenAIToken(refreshToken) {
 
 // src/oauth/gemini.ts
 var import_node_http2 = __toESM(require("http"), 1);
-var import_node_crypto5 = __toESM(require("crypto"), 1);
+var import_node_crypto4 = __toESM(require("crypto"), 1);
 var CLIENT_ID_ENV = "GGCODER_GEMINI_OAUTH_CLIENT_ID";
 var CLIENT_SECRET_ENV = "GGCODER_GEMINI_OAUTH_CLIENT_SECRET";
 var DEFAULT_CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
@@ -1040,7 +764,7 @@ var CodeAssistHttpError = class extends Error {
 async function loginGemini(callbacks) {
   const { clientId: clientId2, clientSecret } = getGeminiOAuthClientCredentials();
   const { verifier, challenge } = await generatePKCE();
-  const state = import_node_crypto5.default.randomBytes(32).toString("hex");
+  const state = import_node_crypto4.default.randomBytes(32).toString("hex");
   const redirectUri = await getLoopbackRedirectUri();
   const url = new URL(AUTHORIZE_URL3);
   url.searchParams.set("response_type", "code");
@@ -1569,8 +1293,8 @@ async function refreshXaiToken(refreshToken) {
 }
 
 // src/file-lock.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_promises3 = require("timers/promises");
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_promises2 = require("timers/promises");
 var STALE_TIMEOUT_MS = 1e4;
 var RETRY_INTERVAL_MS = 50;
 var MAX_WAIT_MS = 5e3;
@@ -1588,36 +1312,36 @@ async function acquireLock(lockPath) {
   while (true) {
     try {
       const info = { pid: process.pid, timestamp: Date.now() };
-      await import_promises2.default.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
+      await import_promises.default.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
       return;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const content = await import_promises2.default.readFile(lockPath, "utf-8");
+        const content = await import_promises.default.readFile(lockPath, "utf-8");
         const info = JSON.parse(content);
         const isProcessAlive = isAlive(info.pid);
         const isStale = Date.now() - info.timestamp > STALE_TIMEOUT_MS;
         if (!isProcessAlive || isStale) {
-          await import_promises2.default.unlink(lockPath).catch(() => {
+          await import_promises.default.unlink(lockPath).catch(() => {
           });
           continue;
         }
       } catch {
-        await import_promises2.default.unlink(lockPath).catch(() => {
+        await import_promises.default.unlink(lockPath).catch(() => {
         });
         continue;
       }
       if (Date.now() - startTime > MAX_WAIT_MS) {
-        await import_promises2.default.unlink(lockPath).catch(() => {
+        await import_promises.default.unlink(lockPath).catch(() => {
         });
         continue;
       }
-      await (0, import_promises3.setTimeout)(RETRY_INTERVAL_MS);
+      await (0, import_promises2.setTimeout)(RETRY_INTERVAL_MS);
     }
   }
 }
 async function releaseLock(lockPath) {
-  await import_promises2.default.unlink(lockPath).catch(() => {
+  await import_promises.default.unlink(lockPath).catch(() => {
   });
 }
 function isAlive(pid) {
@@ -1630,6 +1354,170 @@ function isAlive(pid) {
   }
 }
 
+// src/logger.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_crypto5 = require("crypto");
+var import_gg_ai2 = require("@kenkaiiii/gg-ai");
+var MAX_BYTES = 10 * 1024 * 1024;
+var MIN_HEADROOM_BYTES = 64 * 1024;
+var fd = null;
+var logPath = null;
+var fileBytes = 0;
+var processBytes = 0;
+var rotationFailed = false;
+var capped = false;
+var sessionId = "";
+var appName = "app";
+var cleanups = [];
+var exactSecrets = [];
+function rotateIfNeeded(filePath, force = false) {
+  try {
+    const st = import_node_fs2.default.statSync(filePath);
+    if (!force && st.size <= MAX_BYTES - MIN_HEADROOM_BYTES) return;
+    const rotated = `${filePath}.1`;
+    try {
+      import_node_fs2.default.unlinkSync(rotated);
+    } catch {
+    }
+    import_node_fs2.default.renameSync(filePath, rotated);
+  } catch {
+  }
+}
+function rotateOpenLog() {
+  if (fd === null || logPath === null) return false;
+  const sizeBefore = fileBytes;
+  try {
+    import_node_fs2.default.closeSync(fd);
+  } catch {
+  }
+  fd = null;
+  rotateIfNeeded(logPath, true);
+  try {
+    fd = import_node_fs2.default.openSync(logPath, "a");
+    fileBytes = import_node_fs2.default.fstatSync(fd).size;
+  } catch {
+    if (fd !== null) {
+      try {
+        import_node_fs2.default.closeSync(fd);
+      } catch {
+      }
+    }
+    fd = null;
+    capped = true;
+    return false;
+  }
+  if (fileBytes >= sizeBefore) rotationFailed = true;
+  return true;
+}
+function openLog(filePath, name) {
+  if (fd !== null || capped) return false;
+  appName = name;
+  exactSecrets = (0, import_gg_ai2.environmentSecrets)(process.env);
+  try {
+    import_node_fs2.default.mkdirSync(import_node_path3.default.dirname(filePath), { recursive: true, mode: 448 });
+  } catch {
+  }
+  rotateIfNeeded(filePath);
+  try {
+    fd = import_node_fs2.default.openSync(filePath, "a");
+  } catch {
+    fd = null;
+    fileBytes = 0;
+    return false;
+  }
+  try {
+    fileBytes = import_node_fs2.default.fstatSync(fd).size;
+  } catch {
+    try {
+      import_node_fs2.default.closeSync(fd);
+    } catch {
+    }
+    fd = null;
+    fileBytes = 0;
+    return false;
+  }
+  logPath = filePath;
+  processBytes = 0;
+  rotationFailed = false;
+  sessionId = (0, import_node_crypto5.randomBytes)(4).toString("hex");
+  try {
+    if (fileBytes < MAX_BYTES) {
+      const written = import_node_fs2.default.writeSync(fd, "\n");
+      fileBytes += written;
+      processBytes += written;
+    }
+  } catch {
+  }
+  return true;
+}
+function getSessionId() {
+  return sessionId;
+}
+function isLoggerOpen() {
+  return fd !== null;
+}
+function log(level, category, message, data) {
+  if (fd === null) return;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const safeMessage = (0, import_gg_ai2.redactText)(message, { secrets: exactSecrets });
+  let line = `[${ts}] [sid=${sessionId}] [${level}] [${category}] ${safeMessage}`;
+  if (data) {
+    const safeData = (0, import_gg_ai2.redactValue)(data, { secrets: exactSecrets });
+    const pairs = Object.entries(safeData).map(([k, v]) => {
+      if (typeof v === "string") return `${k}=${v}`;
+      if (typeof v === "bigint") return `${k}=${String(v)}`;
+      return `${k}=${JSON.stringify(v)}`;
+    }).join(" ");
+    if (pairs) line += ` ${pairs}`;
+  }
+  line += "\n";
+  const lineBytes = Buffer.byteLength(line);
+  if (processBytes + lineBytes > MAX_BYTES) {
+    const capLine = `[${ts}] [sid=${sessionId}] [WARN] [logger] Log cap reached; file logging disabled until restart
+`;
+    try {
+      if (fileBytes + Buffer.byteLength(capLine) <= MAX_BYTES) {
+        fileBytes += import_node_fs2.default.writeSync(fd, capLine);
+      }
+      import_node_fs2.default.closeSync(fd);
+    } catch {
+    }
+    fd = null;
+    capped = true;
+    return;
+  }
+  if (fileBytes + lineBytes > MAX_BYTES && !rotationFailed && !rotateOpenLog()) return;
+  if (fd === null) return;
+  try {
+    const written = import_node_fs2.default.writeSync(fd, line);
+    fileBytes += written;
+    processBytes += written;
+  } catch {
+  }
+}
+function registerLogCleanup(fn) {
+  cleanups.push(fn);
+}
+function closeLogger(opts) {
+  if (fd !== null) {
+    if (opts?.shutdownLine !== false) log("INFO", "shutdown", `${appName} shutting down`);
+    try {
+      if (fd !== null) import_node_fs2.default.closeSync(fd);
+    } catch {
+    }
+  }
+  fd = null;
+  logPath = null;
+  fileBytes = 0;
+  processBytes = 0;
+  rotationFailed = false;
+  capped = false;
+  exactSecrets = [];
+  for (const unsub of cleanups) unsub();
+  cleanups = [];
+}
+
 // src/hidden-providers.ts
 var HIDDEN_PROVIDERS = ["gemini"];
 function isHiddenProvider(provider) {
@@ -1836,7 +1724,7 @@ var AuthStorage = class {
     const first = !this.loaded;
     await withFileLock(this.filePath, async () => {
       try {
-        const content = await import_promises4.default.readFile(this.filePath, "utf-8");
+        const content = await import_promises3.default.readFile(this.filePath, "utf-8");
         this.data = JSON.parse(content);
         if (first) {
           log("INFO", "auth", `Loaded credentials from ${this.filePath}`, {
@@ -1882,7 +1770,7 @@ var AuthStorage = class {
     }
     let changed;
     try {
-      const stat = await import_promises4.default.stat(this.filePath);
+      const stat = await import_promises3.default.stat(this.filePath);
       changed = stat.ino !== this.snapshotIno || stat.mtimeMs !== this.snapshotMtimeMs || stat.size !== this.snapshotSize;
     } catch {
       changed = this.snapshotSize !== -1;
@@ -1895,7 +1783,7 @@ var AuthStorage = class {
    */
   async rememberSnapshot() {
     try {
-      const stat = await import_promises4.default.stat(this.filePath);
+      const stat = await import_promises3.default.stat(this.filePath);
       this.snapshotMtimeMs = stat.mtimeMs;
       this.snapshotSize = stat.size;
       this.snapshotIno = stat.ino;
@@ -2136,7 +2024,7 @@ var AuthStorage = class {
 };
 async function readAuthData(filePath) {
   try {
-    const content = await import_promises4.default.readFile(filePath, "utf-8");
+    const content = await import_promises3.default.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error.code === "ENOENT") return {};
@@ -2146,10 +2034,10 @@ async function readAuthData(filePath) {
 async function atomicWriteFile(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${import_node_crypto6.default.randomUUID().slice(0, 8)}.tmp`;
   try {
-    await import_promises4.default.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    await import_promises4.default.rename(tmpPath, filePath);
+    await import_promises3.default.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await import_promises3.default.rename(tmpPath, filePath);
   } catch (err) {
-    await import_promises4.default.unlink(tmpPath).catch(() => {
+    await import_promises3.default.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
@@ -3147,7 +3035,7 @@ var FALLBACK_CONTEXT_WINDOW = 4096;
 var LOCAL_API_KEY_PLACEHOLDER = "local";
 var DEFAULT_PROBE_TIMEOUT_MS = 1200;
 var ENRICH_CONCURRENCY = 6;
-var CACHE_TTL_MS2 = 3e4;
+var CACHE_TTL_MS = 3e4;
 var NON_CHAT_ID_PATTERN = /(?:^|[-_/])(?:embed|embedding|rerank|reranker|bge|nomic-embed)/i;
 var LOCAL_ID_PREFIX = "local/";
 function formatLocalModelId(endpointId, rawId) {
@@ -3388,7 +3276,7 @@ function cacheKey(endpoints) {
 }
 async function discoverLocalModels(endpoints = DEFAULT_LOCAL_ENDPOINTS, options = {}) {
   const key = cacheKey(endpoints);
-  if (!options.force && cache && cache.key === key && Date.now() - cache.at < CACHE_TTL_MS2) {
+  if (!options.force && cache && cache.key === key && Date.now() - cache.at < CACHE_TTL_MS) {
     return cache.result;
   }
   const probes = await Promise.all(endpoints.map((endpoint) => probeEndpoint(endpoint, options)));
@@ -4161,9 +4049,9 @@ async function transcribeVoice(fileUrl) {
 // src/auto-update.ts
 var import_node_child_process2 = require("child_process");
 var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
-var FETCH_TIMEOUT_MS2 = 1e4;
+var FETCH_TIMEOUT_MS = 1e4;
 function compareVersions(a, b) {
   const pa = a.split(".").map(Number);
   const pb = b.split(".").map(Number);
@@ -4203,7 +4091,7 @@ function createAutoUpdater(config) {
   function writeState(state) {
     try {
       const filePath = stateFilePath();
-      import_node_fs4.default.mkdirSync(import_node_path5.default.dirname(filePath), { recursive: true, mode: 448 });
+      import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(filePath), { recursive: true, mode: 448 });
       import_node_fs4.default.writeFileSync(filePath, JSON.stringify(state));
     } catch {
     }
@@ -4233,7 +4121,7 @@ function createAutoUpdater(config) {
   async function fetchLatestVersion() {
     try {
       const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS2);
+      const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
       const response = await fetch(REGISTRY_URL, { signal: controller.signal });
       clearTimeout(timeout);
       const data = await response.json();