@prestyj/core 5.25.0 → 5.25.1

package/dist/{chunk-GDM5Q7SA.js → chunk-THUBQC6I.js}

@@ -222,7 +222,7 @@ async function refreshKimiToken(refreshToken) {
 
 // src/auth-storage.ts
 import fs4 from "fs/promises";
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import crypto5 from "crypto";
 
 // src/oauth/anthropic.ts
@@ -248,6 +248,7 @@ async function generatePKCE() {
 
 // src/claude-code-version.ts
 import fs2 from "fs/promises";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import path3 from "path";
 
 // src/logger.ts
@@ -375,19 +376,41 @@ function closeLogger(opts) {
 
 // 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 CACHE_FRESH_MS = 60 * 60 * 1e3;
+var CACHE_HARD_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
-var FALLBACK_VERSION = "2.1.88";
+var FALLBACK_VERSION = "2.1.280";
 var memoryCache = null;
 var inflight = null;
+var backgroundRefresh = null;
+var versionFloor = null;
 function cachePath() {
   return path3.join(getAppPaths().agentDir, "claude-code-version.json");
 }
+function compareClaudeCodeVersions(a, b) {
+  const parse = (v) => v.split(".").map((part) => Number.parseInt(part, 10)).map((n) => Number.isFinite(n) ? n : 0);
+  const left = parse(a);
+  const right = parse(b);
+  for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function applyFloor(version) {
+  if (!versionFloor) return version;
+  return compareClaudeCodeVersions(versionFloor, version) > 0 ? versionFloor : version;
+}
 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") {
+      if (typeof parsed.minVersion === "string") {
+        if (!versionFloor || compareClaudeCodeVersions(parsed.minVersion, versionFloor) > 0) {
+          versionFloor = parsed.minVersion;
+        }
+      }
       return parsed;
     }
     return null;
@@ -398,7 +421,11 @@ async function readDiskCache() {
 async function writeDiskCache(data) {
   try {
     await fs2.mkdir(getAppPaths().agentDir, { recursive: true, mode: 448 });
-    await fs2.writeFile(cachePath(), JSON.stringify(data), { mode: 384 });
+    await fs2.writeFile(
+      cachePath(),
+      JSON.stringify({ ...data, ...versionFloor ? { minVersion: versionFloor } : {} }),
+      { mode: 384 }
+    );
   } catch (err) {
     log(
       "WARN",
@@ -424,6 +451,19 @@ async function fetchLatest() {
     clearTimeout(timer);
   }
 }
+function refreshInBackground() {
+  if (backgroundRefresh) return;
+  backgroundRefresh = (async () => {
+    const fetched = await fetchLatest();
+    if (fetched) {
+      await writeDiskCache({ version: fetched, fetchedAt: Date.now() });
+      memoryCache = { version: applyFloor(fetched), expiresAt: Date.now() + CACHE_FRESH_MS };
+    }
+  })().catch(() => {
+  }).finally(() => {
+    backgroundRefresh = null;
+  });
+}
 async function getClaudeCodeVersion() {
   if (memoryCache && Date.now() < memoryCache.expiresAt) {
     return memoryCache.version;
@@ -431,18 +471,26 @@ async function getClaudeCodeVersion() {
   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;
+    const age = disk ? Date.now() - disk.fetchedAt : Infinity;
+    if (disk && age < CACHE_FRESH_MS) {
+      const version = applyFloor(disk.version);
+      memoryCache = { version, expiresAt: Date.now() + CACHE_FRESH_MS };
+      return version;
+    }
+    if (disk && age < CACHE_HARD_MS) {
+      const version = applyFloor(disk.version);
+      memoryCache = { version, expiresAt: Date.now() + 5 * 60 * 1e3 };
+      refreshInBackground();
+      return 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 version = applyFloor(fetched);
+      memoryCache = { version, expiresAt: Date.now() + CACHE_FRESH_MS };
+      return version;
     }
-    const resolved = disk?.version ?? FALLBACK_VERSION;
+    const resolved = applyFloor(disk?.version ?? FALLBACK_VERSION);
     memoryCache = { version: resolved, expiresAt: Date.now() + 5 * 60 * 1e3 };
     log(
       "WARN",
@@ -457,6 +505,44 @@ async function getClaudeCodeVersion() {
     inflight = null;
   }
 }
+var REQUIRED_VERSION_PATTERN = /version\s+(\d+(?:\.\d+)+)\s+or\s+newer\s+is\s+required/i;
+function recordRequiredClaudeCodeVersion(message) {
+  const required = REQUIRED_VERSION_PATTERN.exec(message ?? "")?.[1];
+  if (!required) return null;
+  if (versionFloor && compareClaudeCodeVersions(required, versionFloor) <= 0) return versionFloor;
+  versionFloor = required;
+  memoryCache = null;
+  log(
+    "WARN",
+    "claude-code-version",
+    `Provider requires Claude Code >= ${required}; pinning User-Agent floor`
+  );
+  try {
+    const dir = getAppPaths().agentDir;
+    mkdirSync2(dir, { recursive: true, mode: 448 });
+    let existing = {};
+    try {
+      existing = JSON.parse(readFileSync2(cachePath(), "utf-8"));
+    } catch {
+    }
+    writeFileSync2(
+      cachePath(),
+      JSON.stringify({
+        version: existing.version ?? required,
+        fetchedAt: existing.fetchedAt ?? 0,
+        minVersion: required
+      }),
+      { mode: 384 }
+    );
+  } catch (err) {
+    log(
+      "WARN",
+      "claude-code-version",
+      `Failed to persist required version: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return required;
+}
 async function getClaudeCliUserAgent() {
   const version = await getClaudeCodeVersion();
   return `claude-cli/${version} (external, cli)`;
@@ -1444,7 +1530,7 @@ function activeBaseUrlEntry(data, provider) {
 }
 function readStoredBaseUrlSync(authFile, provider) {
   try {
-    const data = JSON.parse(readFileSync2(authFile, "utf-8"));
+    const data = JSON.parse(readFileSync3(authFile, "utf-8"));
     return activeBaseUrlEntry(data, provider)?.baseUrl;
   } catch {
     return void 0;
@@ -2613,7 +2699,9 @@ export {
   log,
   registerLogCleanup,
   closeLogger,
+  compareClaudeCodeVersions,
   getClaudeCodeVersion,
+  recordRequiredClaudeCodeVersion,
   getClaudeCliUserAgent,
   loginAnthropic,
   refreshAnthropicToken,
@@ -2657,4 +2745,4 @@ export {
   getSummaryModel,
   getFastModel
 };
-//# sourceMappingURL=chunk-GDM5Q7SA.js.map
+//# sourceMappingURL=chunk-THUBQC6I.js.map