@chrysb/alphaclaw 0.8.4 → 0.8.6

package/lib/server/model-catalog-cache.js

@@ -0,0 +1,251 @@
+const fs = require("fs");
+const path = require("path");
+const { ALPHACLAW_DIR, kFallbackOnboardingModels } = require("./constants");
+
+const kModelCatalogCacheVersion = 1;
+const kModelCatalogRefreshBackoffMs = 30 * 1000;
+const kDefaultCachePath = path.join(ALPHACLAW_DIR, "cache", "model-catalog.json");
+
+const createResponse = ({
+  source = "fallback",
+  fetchedAt = null,
+  stale = false,
+  refreshing = false,
+  models = [],
+} = {}) => ({
+  ok: true,
+  source,
+  fetchedAt,
+  stale,
+  refreshing,
+  models,
+});
+
+const normalizeCachedModels = ({
+  models,
+  normalizeOnboardingModels = (items) => items,
+} = {}) =>
+  normalizeOnboardingModels(
+    (Array.isArray(models) ? models : []).map((model) => ({
+      key: model?.key,
+      name: model?.label || model?.name || model?.key,
+    })),
+  );
+
+const normalizeCacheEntry = ({
+  raw,
+  normalizeOnboardingModels = (items) => items,
+} = {}) => {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const fetchedAt = Number(raw.fetchedAt || 0);
+  const models = normalizeCachedModels({
+    models: raw.models,
+    normalizeOnboardingModels,
+  });
+  if (!Number.isFinite(fetchedAt) || fetchedAt <= 0 || models.length === 0) {
+    return null;
+  }
+  return {
+    version: kModelCatalogCacheVersion,
+    fetchedAt,
+    models,
+  };
+};
+
+const createModelCatalogCache = ({
+  fsModule = fs,
+  pathModule = path,
+  shellCmd,
+  gatewayEnv = () => ({}),
+  parseJsonFromNoisyOutput = () => ({}),
+  normalizeOnboardingModels = (items) => items,
+  fallbackModels = kFallbackOnboardingModels,
+  cachePath = kDefaultCachePath,
+  refreshBackoffMs = kModelCatalogRefreshBackoffMs,
+  now = () => Date.now(),
+  setTimeoutFn = setTimeout,
+  clearTimeoutFn = clearTimeout,
+  logger = console,
+} = {}) => {
+  let cacheLoaded = false;
+  let memoryCache = null;
+  let cacheIsStale = false;
+  let refreshPromise = null;
+  let retryTimer = null;
+  let backoffUntilMs = 0;
+
+  const clearRetryTimer = () => {
+    if (!retryTimer) return;
+    clearTimeoutFn(retryTimer);
+    retryTimer = null;
+  };
+
+  const isRefreshPending = () => !!refreshPromise || !!retryTimer;
+
+  const setCacheEntry = (entry, { fresh = false } = {}) => {
+    memoryCache = entry;
+    cacheLoaded = true;
+    cacheIsStale = !fresh;
+    backoffUntilMs = 0;
+    clearRetryTimer();
+    return memoryCache;
+  };
+
+  const readDiskCache = () => {
+    if (cacheLoaded) return memoryCache;
+    cacheLoaded = true;
+    try {
+      const raw = JSON.parse(fsModule.readFileSync(cachePath, "utf8"));
+      const entry = normalizeCacheEntry({
+        raw,
+        normalizeOnboardingModels,
+      });
+      if (!entry) return null;
+      memoryCache = entry;
+      cacheIsStale = true;
+      return memoryCache;
+    } catch {
+      memoryCache = null;
+      cacheIsStale = false;
+      return null;
+    }
+  };
+
+  const writeDiskCache = (entry) => {
+    fsModule.mkdirSync(pathModule.dirname(cachePath), { recursive: true });
+    fsModule.writeFileSync(
+      cachePath,
+      `${JSON.stringify(entry, null, 2)}\n`,
+      "utf8",
+    );
+  };
+
+  const loadFreshCatalog = async () => {
+    const output = await shellCmd("openclaw models list --all --json", {
+      env: gatewayEnv(),
+      timeout: 20000,
+    });
+    const parsed = parseJsonFromNoisyOutput(output);
+    const models = normalizeOnboardingModels(parsed?.models || []);
+    if (models.length === 0) {
+      throw new Error("No models found");
+    }
+    const entry = {
+      version: kModelCatalogCacheVersion,
+      fetchedAt: now(),
+      models,
+    };
+    writeDiskCache(entry);
+    setCacheEntry(entry, { fresh: true });
+    return entry;
+  };
+
+  const scheduleRetry = () => {
+    if (!memoryCache || retryTimer) return;
+    const delayMs = Math.max(backoffUntilMs - now(), 0);
+    retryTimer = setTimeoutFn(() => {
+      retryTimer = null;
+      if (!memoryCache || !cacheIsStale || refreshPromise) return;
+      void startBackgroundRefresh();
+    }, delayMs);
+    if (typeof retryTimer?.unref === "function") retryTimer.unref();
+  };
+
+  const handleRefreshFailure = (err) => {
+    if (memoryCache) {
+      cacheIsStale = true;
+      backoffUntilMs = now() + refreshBackoffMs;
+      scheduleRetry();
+      logger.error?.(
+        `[models] Failed to refresh cached models: ${err.message || String(err)}`,
+      );
+      return;
+    }
+    logger.error?.(
+      `[models] Failed to load dynamic models: ${err.message || String(err)}`,
+    );
+  };
+
+  const startBackgroundRefresh = () => {
+    readDiskCache();
+    if (!memoryCache) return null;
+    if (refreshPromise) return refreshPromise;
+    if (retryTimer) return null;
+    if (backoffUntilMs > now()) {
+      scheduleRetry();
+      return null;
+    }
+    refreshPromise = Promise.resolve()
+      .then(() => loadFreshCatalog())
+      .catch((err) => {
+        handleRefreshFailure(err);
+        return null;
+      })
+      .finally(() => {
+        refreshPromise = null;
+      });
+    return refreshPromise;
+  };
+
+  return {
+    async getCatalogResponse() {
+      readDiskCache();
+      if (memoryCache && !cacheIsStale) {
+        return createResponse({
+          source: "openclaw",
+          fetchedAt: memoryCache.fetchedAt,
+          stale: false,
+          refreshing: false,
+          models: memoryCache.models,
+        });
+      }
+      if (memoryCache) {
+        startBackgroundRefresh();
+        return createResponse({
+          source: "cache",
+          fetchedAt: memoryCache.fetchedAt,
+          stale: true,
+          refreshing: isRefreshPending(),
+          models: memoryCache.models,
+        });
+      }
+      try {
+        const freshEntry = await loadFreshCatalog();
+        return createResponse({
+          source: "openclaw",
+          fetchedAt: freshEntry.fetchedAt,
+          stale: false,
+          refreshing: false,
+          models: freshEntry.models,
+        });
+      } catch (err) {
+        handleRefreshFailure(err);
+        return createResponse({
+          source: "fallback",
+          fetchedAt: null,
+          stale: false,
+          refreshing: false,
+          models: fallbackModels,
+        });
+      }
+    },
+
+    markStale() {
+      readDiskCache();
+      if (!memoryCache) return;
+      cacheIsStale = true;
+      backoffUntilMs = 0;
+      clearRetryTimer();
+    },
+  };
+};
+
+module.exports = {
+  createModelCatalogCache,
+  createResponse,
+  normalizeCachedModels,
+  normalizeCacheEntry,
+  kModelCatalogCacheVersion,
+  kModelCatalogRefreshBackoffMs,
+  kDefaultCachePath,
+};

