@chrysb/alphaclaw 0.8.5 → 0.8.6

package/lib/public/js/components/welcome/use-welcome.js

@@ -6,6 +6,7 @@ import {
   applyImport,
   fetchModels,
 } from "../../lib/api.js";
+import { useCachedFetch } from "../../hooks/use-cached-fetch.js";
 import {
   getModelProvider,
   getAuthProviderFromModelProvider,
@@ -13,8 +14,15 @@ import {
   getVisibleAiFieldKeys,
   kProviderAuthFields,
 } from "../../lib/model-config.js";
+import {
+  getInitialOnboardingModelKey,
+  getModelCatalogModels,
+  kModelCatalogCacheKey,
+} from "../../lib/model-catalog.js";
 import {
   kWelcomeGroups,
+  getWelcomeGroupError,
+  findFirstInvalidWelcomeGroup,
   isValidGithubRepoInput,
   kGithubFlowFresh,
   kGithubFlowImport,
@@ -76,11 +84,18 @@ const normalizePlaceholderReview = (review) => {
 export const useWelcome = ({ onComplete }) => {
   const kSetupStepIndex = kWelcomeGroups.length;
   const kPairingStepIndex = kSetupStepIndex + 1;
-  const { vals, setVals, setValue, step, setStep, setupError, setSetupError } =
-    useWelcomeStorage({
-      kSetupStepIndex,
-      kPairingStepIndex,
-    });
+  const {
+    vals,
+    setVals,
+    setValue: setStoredValue,
+    step,
+    setStep,
+    setupError,
+    setSetupError,
+  } = useWelcomeStorage({
+    kSetupStepIndex,
+    kPairingStepIndex,
+  });
   const [models, setModels] = useState([]);
   const [modelsLoading, setModelsLoading] = useState(true);
   const [modelsError, setModelsError] = useState(null);
@@ -110,6 +125,14 @@ export const useWelcome = ({ onComplete }) => {
   const [importScanResult, setImportScanResult] = useState(null);
   const [importScanning, setImportScanning] = useState(false);
   const [importError, setImportError] = useState(null);
+  const modelsFetchState = useCachedFetch(kModelCatalogCacheKey, fetchModels, {
+    maxAgeMs: 30000,
+  });
+
+  const setValue = (key, value) => {
+    if (formError) setFormError(null);
+    setStoredValue(key, value);
+  };
 
   const setImportStep = (nextStep) => {
     setImportStepState(nextStep);
@@ -129,21 +152,54 @@ export const useWelcome = ({ onComplete }) => {
   };
 
   useEffect(() => {
-    fetchModels()
-      .then((result) => {
-        const list = Array.isArray(result.models) ? result.models : [];
-        const featured = getFeaturedModels(list);
-        setModels(list);
-        if (!vals.MODEL_KEY && list.length > 0) {
-          const defaultModel = featured[0] || list[0];
-          setVals((prev) => ({ ...prev, MODEL_KEY: defaultModel.key }));
-        }
-      })
-      .catch(() => setModelsError("Failed to load models"))
-      .finally(() => setModelsLoading(false));
-  }, []);
+    const list = getModelCatalogModels(modelsFetchState.data);
+    if (!modelsFetchState.data) return;
+    setModels(list);
+    setModelsError(list.length > 0 ? null : "No models found");
+    const defaultModelKey = getInitialOnboardingModelKey({
+      catalog: list,
+      currentModelKey: vals.MODEL_KEY,
+    });
+    if (!vals.MODEL_KEY && defaultModelKey) {
+      setVals((prev) => ({ ...prev, MODEL_KEY: defaultModelKey }));
+    }
+  }, [modelsFetchState.data, setVals, vals.MODEL_KEY]);
+
+  useEffect(() => {
+    const hasModels = getModelCatalogModels(modelsFetchState.data).length > 0;
+    setModelsLoading(modelsFetchState.loading && !hasModels);
+  }, [modelsFetchState.data, modelsFetchState.loading]);
+
+  useEffect(() => {
+    if (!modelsFetchState.error) return;
+    setModelsError("Failed to load models");
+    setModelsLoading(false);
+  }, [modelsFetchState.error]);
+
+  const getValidationContext = (currentVals = {}) => {
+    const currentSelectedProvider = getModelProvider(
+      String(currentVals.MODEL_KEY || "").trim(),
+    );
+    const currentSelectedAuthProvider =
+      getAuthProviderFromModelProvider(currentSelectedProvider);
+    const currentProviderAuthFields =
+      kProviderAuthFields[currentSelectedAuthProvider] || [];
+    const currentHasAi =
+      currentSelectedProvider === "openai-codex"
+        ? !!codexStatus.connected
+        : currentProviderAuthFields.some((field) =>
+            !!String(currentVals[field.key] || "").trim(),
+          );
 
-  const selectedProvider = getModelProvider(vals.MODEL_KEY);
+    return {
+      hasAi: currentHasAi,
+      selectedProvider: currentSelectedProvider,
+      codexLoading,
+    };
+  };
+
+  const validationContext = getValidationContext(vals);
+  const { selectedProvider, hasAi } = validationContext;
   const placeholderReview = normalizePlaceholderReview(
     vals[kImportPlaceholderReviewKey],
   );
@@ -164,23 +220,10 @@ export const useWelcome = ({ onComplete }) => {
   const canToggleFullCatalog =
     featuredModels.length > 0 && models.length > featuredModels.length;
   const visibleAiFieldKeys = getVisibleAiFieldKeys(selectedProvider);
-  const selectedAuthProvider = getAuthProviderFromModelProvider(selectedProvider);
-  const selectedProviderAuthFields = kProviderAuthFields[selectedAuthProvider] || [];
-  const hasAi =
-    selectedProvider === "openai-codex"
-      ? !!codexStatus.connected
-      : selectedProviderAuthFields.some(
-          (field) => !!String(vals[field.key] || "").trim(),
-        );
-
-  const allValid = kWelcomeGroups.every((group) => group.validate(vals, { hasAi }));
   const isPreStep = step === -1;
   const isSetupStep = step === kSetupStepIndex;
   const isPairingStep = step === kPairingStepIndex;
   const activeGroup = step >= 0 && step < kSetupStepIndex ? kWelcomeGroups[step] : null;
-  const currentGroupValid = activeGroup
-    ? activeGroup.validate(vals, { hasAi })
-    : false;
   const selectedPairingChannel = String(
     vals[kPairingChannelKey] || getPreferredPairingChannel(vals),
   );
@@ -202,7 +245,21 @@ export const useWelcome = ({ onComplete }) => {
   const handleSubmit = async () => {
     const { normalizedVals, didChange } = normalizeOnboardingVals(vals);
     if (didChange) setVals(normalizedVals);
-    if (!kWelcomeGroups.every((group) => group.validate(normalizedVals, { hasAi }))) {
+    const submitValidationContext = getValidationContext(normalizedVals);
+    const invalidGroup = findFirstInvalidWelcomeGroup(
+      normalizedVals,
+      submitValidationContext,
+    );
+    if (invalidGroup) {
+      setFormError(
+        getWelcomeGroupError(
+          invalidGroup.id,
+          normalizedVals,
+          submitValidationContext,
+        ),
+      );
+      setSetupError(null);
+      setStep(kWelcomeGroups.findIndex((group) => group.id === invalidGroup.id));
       return;
     }
     if (loading) return;
@@ -309,7 +366,17 @@ export const useWelcome = ({ onComplete }) => {
   const goNext = async () => {
     const { normalizedVals, didChange } = normalizeOnboardingVals(vals);
     if (didChange) setVals(normalizedVals);
-    if (!activeGroup || !activeGroup.validate(normalizedVals, { hasAi })) return;
+    if (!activeGroup) return;
+    const stepValidationContext = getValidationContext(normalizedVals);
+    const stepValidationError = getWelcomeGroupError(
+      activeGroup.id,
+      normalizedVals,
+      stepValidationContext,
+    );
+    if (stepValidationError) {
+      setFormError(stepValidationError);
+      return;
+    }
     setFormError(null);
     if (activeGroup.id === "github") {
       const githubFlow = normalizedVals._GITHUB_FLOW || kGithubFlowFresh;
@@ -545,12 +612,10 @@ export const useWelcome = ({ onComplete }) => {
       canToggleFullCatalog,
       visibleAiFieldKeys,
       hasAi,
-      allValid,
       isPreStep,
       isSetupStep,
       isPairingStep,
       activeGroup,
-      currentGroupValid,
       selectedPairingChannel,
       placeholderReview,
       isImportStep,

package/lib/public/js/lib/codex-oauth-window.js

@@ -0,0 +1,22 @@
+const kCodexAuthStartPath = "/auth/codex/start";
+const kCodexAuthWindowName = "codex-auth";
+const kCodexAuthPopupFeatures = "popup=yes,width=640,height=780";
+const kCodexAuthCallbackMessageType = "callback-input";
+
+export const openCodexAuthWindow = () => {
+  const popup = window.open(
+    kCodexAuthStartPath,
+    kCodexAuthWindowName,
+    kCodexAuthPopupFeatures,
+  );
+  if (!popup || popup.closed) {
+    window.location.href = kCodexAuthStartPath;
+    return null;
+  }
+  return popup;
+};
+
+export const isCodexAuthCallbackMessage = (value) =>
+  value?.codex === kCodexAuthCallbackMessageType &&
+  typeof value.input === "string" &&
+  value.input.trim().length > 0;

package/lib/public/js/lib/model-catalog.js

@@ -0,0 +1,20 @@
+import { getFeaturedModels } from "./model-config.js";
+
+export const kModelCatalogCacheKey = "/api/models";
+export const kModelCatalogPollIntervalMs = 3000;
+
+export const getModelCatalogModels = (payload) =>
+  Array.isArray(payload?.models) ? payload.models : [];
+
+export const isModelCatalogRefreshing = (payload) =>
+  Boolean(payload?.refreshing);
+
+export const getInitialOnboardingModelKey = ({
+  catalog = [],
+  currentModelKey = "",
+} = {}) => {
+  const normalizedCurrent = String(currentModelKey || "").trim();
+  if (normalizedCurrent) return normalizedCurrent;
+  const featuredModels = getFeaturedModels(catalog);
+  return String(featuredModels[0]?.key || catalog[0]?.key || "");
+};

package/lib/public/js/lib/storage-keys.js

@@ -6,6 +6,7 @@
 
 // --- UI settings (single JSON blob containing sub-keys) ---
 export const kUiSettingsStorageKey = "alphaclaw.ui.settings";
+export const kThemeStorageKey = "alphaclaw.ui.theme";
 
 // --- Browse / file viewer ---
 export const kFileViewerModeStorageKey = "alphaclaw.browse.viewerMode";
@@ -30,4 +31,3 @@ export const kAgentLastSessionKey = "alphaclaw.agent.lastSessionKey";
 
 // --- Chat ---
 export const kChatSessionDraftsStorageKey = "alphaclaw.chat.sessionDrafts";
-

package/lib/public/login.html

@@ -11,6 +11,14 @@
     <link rel="icon" type="image/svg+xml" href="./img/logo.svg" />
     <link rel="stylesheet" href="./css/theme.css" />
     <link rel="stylesheet" href="./css/tailwind.generated.css" />
+    <script>
+      try {
+        var t = localStorage.getItem("alphaclaw.ui.theme");
+        if (t === "system") t = window.matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
+        else if (t !== "dark" && t !== "light") t = "dark";
+        document.documentElement.dataset.theme = t;
+      } catch {}
+    </script>
   </head>
   <body class="min-h-screen flex items-center justify-center p-4">
     <div class="max-w-sm w-full relative z-10">
@@ -53,10 +61,6 @@
       </form>
     </div>
     <script>
-      try {
-        window.localStorage?.clear?.();
-      } catch {}
-
       const formEl = document.getElementById("login-form");
       const passwordEl = document.getElementById("password");
       const submitButtonEl = document.getElementById("submit-btn");

package/lib/public/setup.html

@@ -16,6 +16,15 @@
     <link rel="stylesheet" href="./css/agents.css" />
     <link rel="stylesheet" href="./css/chat.css" />
     <link rel="stylesheet" href="./css/cron.css" />
+    <script>
+      // Apply saved theme before render to prevent flash.
+      try {
+        var t = localStorage.getItem("alphaclaw.ui.theme");
+        if (t === "system") t = window.matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
+        else if (t !== "dark" && t !== "light") t = "dark";
+        document.documentElement.dataset.theme = t;
+      } catch {}
+    </script>
   </head>
   <body>
     <div id="app"></div>

package/lib/server/db/webhooks/index.js

@@ -10,6 +10,7 @@ let pruneTimer = null;
 const kDefaultRequestLimit = 50;
 const kMaxRequestLimit = 200;
 const kPruneIntervalMs = 12 * 60 * 60 * 1000;
+const kHealthSummaryWindow = 25;
 
 const ensureDb = () => {
   if (!db) throw new Error("Webhooks DB not initialized");
@@ -202,22 +203,61 @@ const getHookSummaries = () => {
   const database = ensureDb();
   const rows = database
     .prepare(`
+      WITH ranked_requests AS (
+        SELECT
+          hook_name,
+          created_at,
+          gateway_status,
+          ROW_NUMBER() OVER (
+            PARTITION BY hook_name
+            ORDER BY created_at DESC, id DESC
+          ) AS row_num
+        FROM webhook_requests
+      ),
+      overall_counts AS (
+        SELECT
+          hook_name,
+          MAX(created_at) AS last_received,
+          COUNT(*) AS total_count,
+          SUM(CASE WHEN gateway_status >= 200 AND gateway_status < 300 THEN 1 ELSE 0 END) AS success_count,
+          SUM(CASE WHEN gateway_status IS NULL OR gateway_status < 200 OR gateway_status >= 300 THEN 1 ELSE 0 END) AS error_count
+        FROM webhook_requests
+        GROUP BY hook_name
+      ),
+      recent_counts AS (
+        SELECT
+          hook_name,
+          COUNT(*) AS recent_total_count,
+          SUM(CASE WHEN gateway_status >= 200 AND gateway_status < 300 THEN 1 ELSE 0 END) AS recent_success_count,
+          SUM(CASE WHEN gateway_status IS NULL OR gateway_status < 200 OR gateway_status >= 300 THEN 1 ELSE 0 END) AS recent_error_count
+        FROM ranked_requests
+        WHERE row_num <= $health_window
+        GROUP BY hook_name
+      )
       SELECT
-        hook_name,
-        MAX(created_at) AS last_received,
-        COUNT(*) AS total_count,
-        SUM(CASE WHEN gateway_status >= 200 AND gateway_status < 300 THEN 1 ELSE 0 END) AS success_count,
-        SUM(CASE WHEN gateway_status IS NULL OR gateway_status < 200 OR gateway_status >= 300 THEN 1 ELSE 0 END) AS error_count
-      FROM webhook_requests
-      GROUP BY hook_name
+        overall_counts.hook_name,
+        overall_counts.last_received,
+        overall_counts.total_count,
+        overall_counts.success_count,
+        overall_counts.error_count,
+        COALESCE(recent_counts.recent_total_count, 0) AS recent_total_count,
+        COALESCE(recent_counts.recent_success_count, 0) AS recent_success_count,
+        COALESCE(recent_counts.recent_error_count, 0) AS recent_error_count
+      FROM overall_counts
+      LEFT JOIN recent_counts
+        ON recent_counts.hook_name = overall_counts.hook_name
     `)
-    .all();
+    .all({ $health_window: kHealthSummaryWindow });
   return rows.map((row) => ({
     hookName: row.hook_name,
     lastReceived: row.last_received || null,
     totalCount: Number(row.total_count || 0),
     successCount: Number(row.success_count || 0),
     errorCount: Number(row.error_count || 0),
+    recentTotalCount: Number(row.recent_total_count || 0),
+    recentSuccessCount: Number(row.recent_success_count || 0),
+    recentErrorCount: Number(row.recent_error_count || 0),
+    healthWindowSize: kHealthSummaryWindow,
   }));
 };
 

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,
+};