@prestyj/core 5.25.0 → 5.25.1

package/dist/index.cjs

@@ -48,6 +48,7 @@ __export(index_exports, {
   clearLocalDiscoveryCache: () => clearLocalDiscoveryCache,
   clearRuntimeModels: () => clearRuntimeModels,
   closeLogger: () => closeLogger,
+  compareClaudeCodeVersions: () => compareClaudeCodeVersions,
   createAutoUpdater: () => createAutoUpdater,
   decodeOggOpus: () => decodeOggOpus,
   discoverLocalModels: () => discoverLocalModels,
@@ -101,6 +102,7 @@ __export(index_exports, {
   probeEndpoint: () => probeEndpoint,
   providerStorageKeys: () => providerStorageKeys,
   readStoredBaseUrlSync: () => readStoredBaseUrlSync,
+  recordRequiredClaudeCodeVersion: () => recordRequiredClaudeCodeVersion,
   refreshAnthropicToken: () => refreshAnthropicToken,
   refreshGeminiToken: () => refreshGeminiToken,
   refreshKimiToken: () => refreshKimiToken,
@@ -365,7 +367,7 @@ async function refreshKimiToken(refreshToken) {
 
 // src/auth-storage.ts
 var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_crypto6 = __toESM(require("crypto"), 1);
 
 // src/oauth/anthropic.ts
@@ -391,6 +393,7 @@ async function generatePKCE() {
 
 // src/claude-code-version.ts
 var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_fs3 = require("fs");
 var import_node_path4 = __toESM(require("path"), 1);
 
 // src/logger.ts
@@ -518,19 +521,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 import_node_path4.default.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 import_promises.default.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;
@@ -541,7 +566,11 @@ async function readDiskCache() {
 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 });
+    await import_promises.default.writeFile(
+      cachePath(),
+      JSON.stringify({ ...data, ...versionFloor ? { minVersion: versionFloor } : {} }),
+      { mode: 384 }
+    );
   } catch (err) {
     log(
       "WARN",
@@ -567,6 +596,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;
@@ -574,18 +616,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",
@@ -600,6 +650,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;
+    (0, import_node_fs3.mkdirSync)(dir, { recursive: true, mode: 448 });
+    let existing = {};
+    try {
+      existing = JSON.parse((0, import_node_fs3.readFileSync)(cachePath(), "utf-8"));
+    } catch {
+    }
+    (0, import_node_fs3.writeFileSync)(
+      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)`;
@@ -1587,7 +1675,7 @@ function activeBaseUrlEntry(data, provider) {
 }
 function readStoredBaseUrlSync(authFile, provider) {
   try {
-    const data = JSON.parse((0, import_node_fs3.readFileSync)(authFile, "utf-8"));
+    const data = JSON.parse((0, import_node_fs4.readFileSync)(authFile, "utf-8"));
     return activeBaseUrlEntry(data, provider)?.baseUrl;
   } catch {
     return void 0;
@@ -2870,7 +2958,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) {
@@ -3111,7 +3199,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)));
@@ -3684,7 +3772,7 @@ 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_fs5 = __toESM(require("fs"), 1);
 var import_node_path5 = __toESM(require("path"), 1);
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS2 = 1e4;
@@ -3718,7 +3806,7 @@ function createAutoUpdater(config) {
   }
   function readState() {
     try {
-      const raw = import_node_fs4.default.readFileSync(stateFilePath(), "utf-8");
+      const raw = import_node_fs5.default.readFileSync(stateFilePath(), "utf-8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -3727,8 +3815,8 @@ 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.writeFileSync(filePath, JSON.stringify(state));
+      import_node_fs5.default.mkdirSync(import_node_path5.default.dirname(filePath), { recursive: true, mode: 448 });
+      import_node_fs5.default.writeFileSync(filePath, JSON.stringify(state));
     } catch {
     }
   }
@@ -3870,6 +3958,7 @@ function createAutoUpdater(config) {
   clearLocalDiscoveryCache,
   clearRuntimeModels,
   closeLogger,
+  compareClaudeCodeVersions,
   createAutoUpdater,
   decodeOggOpus,
   discoverLocalModels,
@@ -3923,6 +4012,7 @@ function createAutoUpdater(config) {
   probeEndpoint,
   providerStorageKeys,
   readStoredBaseUrlSync,
+  recordRequiredClaudeCodeVersion,
   refreshAnthropicToken,
   refreshGeminiToken,
   refreshKimiToken,