package/lib/server/routes/models.js

@@ -1,4 +1,5 @@
 const { kFallbackOnboardingModels } = require("../constants");
+const { createModelCatalogCache } = require("../model-catalog-cache");
 
 const runModelsGitSync = async (shellCmd) => {
   if (typeof shellCmd !== "function") return null;
@@ -22,6 +23,13 @@ const registerModelRoutes = ({
   readEnvFile,
   writeEnvFile,
   reloadEnv,
+  modelCatalogCache = createModelCatalogCache({
+    shellCmd,
+    gatewayEnv,
+    parseJsonFromNoisyOutput,
+    normalizeOnboardingModels,
+    fallbackModels: kFallbackOnboardingModels,
+  }),
 }) => {
   const upsertEnvVar = (items, key, value) => {
     const next = Array.isArray(items) ? [...items] : [];
@@ -154,29 +162,8 @@ const registerModelRoutes = ({
   // ── Existing CLI-backed catalog/status routes ──
 
   app.get("/api/models", async (req, res) => {
-    try {
-      const output = await shellCmd("openclaw models list --all --json", {
-        env: gatewayEnv(),
-        timeout: 20000,
-      });
-      const parsed = parseJsonFromNoisyOutput(output);
-      const models = normalizeOnboardingModels(parsed?.models || []);
-      if (models.length > 0) {
-        return res.json({ ok: true, source: "openclaw", models });
-      }
-      return res.json({
-        ok: true,
-        source: "fallback",
-        models: kFallbackOnboardingModels,
-      });
-    } catch (err) {
-      console.error("[models] Failed to load dynamic models:", err.message);
-      return res.json({
-        ok: true,
-        source: "fallback",
-        models: kFallbackOnboardingModels,
-      });
-    }
+    const response = await modelCatalogCache.getCatalogResponse();
+    return res.json(response);
   });
 
   app.get("/api/models/status", async (req, res) => {
@@ -210,6 +197,7 @@ const registerModelRoutes = ({
         env: gatewayEnv(),
         timeout: 30000,
       });
+      modelCatalogCache.markStale();
       res.json({ ok: true });
     } catch (err) {
       res
@@ -286,6 +274,7 @@ const registerModelRoutes = ({
       authProfiles.syncConfigAuthReferencesForAgent(agentId);
 
       const syncWarning = await runModelsGitSync(shellCmd);
+      modelCatalogCache.markStale();
       res.json({
         ok: true,
         ...(syncWarning ? { syncWarning } : {}),
@@ -338,6 +327,7 @@ const registerModelRoutes = ({
       const agentId = req.query.agentId || undefined;
       authProfiles.upsertProfile(profileId, credential, agentId);
       syncEnvVarsForProfiles([{ id: profileId, ...credential }]);
+      modelCatalogCache.markStale();
       res.json({ ok: true });
     } catch (err) {
       res
@@ -359,6 +349,7 @@ const registerModelRoutes = ({
     try {
       const agentId = req.query.agentId || undefined;
       const removed = authProfiles.removeProfile(profileId, agentId);
+      modelCatalogCache.markStale();
       res.json({ ok: true, removed });
     } catch (err) {
       res

package/lib/server/routes/webhooks.js

@@ -29,13 +29,24 @@ const mergeWebhookAndSummary = ({ webhook, summary }) => {
   const totalCount = Number(summary?.totalCount || 0);
   const errorCount = Number(summary?.errorCount || 0);
   const successCount = Number(summary?.successCount || 0);
+  const recentTotalCount = Number(summary?.recentTotalCount || 0);
+  const recentErrorCount = Number(summary?.recentErrorCount || 0);
+  const recentSuccessCount = Number(summary?.recentSuccessCount || 0);
+  const healthWindowSize = Number(summary?.healthWindowSize || 0);
   return {
     ...webhook,
     lastReceived: summary?.lastReceived || null,
     totalCount,
     successCount,
     errorCount,
-    health: buildHealth({ totalCount, errorCount }),
+    recentTotalCount,
+    recentSuccessCount,
+    recentErrorCount,
+    healthWindowSize,
+    health: buildHealth({
+      totalCount: recentTotalCount || totalCount,
+      errorCount: recentTotalCount > 0 ? recentErrorCount : errorCount,
+    }),
   };
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "publishConfig": {
     "access": "public"
   },