@chrysb/alphaclaw 0.9.9 → 0.9.11

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

@@ -1,9 +1,12 @@
 const fs = require("fs");
 const path = require("path");
 const { ALPHACLAW_DIR, kFallbackOnboardingModels } = require("./constants");
+const { getCommandOutputCandidates } = require("./utils/command-output");
 
 const kModelCatalogCacheVersion = 1;
 const kModelCatalogRefreshBackoffMs = 30 * 1000;
+const kModelCatalogLoadTimeoutMs = 120 * 1000;
+const kModelCatalogBootstrapSource = "bootstrap";
 const kDefaultCachePath = path.join(ALPHACLAW_DIR, "cache", "model-catalog.json");
 
 const createResponse = ({
@@ -21,6 +24,12 @@ const createResponse = ({
   models,
 });
 
+const normalizeOpenclawVersion = (value) => {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
+};
+
 const normalizeCachedModels = ({
   models,
   normalizeOnboardingModels = (items) => items,
@@ -48,10 +57,20 @@ const normalizeCacheEntry = ({
   return {
     version: kModelCatalogCacheVersion,
     fetchedAt,
+    openclawVersion: normalizeOpenclawVersion(raw.openclawVersion),
     models,
   };
 };
 
+const parseCatalogModelsFromOutput = ({
+  rawOutput,
+  parseJsonFromNoisyOutput = () => ({}),
+  normalizeOnboardingModels = (items) => items,
+} = {}) => {
+  const parsed = parseJsonFromNoisyOutput(rawOutput);
+  return normalizeOnboardingModels(parsed?.models || []);
+};
+
 const createModelCatalogCache = ({
   fsModule = fs,
   pathModule = path,
@@ -59,6 +78,8 @@ const createModelCatalogCache = ({
   gatewayEnv = () => ({}),
   parseJsonFromNoisyOutput = () => ({}),
   normalizeOnboardingModels = (items) => items,
+  readOpenclawVersion = () => null,
+  shouldStartDynamicRefresh = () => true,
   fallbackModels = kFallbackOnboardingModels,
   cachePath = kDefaultCachePath,
   refreshBackoffMs = kModelCatalogRefreshBackoffMs,
@@ -74,6 +95,23 @@ const createModelCatalogCache = ({
   let retryTimer = null;
   let backoffUntilMs = 0;
 
+  const readCurrentOpenclawVersion = ({ refresh = false } = {}) => {
+    try {
+      return normalizeOpenclawVersion(readOpenclawVersion({ refresh }));
+    } catch {
+      return null;
+    }
+  };
+
+  const isCompatibleWithCurrentOpenclaw = ({
+    entry,
+    currentOpenclawVersion,
+  } = {}) => {
+    if (!entry) return false;
+    if (!currentOpenclawVersion) return true;
+    return entry.openclawVersion === currentOpenclawVersion;
+  };
+
   const clearRetryTimer = () => {
     if (!retryTimer) return;
     clearTimeoutFn(retryTimer);
@@ -82,6 +120,14 @@ const createModelCatalogCache = ({
 
   const isRefreshPending = () => !!refreshPromise || !!retryTimer;
 
+  const canStartDynamicRefresh = () => {
+    try {
+      return shouldStartDynamicRefresh() !== false;
+    } catch {
+      return false;
+    }
+  };
+
   const setCacheEntry = (entry, { fresh = false } = {}) => {
     memoryCache = entry;
     cacheLoaded = true;
@@ -121,41 +167,76 @@ const createModelCatalogCache = ({
   };
 
   const loadFreshCatalog = async () => {
-    const output = await shellCmd("openclaw models list --all --json", {
-      env: gatewayEnv(),
-      timeout: 30000,
-    });
-    const parsed = parseJsonFromNoisyOutput(output);
-    const models = normalizeOnboardingModels(parsed?.models || []);
+    const openclawVersion = readCurrentOpenclawVersion({ refresh: true });
+    let models = [];
+    let recoveredFromCommandError = false;
+    try {
+      const output = await shellCmd("openclaw models list --all --json", {
+        env: gatewayEnv(),
+        timeout: kModelCatalogLoadTimeoutMs,
+      });
+      models = parseCatalogModelsFromOutput({
+        rawOutput: output,
+        parseJsonFromNoisyOutput,
+        normalizeOnboardingModels,
+      });
+    } catch (err) {
+      for (const rawOutput of getCommandOutputCandidates(err)) {
+        models = parseCatalogModelsFromOutput({
+          rawOutput,
+          parseJsonFromNoisyOutput,
+          normalizeOnboardingModels,
+        });
+        if (models.length > 0) {
+          recoveredFromCommandError = true;
+          logger.warn?.(
+            `[models] Recovered model catalog from failed command output: ${err.message || String(err)}`,
+          );
+          break;
+        }
+      }
+      if (models.length === 0) throw err;
+    }
     if (models.length === 0) {
       throw new Error("No models found");
     }
     const entry = {
       version: kModelCatalogCacheVersion,
       fetchedAt: now(),
+      openclawVersion,
       models,
     };
     writeDiskCache(entry);
     setCacheEntry(entry, { fresh: true });
+    if (recoveredFromCommandError) {
+      backoffUntilMs = 0;
+      clearRetryTimer();
+    }
     return entry;
   };
 
   const scheduleRetry = () => {
-    if (!memoryCache || retryTimer) return;
+    if (!canStartDynamicRefresh()) {
+      clearRetryTimer();
+      return;
+    }
+    if (retryTimer) return;
     const delayMs = Math.max(backoffUntilMs - now(), 0);
     retryTimer = setTimeoutFn(() => {
       retryTimer = null;
-      if (!memoryCache || !cacheIsStale || refreshPromise) return;
+      if (!canStartDynamicRefresh()) return;
+      if (refreshPromise) return;
+      if (memoryCache && !cacheIsStale) return;
       void startBackgroundRefresh();
     }, delayMs);
     if (typeof retryTimer?.unref === "function") retryTimer.unref();
   };
 
   const handleRefreshFailure = (err) => {
+    backoffUntilMs = now() + refreshBackoffMs;
+    scheduleRetry();
     if (memoryCache) {
       cacheIsStale = true;
-      backoffUntilMs = now() + refreshBackoffMs;
-      scheduleRetry();
       logger.error?.(
         `[models] Failed to refresh cached models: ${err.message || String(err)}`,
       );
@@ -167,8 +248,11 @@ const createModelCatalogCache = ({
   };
 
   const startBackgroundRefresh = () => {
+    if (!canStartDynamicRefresh()) {
+      clearRetryTimer();
+      return null;
+    }
     readDiskCache();
-    if (!memoryCache) return null;
     if (refreshPromise) return refreshPromise;
     if (retryTimer) return null;
     if (backoffUntilMs > now()) {
@@ -190,6 +274,21 @@ const createModelCatalogCache = ({
   return {
     async getCatalogResponse() {
       readDiskCache();
+      if (memoryCache && !cacheIsStale) {
+        const currentOpenclawVersion = readCurrentOpenclawVersion({
+          refresh: true,
+        });
+        if (
+          !isCompatibleWithCurrentOpenclaw({
+            entry: memoryCache,
+            currentOpenclawVersion,
+          })
+        ) {
+          cacheIsStale = true;
+          backoffUntilMs = 0;
+          clearRetryTimer();
+        }
+      }
       if (memoryCache && !cacheIsStale) {
         return createResponse({
           source: "openclaw",
@@ -200,34 +299,25 @@ const createModelCatalogCache = ({
         });
       }
       if (memoryCache) {
-        startBackgroundRefresh();
+        const didStartRefresh = !!startBackgroundRefresh();
         return createResponse({
           source: "cache",
           fetchedAt: memoryCache.fetchedAt,
           stale: true,
-          refreshing: isRefreshPending(),
+          refreshing:
+            canStartDynamicRefresh() && (didStartRefresh || 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,
-        });
-      }
+      const didStartRefresh = !!startBackgroundRefresh();
+      return createResponse({
+        source: kModelCatalogBootstrapSource,
+        fetchedAt: null,
+        stale: true,
+        refreshing:
+          canStartDynamicRefresh() && (didStartRefresh || isRefreshPending()),
+        models: fallbackModels,
+      });
     },
 
     markStale() {
@@ -247,5 +337,7 @@ module.exports = {
   normalizeCacheEntry,
   kModelCatalogCacheVersion,
   kModelCatalogRefreshBackoffMs,
+  kModelCatalogLoadTimeoutMs,
+  kModelCatalogBootstrapSource,
   kDefaultCachePath,
 };

package/lib/server/onboarding/github.js

@@ -113,6 +113,42 @@ const findOwnedRepoByName = async ({
   return null;
 };
 
+const findAccessibleOrgByLogin = async ({ repoOwner, ghHeaders }) => {
+  const normalizedRepoOwner = String(repoOwner || "").trim().toLowerCase();
+  if (!normalizedRepoOwner) return null;
+
+  let nextUrl = "https://api.github.com/user/orgs?per_page=100&page=1";
+  while (nextUrl) {
+    const res = await fetch(nextUrl, { headers: ghHeaders });
+    if (!res.ok) {
+      const details = await parseGithubErrorMessage(res);
+      return {
+        error:
+          `Cannot verify organization "${repoOwner}" access: ${details}. ` +
+          "Check the owner name or use a token that can access that organization.",
+      };
+    }
+
+    const orgs = await res.json();
+    if (!Array.isArray(orgs)) {
+      return {
+        error: `Cannot verify organization "${repoOwner}" access from GitHub response.`,
+      };
+    }
+
+    const org = orgs.find(
+      (item) =>
+        String(item?.login || "").trim().toLowerCase() ===
+        normalizedRepoOwner,
+    );
+    if (org) return { org };
+
+    nextUrl = getNextGithubPageUrl(res.headers?.get?.("link"));
+  }
+
+  return null;
+};
+
 const isClassicPat = (token) => String(token || "").startsWith("ghp_");
 const isFineGrainedPat = (token) =>
   String(token || "").startsWith("github_pat_");
@@ -187,7 +223,43 @@ const verifyGithubRepoForOnboarding = async ({
           error: `Repository "${repoUrl}" not found. Check the repo name and token permissions.`,
         };
       }
-      return { ok: true, repoExists: false, repoIsEmpty: false };
+      if (!viewerLogin) {
+        return {
+          ok: false,
+          status: 400,
+          error: "Cannot verify GitHub account owner for this token.",
+        };
+      }
+      if (repoOwner.toLowerCase() !== viewerLogin.toLowerCase()) {
+        const orgLookup = await findAccessibleOrgByLogin({
+          repoOwner,
+          ghHeaders,
+        });
+        if (!orgLookup?.org) {
+          return {
+            ok: false,
+            status: 400,
+            error:
+              orgLookup?.error ||
+              `Repository owner "${repoOwner}" does not match the authenticated GitHub user "${viewerLogin}" ` +
+                "and was not found in the token's accessible organizations. Check the owner name or use a token that can create repositories for that organization.",
+          };
+        }
+        return {
+          ok: true,
+          repoExists: false,
+          repoIsEmpty: false,
+          createOwnerType: "org",
+          viewerLogin,
+        };
+      }
+      return {
+        ok: true,
+        repoExists: false,
+        repoIsEmpty: false,
+        createOwnerType: "user",
+        viewerLogin,
+      };
     }
     if (checkRes.ok) {
       const commitsRes = await fetch(
@@ -250,6 +322,7 @@ const ensureGithubRepoAccessible = async ({
   githubToken,
 }) => {
   const ghHeaders = buildGithubHeaders(githubToken);
+  const [repoOwner = ""] = String(repoUrl || "").split("/");
   const verification = await verifyGithubRepoForOnboarding({
     repoUrl,
     githubToken,
@@ -262,7 +335,11 @@ const ensureGithubRepoAccessible = async ({
 
   try {
     console.log(`[onboard] Creating repo ${repoUrl}...`);
-    const createRes = await fetch("https://api.github.com/user/repos", {
+    const createUrl =
+      verification.createOwnerType === "org"
+        ? `https://api.github.com/orgs/${repoOwner}/repos`
+        : "https://api.github.com/user/repos";
+    const createRes = await fetch(createUrl, {
       method: "POST",
       headers: { ...ghHeaders, "Content-Type": "application/json" },
       body: JSON.stringify({

package/lib/server/onboarding/index.js

@@ -1,5 +1,5 @@
 const path = require("path");
-const { kSetupDir, kRootDir } = require("../constants");
+const { kSetupDir } = require("../constants");
 const {
   resolveConfigIncludes,
   resolveImportedConfigPaths,
@@ -491,14 +491,7 @@ const createOnboardingService = ({
       await shellCmd(
         `openclaw onboard ${onboardArgs.map((a) => `"${a}"`).join(" ")}`,
         {
-          env: {
-            ...process.env,
-            HOME: kRootDir,
-            OPENCLAW_HOME: kRootDir,
-            OPENCLAW_CONFIG_PATH: `${OPENCLAW_DIR}/openclaw.json`,
-            OPENCLAW_STATE_DIR: OPENCLAW_DIR,
-            XDG_CONFIG_HOME: OPENCLAW_DIR,
-          },
+          env: gatewayEnv(),
           timeout: 120000,
         },
       );

package/lib/server/onboarding/openclaw.js

@@ -162,7 +162,10 @@ const getSafeImportedDmPolicy = (channelConfig = {}) => {
   return channelConfig?.dmPolicy || "pairing";
 };
 
-const applyFreshOnboardingChannels = ({ cfg, varMap }) => {
+const applyFreshOnboardingChannels = ({
+  cfg,
+  varMap,
+}) => {
   if (varMap.TELEGRAM_BOT_TOKEN) {
     cfg.channels.telegram = {
       enabled: true,
@@ -214,11 +217,18 @@ const applyFreshOnboardingChannels = ({ cfg, varMap }) => {
   ensureUsageTrackerPluginEntry(cfg);
 };
 
-const writeSanitizedOpenclawConfig = ({ fs, openclawDir, varMap }) => {
+const writeSanitizedOpenclawConfig = ({
+  fs,
+  openclawDir,
+  varMap,
+}) => {
   const configPath = `${openclawDir}/openclaw.json`;
   const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
   ensureManagedConfigShell(cfg);
-  applyFreshOnboardingChannels({ cfg, varMap });
+  applyFreshOnboardingChannels({
+    cfg,
+    varMap,
+  });
 
   let content = JSON.stringify(cfg, null, 2);
   const replacements = buildSecretReplacements(varMap, process.env);
@@ -239,7 +249,11 @@ const writeSanitizedOpenclawConfig = ({ fs, openclawDir, varMap }) => {
   console.log("[onboard] Config sanitized");
 };
 
-const writeManagedImportOpenclawConfig = ({ fs, openclawDir, varMap }) => {
+const writeManagedImportOpenclawConfig = ({
+  fs,
+  openclawDir,
+  varMap,
+}) => {
   const configPath = `${openclawDir}/openclaw.json`;
   const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
   ensureManagedConfigShell(cfg);

package/lib/server/openclaw-runtime-env.js

@@ -0,0 +1,55 @@
+const fs = require("fs");
+const path = require("path");
+const { kRootDir } = require("./constants");
+
+const kDefaultOpenclawCompileCacheDir = path.join(
+  kRootDir,
+  "cache",
+  "openclaw-compile-cache",
+);
+
+const normalizeEnvValue = (value) => String(value || "").trim();
+
+const resolveOpenclawCompileCacheDir = (env = process.env) =>
+  normalizeEnvValue(env.NODE_COMPILE_CACHE) || kDefaultOpenclawCompileCacheDir;
+
+const resolveOpenclawNoRespawn = (env = process.env) =>
+  normalizeEnvValue(env.OPENCLAW_NO_RESPAWN) || "1";
+
+const withOpenclawStartupEnv = (env = process.env) => ({
+  ...env,
+  NODE_COMPILE_CACHE: resolveOpenclawCompileCacheDir(env),
+  OPENCLAW_NO_RESPAWN: resolveOpenclawNoRespawn(env),
+});
+
+const ensureOpenclawStartupEnv = ({
+  fsModule = fs,
+  env = process.env,
+  logger = console,
+} = {}) => {
+  const nextEnv = withOpenclawStartupEnv(env);
+  try {
+    fsModule.mkdirSync(nextEnv.NODE_COMPILE_CACHE, { recursive: true });
+  } catch (err) {
+    logger?.warn?.(
+      `[alphaclaw] OpenClaw compile cache directory unavailable: ${err.message}`,
+    );
+  }
+
+  if (!normalizeEnvValue(env.NODE_COMPILE_CACHE)) {
+    env.NODE_COMPILE_CACHE = nextEnv.NODE_COMPILE_CACHE;
+  }
+  if (!normalizeEnvValue(env.OPENCLAW_NO_RESPAWN)) {
+    env.OPENCLAW_NO_RESPAWN = nextEnv.OPENCLAW_NO_RESPAWN;
+  }
+
+  return nextEnv;
+};
+
+module.exports = {
+  kDefaultOpenclawCompileCacheDir,
+  ensureOpenclawStartupEnv,
+  resolveOpenclawCompileCacheDir,
+  resolveOpenclawNoRespawn,
+  withOpenclawStartupEnv,
+};

package/lib/server/openclaw-version.js

@@ -24,9 +24,10 @@ const createOpenclawVersionService = ({
   };
   let kOpenclawUpdateInProgress = false;
 
-  const readOpenclawVersion = () => {
+  const readOpenclawVersion = ({ refresh = false } = {}) => {
     const now = Date.now();
     if (
+      !refresh &&
       kOpenclawVersionCache.value &&
       now - kOpenclawVersionCache.fetchedAt < kVersionCacheTtlMs
     ) {

package/lib/server/routes/models.js

@@ -1,5 +1,6 @@
 const { kFallbackOnboardingModels } = require("../constants");
 const { createModelCatalogCache } = require("../model-catalog-cache");
+const { getCommandOutputCandidates } = require("../utils/command-output");
 
 const runModelsGitSync = async (shellCmd) => {
   if (typeof shellCmd !== "function") return null;
@@ -13,12 +14,25 @@ const runModelsGitSync = async (shellCmd) => {
   }
 };
 
+const parseJsonFromShellError = ({
+  error,
+  parseJsonFromNoisyOutput = () => null,
+} = {}) => {
+  for (const rawOutput of getCommandOutputCandidates(error)) {
+    const parsed = parseJsonFromNoisyOutput(rawOutput);
+    if (parsed) return parsed;
+  }
+  return null;
+};
+
 const registerModelRoutes = ({
   app,
   shellCmd,
   gatewayEnv,
   parseJsonFromNoisyOutput,
   normalizeOnboardingModels,
+  readOpenclawVersion,
+  isOnboarded = () => true,
   authProfiles,
   readEnvFile,
   writeEnvFile,
@@ -28,6 +42,8 @@ const registerModelRoutes = ({
     gatewayEnv,
     parseJsonFromNoisyOutput,
     normalizeOnboardingModels,
+    readOpenclawVersion,
+    shouldStartDynamicRefresh: isOnboarded,
     fallbackModels: kFallbackOnboardingModels,
   }),
 }) => {
@@ -180,6 +196,18 @@ const registerModelRoutes = ({
         imageModel: parsed.imageModel || null,
       });
     } catch (err) {
+      const parsed = parseJsonFromShellError({
+        error: err,
+        parseJsonFromNoisyOutput,
+      });
+      if (parsed) {
+        return res.json({
+          ok: true,
+          modelKey: parsed.resolvedDefault || parsed.defaultModel || null,
+          fallbacks: parsed.fallbacks || [],
+          imageModel: parsed.imageModel || null,
+        });
+      }
       res.json({
         ok: false,
         error: err.message || "Failed to read model status",