@chrysb/alphaclaw 0.9.10 → 0.9.12

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

@@ -5,6 +5,8 @@ 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 = ({
@@ -77,6 +79,7 @@ const createModelCatalogCache = ({
   parseJsonFromNoisyOutput = () => ({}),
   normalizeOnboardingModels = (items) => items,
   readOpenclawVersion = () => null,
+  shouldStartDynamicRefresh = () => true,
   fallbackModels = kFallbackOnboardingModels,
   cachePath = kDefaultCachePath,
   refreshBackoffMs = kModelCatalogRefreshBackoffMs,
@@ -117,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;
@@ -162,7 +173,7 @@ const createModelCatalogCache = ({
     try {
       const output = await shellCmd("openclaw models list --all --json", {
         env: gatewayEnv(),
-        timeout: 30000,
+        timeout: kModelCatalogLoadTimeoutMs,
       });
       models = parseCatalogModelsFromOutput({
         rawOutput: output,
@@ -205,21 +216,27 @@ const createModelCatalogCache = ({
   };
 
   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)}`,
       );
@@ -231,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()) {
@@ -279,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() {
@@ -326,5 +337,7 @@ module.exports = {
   normalizeCacheEntry,
   kModelCatalogCacheVersion,
   kModelCatalogRefreshBackoffMs,
+  kModelCatalogLoadTimeoutMs,
+  kModelCatalogBootstrapSource,
   kDefaultCachePath,
 };

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/routes/models.js

@@ -32,6 +32,7 @@ const registerModelRoutes = ({
   parseJsonFromNoisyOutput,
   normalizeOnboardingModels,
   readOpenclawVersion,
+  isOnboarded = () => true,
   authProfiles,
   readEnvFile,
   writeEnvFile,
@@ -42,6 +43,7 @@ const registerModelRoutes = ({
     parseJsonFromNoisyOutput,
     normalizeOnboardingModels,
     readOpenclawVersion,
+    shouldStartDynamicRefresh: isOnboarded,
     fallbackModels: kFallbackOnboardingModels,
   }),
 }) => {

package/lib/server/usage-tracker-config.js

@@ -7,6 +7,7 @@ const kUsageTrackerPluginPath = path.resolve(
   "plugin",
   "usage-tracker",
 );
+const kConversationAccessHookPolicyKey = "allowConversationAccess";
 
 const ensurePluginsShell = (cfg = {}) => {
   if (!cfg.plugins || typeof cfg.plugins !== "object") cfg.plugins = {};
@@ -29,19 +30,43 @@ const ensurePluginAllowed = ({ cfg = {}, pluginKey = "" }) => {
   }
 };
 
+const buildUsageTrackerHookPolicy = ({ existingHooks = {} } = {}) => {
+  const hooks = {};
+  if (typeof existingHooks.allowPromptInjection === "boolean") {
+    hooks.allowPromptInjection = existingHooks.allowPromptInjection;
+  }
+  hooks[kConversationAccessHookPolicyKey] = true;
+  return hooks;
+};
+
 const ensureUsageTrackerPluginEntry = (cfg = {}) => {
   const before = JSON.stringify(cfg);
   ensurePluginAllowed({ cfg, pluginKey: "usage-tracker" });
   if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
     cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
   }
-  cfg.plugins.entries["usage-tracker"] = {
-    ...(cfg.plugins.entries["usage-tracker"] &&
+  const existingEntry =
+    cfg.plugins.entries["usage-tracker"] &&
     typeof cfg.plugins.entries["usage-tracker"] === "object"
       ? cfg.plugins.entries["usage-tracker"]
-      : {}),
+      : {};
+  const existingHooks =
+    existingEntry.hooks && typeof existingEntry.hooks === "object"
+      ? existingEntry.hooks
+      : {};
+  const hooks = buildUsageTrackerHookPolicy({
+    existingHooks,
+  });
+  const nextEntry = {
+    ...existingEntry,
     enabled: true,
   };
+  if (Object.keys(hooks).length > 0) {
+    nextEntry.hooks = hooks;
+  } else {
+    delete nextEntry.hooks;
+  }
+  cfg.plugins.entries["usage-tracker"] = nextEntry;
   return JSON.stringify(cfg) !== before;
 };
 

package/lib/server.js

@@ -141,12 +141,16 @@ const {
 const {
   ensureManagedExecDefaults,
 } = require("./server/exec-defaults-config");
+const {
+  ensureOpenclawStartupEnv,
+} = require("./server/openclaw-runtime-env");
 
 const { PORT, kTrustProxyHops, SETUP_API_PREFIXES } = constants;
 
 initializeServerRuntime({
   fs,
   constants,
+  ensureOpenclawStartupEnv,
   startEnvWatcher,
   attachGatewaySignalHandlers,
   cleanupStaleImportTempDirs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.9.10",
+  "version": "0.9.12",
   "publishConfig": {
     "access": "public"
   },
@@ -19,14 +19,11 @@
   },
   "files": [
     "bin/",
-    "lib/",
-    "patches/",
-    "scripts/apply-openclaw-patches.js"
+    "lib/"
   ],
   "scripts": {
     "start": "node bin/alphaclaw.js start",
     "build:ui": "node scripts/build-ui.mjs",
-    "postinstall": "node ./scripts/apply-openclaw-patches.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:watchdog": "vitest run tests/server/watchdog.test.js tests/server/watchdog-db.test.js tests/server/routes-watchdog.test.js",
@@ -36,8 +33,7 @@
   "dependencies": {
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
-    "openclaw": "2026.4.21",
-    "patch-package": "^8.0.1",
+    "openclaw": "2026.4.24",
     "ws": "^8.19.0"
   },
   "devDependencies": {

package/patches/openclaw+2026.4.21.patch

@@ -1,13 +0,0 @@
-diff --git a/node_modules/openclaw/dist/server.impl-DLF59fRo.js b/node_modules/openclaw/dist/server.impl-DLF59fRo.js
-index d6b4a5c..4e76dd9 100644
---- a/node_modules/openclaw/dist/server.impl-DLF59fRo.js
-+++ b/node_modules/openclaw/dist/server.impl-DLF59fRo.js
-@@ -22187,7 +22187,7 @@ function attachGatewayWsMessageHandler(params) {
- 					close(1008, truncateCloseReason(authMessage));
- 				};
- 				const clearUnboundScopes = () => {
--					if (scopes.length > 0) {
-+					if (scopes.length > 0 && !sharedAuthOk) {
- 						scopes = [];
- 						connectParams.scopes = scopes;
- 					}

package/scripts/apply-openclaw-patches.js

@@ -1,99 +0,0 @@
-/**
- * patch-package resolves paths relative to the npm/yarn project root (where the
- * lockfile lives). When this package's postinstall runs, process.cwd() is often
- * this package directory, so a plain `patch-package` call treats that as the
- * app root and looks for ./node_modules/openclaw under it — but openclaw is
- * usually hoisted to the consumer's top-level node_modules.
- *
- * This script finds the real install root (directory containing a lockfile) and
- * runs patch-package there with --patch-dir pointing at our bundled patches/.
- */
-const { spawnSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-const kAlphaclawRoot = path.join(__dirname, "..");
-
-const findProjectRootFromOpenclawDir = (openclawDir) => {
-  let dir = path.resolve(openclawDir);
-  for (let i = 0; i < 30; i += 1) {
-    if (
-      fs.existsSync(path.join(dir, "package-lock.json")) ||
-      fs.existsSync(path.join(dir, "yarn.lock")) ||
-      fs.existsSync(path.join(dir, "pnpm-lock.yaml"))
-    ) {
-      return dir;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return path.dirname(path.dirname(openclawDir));
-};
-
-const main = () => {
-  const patchesDir = path.join(kAlphaclawRoot, "patches");
-  if (!fs.existsSync(patchesDir)) {
-    return;
-  }
-  const hasPatch = fs
-    .readdirSync(patchesDir)
-    .some((name) => name.endsWith(".patch"));
-  if (!hasPatch) {
-    return;
-  }
-
-  let openclawMainPath;
-  try {
-    openclawMainPath = require.resolve("openclaw", { paths: [kAlphaclawRoot] });
-  } catch {
-    return;
-  }
-
-  const openclawDir = (() => {
-    let dir = path.dirname(openclawMainPath);
-    for (let i = 0; i < 8; i += 1) {
-      const pkgPath = path.join(dir, "package.json");
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-          if (pkg.name === "openclaw") return dir;
-        } catch {
-          /* continue */
-        }
-      }
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-    return path.dirname(path.dirname(openclawMainPath));
-  })();
-  const projectRoot = findProjectRootFromOpenclawDir(openclawDir);
-
-  let relPatchDir = path.relative(projectRoot, patchesDir);
-  if (relPatchDir.startsWith("..") || path.isAbsolute(relPatchDir)) {
-    console.error(
-      "[@chrysb/alphaclaw] patch-package: could not resolve patch dir relative to project root",
-    );
-    process.exit(1);
-  }
-  relPatchDir = relPatchDir.split(path.sep).join("/");
-
-  const patchPackageMain = require.resolve("patch-package/dist/index.js", {
-    paths: [kAlphaclawRoot],
-  });
-
-  const result = spawnSync(
-    process.execPath,
-    [patchPackageMain, "--patch-dir", relPatchDir],
-    { cwd: projectRoot, stdio: "inherit", env: process.env },
-  );
-  if (result.error) {
-    throw result.error;
-  }
-  if (result.status !== 0 && result.status !== null) {
-    process.exit(result.status);
-  }
-};
-
-main();