@kenkaiiii/gg-core 5.87.1 → 5.87.3

package/dist/{chunk-HMJZM62P.js → chunk-5ZYOOESD.js}

@@ -230,7 +230,7 @@ async function refreshKimiToken(refreshToken) {
 }
 
 // src/auth-storage.ts
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 import { readFileSync as readFileSync2 } from "fs";
 import crypto5 from "crypto";
 
@@ -256,283 +256,11 @@ async function generatePKCE() {
 }
 
 // src/claude-code-version.ts
-import fs2 from "fs/promises";
-import path3 from "path";
-
-// src/logger.ts
-import fs from "fs";
-import path2 from "path";
-import { randomBytes } from "crypto";
-import { environmentSecrets, redactText, redactValue } from "@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 = fs.statSync(filePath);
-    if (!force && st.size <= MAX_BYTES - MIN_HEADROOM_BYTES) return;
-    const rotated = `${filePath}.1`;
-    try {
-      fs.unlinkSync(rotated);
-    } catch {
-    }
-    fs.renameSync(filePath, rotated);
-  } catch {
-  }
-}
-function rotateOpenLog() {
-  if (fd === null || logPath === null) return false;
-  const sizeBefore = fileBytes;
-  try {
-    fs.closeSync(fd);
-  } catch {
-  }
-  fd = null;
-  rotateIfNeeded(logPath, true);
-  try {
-    fd = fs.openSync(logPath, "a");
-    fileBytes = fs.fstatSync(fd).size;
-  } catch {
-    if (fd !== null) {
-      try {
-        fs.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 = environmentSecrets(process.env);
-  try {
-    fs.mkdirSync(path2.dirname(filePath), { recursive: true, mode: 448 });
-  } catch {
-  }
-  rotateIfNeeded(filePath);
-  try {
-    fd = fs.openSync(filePath, "a");
-  } catch {
-    fd = null;
-    fileBytes = 0;
-    return false;
-  }
-  try {
-    fileBytes = fs.fstatSync(fd).size;
-  } catch {
-    try {
-      fs.closeSync(fd);
-    } catch {
-    }
-    fd = null;
-    fileBytes = 0;
-    return false;
-  }
-  logPath = filePath;
-  processBytes = 0;
-  rotationFailed = false;
-  sessionId = randomBytes(4).toString("hex");
-  try {
-    if (fileBytes < MAX_BYTES) {
-      const written = fs.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 = redactText(message, { secrets: exactSecrets });
-  let line = `[${ts}] [sid=${sessionId}] [${level}] [${category}] ${safeMessage}`;
-  if (data) {
-    const safeData = 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 += fs.writeSync(fd, capLine);
-      }
-      fs.closeSync(fd);
-    } catch {
-    }
-    fd = null;
-    capped = true;
-    return;
-  }
-  if (fileBytes + lineBytes > MAX_BYTES && !rotationFailed && !rotateOpenLog()) return;
-  if (fd === null) return;
-  try {
-    const written = fs.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) fs.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 path3.join(getAppPaths().agentDir, "claude-code-version.json");
-}
-async function readDiskCache() {
-  try {
-    const raw = await fs2.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 fs2.mkdir(getAppPaths().agentDir, { recursive: true, mode: 448 });
-    await fs2.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)`;
-}
+import {
+  getClaudeCodeVersion,
+  getClaudeCliUserAgent,
+  pendingClaudeCodeVersionRefresh
+} from "@kenkaiiii/gg-ai";
 
 // src/oauth/anthropic.ts
 var CLIENT_ID2 = atob("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
@@ -1415,7 +1143,7 @@ async function refreshXaiToken(refreshToken) {
 }
 
 // src/file-lock.ts
-import fs3 from "fs/promises";
+import fs from "fs/promises";
 import { setTimeout as setTimeout2 } from "timers/promises";
 var STALE_TIMEOUT_MS = 1e4;
 var RETRY_INTERVAL_MS = 50;
@@ -1434,27 +1162,27 @@ async function acquireLock(lockPath) {
   while (true) {
     try {
       const info = { pid: process.pid, timestamp: Date.now() };
-      await fs3.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
+      await fs.writeFile(lockPath, JSON.stringify(info), { flag: "wx" });
       return;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       try {
-        const content = await fs3.readFile(lockPath, "utf-8");
+        const content = await fs.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 fs3.unlink(lockPath).catch(() => {
+          await fs.unlink(lockPath).catch(() => {
           });
           continue;
         }
       } catch {
-        await fs3.unlink(lockPath).catch(() => {
+        await fs.unlink(lockPath).catch(() => {
         });
         continue;
       }
       if (Date.now() - startTime > MAX_WAIT_MS) {
-        await fs3.unlink(lockPath).catch(() => {
+        await fs.unlink(lockPath).catch(() => {
         });
         continue;
       }
@@ -1463,7 +1191,7 @@ async function acquireLock(lockPath) {
   }
 }
 async function releaseLock(lockPath) {
-  await fs3.unlink(lockPath).catch(() => {
+  await fs.unlink(lockPath).catch(() => {
   });
 }
 function isAlive(pid) {
@@ -1476,6 +1204,170 @@ function isAlive(pid) {
   }
 }
 
+// src/logger.ts
+import fs2 from "fs";
+import path2 from "path";
+import { randomBytes } from "crypto";
+import { environmentSecrets, redactText, redactValue } from "@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 = fs2.statSync(filePath);
+    if (!force && st.size <= MAX_BYTES - MIN_HEADROOM_BYTES) return;
+    const rotated = `${filePath}.1`;
+    try {
+      fs2.unlinkSync(rotated);
+    } catch {
+    }
+    fs2.renameSync(filePath, rotated);
+  } catch {
+  }
+}
+function rotateOpenLog() {
+  if (fd === null || logPath === null) return false;
+  const sizeBefore = fileBytes;
+  try {
+    fs2.closeSync(fd);
+  } catch {
+  }
+  fd = null;
+  rotateIfNeeded(logPath, true);
+  try {
+    fd = fs2.openSync(logPath, "a");
+    fileBytes = fs2.fstatSync(fd).size;
+  } catch {
+    if (fd !== null) {
+      try {
+        fs2.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 = environmentSecrets(process.env);
+  try {
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true, mode: 448 });
+  } catch {
+  }
+  rotateIfNeeded(filePath);
+  try {
+    fd = fs2.openSync(filePath, "a");
+  } catch {
+    fd = null;
+    fileBytes = 0;
+    return false;
+  }
+  try {
+    fileBytes = fs2.fstatSync(fd).size;
+  } catch {
+    try {
+      fs2.closeSync(fd);
+    } catch {
+    }
+    fd = null;
+    fileBytes = 0;
+    return false;
+  }
+  logPath = filePath;
+  processBytes = 0;
+  rotationFailed = false;
+  sessionId = randomBytes(4).toString("hex");
+  try {
+    if (fileBytes < MAX_BYTES) {
+      const written = fs2.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 = redactText(message, { secrets: exactSecrets });
+  let line = `[${ts}] [sid=${sessionId}] [${level}] [${category}] ${safeMessage}`;
+  if (data) {
+    const safeData = 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 += fs2.writeSync(fd, capLine);
+      }
+      fs2.closeSync(fd);
+    } catch {
+    }
+    fd = null;
+    capped = true;
+    return;
+  }
+  if (fileBytes + lineBytes > MAX_BYTES && !rotationFailed && !rotateOpenLog()) return;
+  if (fd === null) return;
+  try {
+    const written = fs2.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) fs2.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) {
@@ -1682,7 +1574,7 @@ var AuthStorage = class {
     const first = !this.loaded;
     await withFileLock(this.filePath, async () => {
       try {
-        const content = await fs4.readFile(this.filePath, "utf-8");
+        const content = await fs3.readFile(this.filePath, "utf-8");
         this.data = JSON.parse(content);
         if (first) {
           log("INFO", "auth", `Loaded credentials from ${this.filePath}`, {
@@ -1728,7 +1620,7 @@ var AuthStorage = class {
     }
     let changed;
     try {
-      const stat = await fs4.stat(this.filePath);
+      const stat = await fs3.stat(this.filePath);
       changed = stat.ino !== this.snapshotIno || stat.mtimeMs !== this.snapshotMtimeMs || stat.size !== this.snapshotSize;
     } catch {
       changed = this.snapshotSize !== -1;
@@ -1741,7 +1633,7 @@ var AuthStorage = class {
    */
   async rememberSnapshot() {
     try {
-      const stat = await fs4.stat(this.filePath);
+      const stat = await fs3.stat(this.filePath);
       this.snapshotMtimeMs = stat.mtimeMs;
       this.snapshotSize = stat.size;
       this.snapshotIno = stat.ino;
@@ -1982,7 +1874,7 @@ var AuthStorage = class {
 };
 async function readAuthData(filePath) {
   try {
-    const content = await fs4.readFile(filePath, "utf-8");
+    const content = await fs3.readFile(filePath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     if (error.code === "ENOENT") return {};
@@ -1992,10 +1884,10 @@ async function readAuthData(filePath) {
 async function atomicWriteFile(filePath, content) {
   const tmpPath = `${filePath}.${process.pid}.${Date.now()}.${crypto5.randomUUID().slice(0, 8)}.tmp`;
   try {
-    await fs4.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
-    await fs4.rename(tmpPath, filePath);
+    await fs3.writeFile(tmpPath, content, { encoding: "utf-8", mode: 384 });
+    await fs3.rename(tmpPath, filePath);
   } catch (err) {
-    await fs4.unlink(tmpPath).catch(() => {
+    await fs3.unlink(tmpPath).catch(() => {
     });
     throw err;
   }
@@ -2869,15 +2761,9 @@ export {
   loginKimi,
   refreshKimiToken,
   generatePKCE,
-  openLog,
-  getSessionId,
-  isLoggerOpen,
-  log,
-  registerLogCleanup,
-  closeLogger,
-  pendingClaudeCodeVersionRefresh,
   getClaudeCodeVersion,
   getClaudeCliUserAgent,
+  pendingClaudeCodeVersionRefresh,
   loginAnthropic,
   refreshAnthropicToken,
   loginOpenAI,
@@ -2890,6 +2776,12 @@ export {
   loginXai,
   refreshXaiToken,
   withFileLock,
+  openLog,
+  getSessionId,
+  isLoggerOpen,
+  log,
+  registerLogCleanup,
+  closeLogger,
   HIDDEN_PROVIDERS,
   isHiddenProvider,
   MOONSHOT_OAUTH_KEY,
@@ -2926,4 +2818,4 @@ export {
   getDefaultThinkingLevel,
   getSummaryModel
 };
-//# sourceMappingURL=chunk-HMJZM62P.js.map
+//# sourceMappingURL=chunk-5ZYOOESD.js.map