@chrysb/alphaclaw 0.9.28 → 0.9.30

package/lib/server/onboarding/validation.js

@@ -2,6 +2,17 @@ const { getEnvVarForApiKeyProvider } = require("../auth-profiles");
 
 const kAnthropicSetupTokenPrefix = "sk-ant-oat01-";
 const kAnthropicApiKeyPrefix = "sk-ant-api";
+const kCanonicalCodexOauthModelKeys = new Set([
+  "openai/gpt-5.4-mini",
+  "openai/gpt-5.5",
+  "openai/gpt-5.6-sol",
+  "openai/gpt-5.6-terra",
+  "openai/gpt-5.6-luna",
+]);
+
+const usesCodexOauth = (modelKey, provider) =>
+  provider === "openai-codex" ||
+  kCanonicalCodexOauthModelKeys.has(String(modelKey || "").trim());
 
 const validateAnthropicCredentialShape = (varMap) => {
   const anthropicToken = String(varMap.ANTHROPIC_TOKEN || "").trim();
@@ -71,7 +82,10 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
   if (!anthropicValidation.ok) return anthropicValidation;
   const githubToken = String(varMap.GITHUB_TOKEN || "");
   const githubRepoInput = String(varMap.GITHUB_WORKSPACE_REPO || "").trim();
-  const selectedProvider = resolveModelProvider(modelKey);
+  const resolvedProvider = resolveModelProvider(modelKey);
+  const selectedProvider = usesCodexOauth(modelKey, resolvedProvider)
+    ? "openai-codex"
+    : resolvedProvider;
   const hasCodexOauth = hasCodexOauthProfile();
   const hasAnyAi = !!(
     varMap.ANTHROPIC_API_KEY ||
@@ -82,7 +96,7 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
   );
   const hasAi = (() => {
     if (selectedProvider === "openai-codex") {
-      return hasCodexOauth;
+      return hasCodexOauth || !!String(varMap.OPENAI_API_KEY || "").trim();
     }
     if (selectedProvider === "anthropic") {
       return !!(varMap.ANTHROPIC_API_KEY || varMap.ANTHROPIC_TOKEN);
@@ -101,7 +115,7 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
       return {
         ok: false,
         status: 400,
-        error: "Connect OpenAI Codex OAuth before continuing",
+        error: "Connect OpenAI Codex OAuth or add an OpenAI API key before continuing",
       };
     }
     return {

package/lib/server/openclaw-codex-migration.js

@@ -3,14 +3,36 @@ const path = require("path");
 const { pathToFileURL } = require("url");
 const { DatabaseSync } = require("node:sqlite");
 
-const findOpenclawDistModule = (prefix) => {
+const findOpenclawDistModules = (prefix) => {
   const entryPath = require.resolve("openclaw");
   const distDir = path.dirname(entryPath);
-  const filename = fs
+  const filenames = fs
     .readdirSync(distDir)
-    .find((name) => name.startsWith(`${prefix}-`) && name.endsWith(".js"));
-  if (!filename) throw new Error(`OpenClaw migration module not found: ${prefix}`);
-  return path.join(distDir, filename);
+    .filter((name) => name.startsWith(`${prefix}-`) && name.endsWith(".js"));
+  if (filenames.length === 0) {
+    throw new Error(`OpenClaw migration module not found: ${prefix}`);
+  }
+  return filenames.map((filename) => path.join(distDir, filename));
+};
+
+const loadOpenclawMigrationApi = async ({ prefix, functionNames }) => {
+  const api = {};
+  for (const modulePath of findOpenclawDistModules(prefix)) {
+    const mod = await import(pathToFileURL(modulePath).href);
+    for (const candidate of Object.values(mod)) {
+      if (typeof candidate !== "function") continue;
+      if (functionNames.includes(candidate.name) && !api[candidate.name]) {
+        api[candidate.name] = candidate;
+      }
+    }
+  }
+  const missing = functionNames.filter((name) => typeof api[name] !== "function");
+  if (missing.length > 0) {
+    throw new Error(
+      `OpenClaw migration exports not found for ${prefix}: ${missing.join(", ")}`,
+    );
+  }
+  return api;
 };
 
 const writeConfig = (configPath, cfg) => {
@@ -73,33 +95,55 @@ const migrateLegacyCodexState = async ({
   }
 
   const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
-  const routeModule = await import(
-    pathToFileURL(findOpenclawDistModule("codex-route-warnings")).href
-  );
-  const authModule = await import(
-    pathToFileURL(findOpenclawDistModule("doctor-auth-flat-profiles")).href
-  );
+  const routeApi = await loadOpenclawMigrationApi({
+    prefix: "codex-route-warnings",
+    functionNames: [
+      "maybeRepairCodexRoutes",
+      "maybeRepairCodexSessionRoutes",
+    ],
+  });
+  const authApi = await loadOpenclawMigrationApi({
+    prefix: "doctor-auth-flat-profiles",
+    functionNames: [
+      "collectOpenAICodexAuthProfileStoreIdMap",
+      "maybeRepairOpenAICodexAuthConfig",
+      "maybeRepairOpenAICodexAuthProfileStores",
+      "maybeMigrateAuthProfileJsonStoresToSqlite",
+    ],
+  });
 
   const changes = [];
   const warnings = [];
-  const routeRepair = routeModule.r({ cfg, env, shouldRepair: true });
+  const routeRepair = routeApi.maybeRepairCodexRoutes({
+    cfg,
+    env,
+    shouldRepair: true,
+  });
   let nextCfg = routeRepair.cfg;
   changes.push(...routeRepair.changes);
   warnings.push(...routeRepair.warnings);
 
-  const profileIdMap = authModule.t({ cfg: nextCfg, env });
-  const configAuthRepair = authModule.a(nextCfg, { profileIdMap });
+  const profileIdMap = authApi.collectOpenAICodexAuthProfileStoreIdMap({
+    cfg: nextCfg,
+    env,
+  });
+  const configAuthRepair = authApi.maybeRepairOpenAICodexAuthConfig(nextCfg, {
+    profileIdMap,
+  });
   nextCfg = configAuthRepair.config;
   changes.push(...configAuthRepair.changes);
   warnings.push(...configAuthRepair.warnings);
 
   if (changes.length > 0) writeConfig(configPath, nextCfg);
 
-  const storeRepair = await authModule.o({ cfg: nextCfg, env });
+  const storeRepair = await authApi.maybeRepairOpenAICodexAuthProfileStores({
+    cfg: nextCfg,
+    env,
+  });
   changes.push(...storeRepair.changes);
   warnings.push(...storeRepair.warnings);
 
-  const sqliteMigration = await authModule.n({
+  const sqliteMigration = await authApi.maybeMigrateAuthProfileJsonStoresToSqlite({
     cfg: nextCfg,
     env,
     prompter: { confirmAutoFix: async () => true },
@@ -113,7 +157,7 @@ const migrateLegacyCodexState = async ({
     writeConfig(configPath, nextCfg);
   }
 
-  const sessionRepair = await routeModule.i({
+  const sessionRepair = await routeApi.maybeRepairCodexSessionRoutes({
     cfg: nextCfg,
     env,
     shouldRepair: true,

package/lib/server/openclaw-thinking.js

@@ -27,29 +27,28 @@ const loadThinkingModule = async () => {
   return thinkingModulePromise;
 };
 
-const isNormalizeThinkLevel = (candidate) => {
-  if (typeof candidate !== "function") return false;
-  try {
-    return (
-      candidate("off") === "off" &&
-      candidate("low") === "low" &&
-      candidate("high") === "high"
-    );
-  } catch {
-    return false;
+const normalizeThinkingLevel = (raw) => {
+  const key = String(raw || "").trim().toLowerCase();
+  if (!key) return null;
+  const collapsed = key.replace(/[\s_-]+/g, "");
+  if (collapsed === "adaptive" || collapsed === "auto") return "adaptive";
+  if (collapsed === "max") return "max";
+  if (collapsed === "ultra") return "ultra";
+  if (collapsed === "xhigh" || collapsed === "extrahigh") return "xhigh";
+  if (key === "off") return "off";
+  if (["on", "enable", "enabled"].includes(key)) return "low";
+  if (["min", "minimal"].includes(key)) return "minimal";
+  if (["low", "thinkhard", "think-hard", "think_hard"].includes(key)) {
+    return "low";
   }
-};
-
-const resolveNormalizeThinkLevel = (mod) => {
-  const candidates = [
-    mod.normalizeThinkLevel,
-    mod.f,
-    mod.p,
-    ...Object.values(mod),
-  ];
-  const match = candidates.find(isNormalizeThinkLevel);
-  if (!match) throw new Error("OpenClaw normalizeThinkLevel export not found");
-  return match;
+  if (["mid", "med", "medium", "thinkharder", "think-harder", "harder"].includes(key)) {
+    return "medium";
+  }
+  if (["high", "ultrathink", "thinkhardest", "highest"].includes(key)) {
+    return "high";
+  }
+  if (key === "think") return "minimal";
+  return null;
 };
 
 const splitModelKey = (modelKey = "") => {
@@ -80,13 +79,13 @@ const resolveThinkingApi = async () => {
   return {
     listThinkingLevelOptions: mod.listThinkingLevelOptions || mod.i,
     resolveThinkingDefaultForModel: mod.resolveThinkingDefaultForModel || mod.s,
-    normalizeThinkLevel: resolveNormalizeThinkLevel(mod),
   };
 };
 
 const resolveThinkingOptionsForModel = async ({
   modelKey = "",
   catalog = [],
+  agentRuntime = "",
 } = {}) => {
   const { provider, model } = splitModelKey(modelKey);
   if (!provider || !model) {
@@ -96,12 +95,20 @@ const resolveThinkingOptionsForModel = async ({
     };
   }
   const api = await resolveThinkingApi();
-  const levels = api.listThinkingLevelOptions(provider, model, catalog) || [];
+  const normalizedAgentRuntime = String(agentRuntime || "").trim() || undefined;
+  const levels =
+    api.listThinkingLevelOptions(
+      provider,
+      model,
+      catalog,
+      normalizedAgentRuntime,
+    ) || [];
   const modelDefault =
     api.resolveThinkingDefaultForModel({
       provider,
       model,
       catalog,
+      agentRuntime: normalizedAgentRuntime,
     }) || "off";
   return {
     levels: levels.map((entry) => ({
@@ -114,14 +121,13 @@ const resolveThinkingOptionsForModel = async ({
 
 const normalizeThinkingDefaultValue = async (raw) => {
   if (raw === null || raw === undefined || raw === "") return null;
-  const api = await resolveThinkingApi();
-  const normalized = api.normalizeThinkLevel(String(raw || "").trim());
-  return normalized || null;
+  return normalizeThinkingLevel(raw);
 };
 
 module.exports = {
   buildCatalogEntry,
   loadThinkingModule,
+  normalizeThinkingLevel,
   normalizeThinkingDefaultValue,
   resolveThinkingOptionsForModel,
   splitModelKey,

package/lib/server/openclaw-version.js

@@ -10,6 +10,7 @@ const {
 } = require("./constants");
 const { normalizeOpenclawVersion } = require("./helpers");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
+const { assertSupportedNodeVersion } = require("../node-runtime");
 
 const createOpenclawVersionService = ({
   gatewayEnv,
@@ -124,6 +125,12 @@ const createOpenclawVersionService = ({
   // Copying individual files (cp -af) avoids the rename syscall entirely.
   const installLatestOpenclaw = () =>
     new Promise((resolve, reject) => {
+      try {
+        assertSupportedNodeVersion();
+      } catch (error) {
+        reject(error);
+        return;
+      }
       const installDir = findInstallDir();
       const tmpDir = fs.mkdtempSync(
         path.join(os.tmpdir(), "openclaw-update-"),

package/lib/server/plugin-config.js

@@ -0,0 +1,22 @@
+const ensurePluginsShell = (cfg = {}) => {
+  if (!cfg.plugins || typeof cfg.plugins !== "object") cfg.plugins = {};
+  if (!Array.isArray(cfg.plugins.allow)) cfg.plugins.allow = [];
+  if (!cfg.plugins.load || typeof cfg.plugins.load !== "object") {
+    cfg.plugins.load = {};
+  }
+  if (!Array.isArray(cfg.plugins.load.paths)) cfg.plugins.load.paths = [];
+  if (!cfg.plugins.entries || typeof cfg.plugins.entries !== "object") {
+    cfg.plugins.entries = {};
+  }
+};
+
+const ensurePluginAllowed = ({ cfg = {}, pluginKey = "" }) => {
+  const normalizedPluginKey = String(pluginKey || "").trim();
+  if (!normalizedPluginKey) return;
+  ensurePluginsShell(cfg);
+  if (!cfg.plugins.allow.includes(normalizedPluginKey)) {
+    cfg.plugins.allow.push(normalizedPluginKey);
+  }
+};
+
+module.exports = { ensurePluginsShell, ensurePluginAllowed };

package/lib/server/routes/models.js

@@ -197,8 +197,12 @@ const registerModelRoutes = ({
         typeof cfg.agents?.defaults?.thinkingDefault === "string"
           ? cfg.agents.defaults.thinkingDefault.trim()
           : null;
+      const agentRuntime = String(
+        cfg.agents?.defaults?.models?.[modelKey]?.agentRuntime?.id || "",
+      ).trim();
       const { levels, modelDefault } = await resolveThinkingOptionsForModel({
         modelKey,
+        agentRuntime,
       });
       const inheritedDefault = globalThinkingDefault || modelDefault || "off";
       return res.json({

package/lib/server/routes/onboarding.js

@@ -95,6 +95,28 @@ const registerOnboardingRoutes = ({
   getBaseUrl,
   runOnboardedBootSequence,
 }) => {
+  const kOnboardingProgressMessages = {
+    creating_repo: "Creating repo...",
+    running_openclaw_onboard: "Running openclaw onboard...",
+    initial_git_push: "Initial git commit/push...",
+    starting_gateway: "Starting gateway...",
+  };
+  let onboardingProgress = {
+    active: false,
+    stage: "idle",
+    message: "",
+    updatedAt: null,
+  };
+  const setOnboardingProgress = (stage, { active = true } = {}) => {
+    const normalizedStage = String(stage || "").trim();
+    onboardingProgress = {
+      active,
+      stage: normalizedStage,
+      message: kOnboardingProgressMessages[normalizedStage] || "",
+      updatedAt: new Date().toISOString(),
+    };
+  };
+
   // Keep mutating onboarding routes marker-gated so in-progress imports
   // can promote files before the final completion marker is written.
   const hasExplicitOnboardingMarker = () =>
@@ -157,21 +179,32 @@ const registerOnboardingRoutes = ({
     res.json({ onboarded: hasExplicitOnboardingMarker() });
   });
 
+  app.get("/api/onboard/progress", (req, res) => {
+    res.json(onboardingProgress);
+  });
+
   app.post("/api/onboard", async (req, res) => {
     if (hasExplicitOnboardingMarker())
       return res.json({ ok: false, error: "Already onboarded" });
 
     try {
+      setOnboardingProgress("creating_repo");
       const { vars, modelKey, importMode } = req.body;
       const result = await onboardingService.completeOnboarding({
         req,
         vars,
         modelKey,
         importMode: !!importMode,
+        onProgress: (stage) => setOnboardingProgress(stage),
       });
+      setOnboardingProgress(
+        result.body?.ok ? "starting_gateway" : "failed",
+        { active: false },
+      );
       res.status(result.status).json(result.body);
     } catch (err) {
       console.error("[onboard] Error:", err);
+      setOnboardingProgress("failed", { active: false });
       res.status(500).json({ ok: false, error: sanitizeOnboardingError(err) });
     }
   });

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

@@ -3,6 +3,8 @@ const { readOpenclawConfig, writeOpenclawConfig } = require("./openclaw-config")
 const {
   migrateLegacyTelegramStreamingConfig,
 } = require("./openclaw-config-migrations");
+const { ensureCodexRuntimePlugin } = require("./codex-runtime-config");
+const { ensurePluginsShell, ensurePluginAllowed } = require("./plugin-config");
 
 const kUsageTrackerPluginPath = path.resolve(
   __dirname,
@@ -14,27 +16,6 @@ const kConversationAccessHookPolicyKey = "allowConversationAccess";
 const kChannelPluginIds = ["telegram", "discord", "slack", "whatsapp"];
 const kDefaultDiscordGroupPolicy = "disabled";
 
-const ensurePluginsShell = (cfg = {}) => {
-  if (!cfg.plugins || typeof cfg.plugins !== "object") cfg.plugins = {};
-  if (!Array.isArray(cfg.plugins.allow)) cfg.plugins.allow = [];
-  if (!cfg.plugins.load || typeof cfg.plugins.load !== "object") {
-    cfg.plugins.load = {};
-  }
-  if (!Array.isArray(cfg.plugins.load.paths)) cfg.plugins.load.paths = [];
-  if (!cfg.plugins.entries || typeof cfg.plugins.entries !== "object") {
-    cfg.plugins.entries = {};
-  }
-};
-
-const ensurePluginAllowed = ({ cfg = {}, pluginKey = "" }) => {
-  const normalizedPluginKey = String(pluginKey || "").trim();
-  if (!normalizedPluginKey) return;
-  ensurePluginsShell(cfg);
-  if (!cfg.plugins.allow.includes(normalizedPluginKey)) {
-    cfg.plugins.allow.push(normalizedPluginKey);
-  }
-};
-
 const buildUsageTrackerHookPolicy = ({ existingHooks = {} } = {}) => {
   const hooks = {};
   if (typeof existingHooks.allowPromptInjection === "boolean") {
@@ -115,6 +96,7 @@ const reconcileEnabledChannelPlugins = (cfg = {}) => {
 
 const reconcileManagedPluginConfig = (cfg = {}) => {
   let changed = ensureUsageTrackerPluginEntry(cfg);
+  if (ensureCodexRuntimePlugin(cfg)) changed = true;
   if (reconcileEnabledChannelPlugins(cfg)) changed = true;
   if (reconcileDiscordGroupPolicy(cfg)) changed = true;
   return changed;

package/lib/server/watchdog.js

@@ -63,6 +63,7 @@ const createWatchdog = ({
     pendingRecoveryNoticeSource: "",
     awaitingAutoRepairRecovery: false,
     startupConsecutiveHealthFailures: 0,
+    configurationErrorActive: false,
   };
   let healthTimer = null;
   let bootstrapHealthTimer = null;
@@ -90,6 +91,7 @@ const createWatchdog = ({
 
   const scheduleDegradedHealthCheck = () => {
     if (degradedHealthTimer) return;
+    if (state.configurationErrorActive) return;
     if (state.health !== "degraded" || state.lifecycle !== "running") return;
     degradedHealthTimer = setTimeout(async () => {
       degradedHealthTimer = null;
@@ -380,6 +382,9 @@ const createWatchdog = ({
   };
 
   const runRepair = async ({ source, correlationId, force = false }) => {
+    if (state.configurationErrorActive && !force) {
+      return { ok: false, skipped: true, reason: "configuration_error" };
+    }
     if (!force && !state.autoRepair) {
       return { ok: false, skipped: true, reason: "auto_repair_disabled" };
     }
@@ -389,10 +394,16 @@ const createWatchdog = ({
     if (state.operationInProgress) {
       return { ok: false, skipped: true, reason: "operation_in_progress" };
     }
+    if (force) {
+      state.configurationErrorActive = false;
+    }
 
     state.operationInProgress = true;
     try {
       const result = await clawCmd("doctor --fix --yes", { quiet: true });
+      if (state.configurationErrorActive && !force) {
+        return { ok: false, skipped: true, reason: "configuration_error" };
+      }
       const ok = !!result?.ok;
       logEvent("repair", source, ok ? "ok" : "failed", result, correlationId);
       if (ok) {
@@ -484,6 +495,7 @@ const createWatchdog = ({
     source = "health_timer",
     allowAutoRepair = true,
   } = {}) => {
+    if (state.configurationErrorActive) return false;
     if (
       state.expectedRestartInProgress &&
       Date.now() >= state.expectedRestartUntilMs
@@ -495,6 +507,9 @@ const createWatchdog = ({
     const correlationId = createCorrelationId();
     state.lastHealthCheckAt = new Date().toISOString();
     const parsed = await probeGatewayHealth();
+    // The gateway may exit with EX_CONFIG while a probe is in flight. Keep the
+    // latched configuration-error state from being overwritten by that result.
+    if (state.configurationErrorActive) return false;
     const staleAfterRestart =
       gatewayStartedAtAtStart != null &&
       state.gatewayStartedAt != null &&
@@ -727,6 +742,33 @@ const createWatchdog = ({
       return;
     }
 
+    if (code === 78) {
+      state.configurationErrorActive = true;
+      state.lifecycle = "configuration_error";
+      state.health = "unhealthy";
+      state.uptimeStartedAt = null;
+      state.crashRecoveryActive = false;
+      state.startupConsecutiveHealthFailures = 0;
+      logEvent(
+        "config_error",
+        "exit_event",
+        "failed",
+        { code, signal: signal ?? null, stderrTail },
+        correlationId,
+      );
+      void notifyOncePerIncident(
+        "gateway_config_error",
+        [
+          "🐺 *AlphaClaw Watchdog*",
+          withViewLogsSuffix("🔴 Gateway configuration invalid"),
+          "OpenClaw stopped with `EX_CONFIG`; automatic restart is paused.",
+        ].join("\n"),
+        correlationId,
+        "config_error",
+      );
+      return;
+    }
+
     state.lifecycle = "crashed";
     state.health = "unhealthy";
     state.uptimeStartedAt = null;
@@ -787,6 +829,7 @@ const createWatchdog = ({
 
   const onGatewayLaunch = ({ startedAt = Date.now(), pid = null } = {}) => {
     clearDegradedHealthCheckTimer();
+    state.configurationErrorActive = false;
     state.lifecycle = "running";
     state.health = "unknown";
     state.startupConsecutiveHealthFailures = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.9.28",
+  "version": "0.9.30",
   "publishConfig": {
     "access": "public"
   },
@@ -33,7 +33,7 @@
   "dependencies": {
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
-    "openclaw": "2026.6.11",
+    "openclaw": "2026.7.1",
     "ws": "^8.19.0"
   },
   "devDependencies": {
@@ -51,6 +51,6 @@
     "wouter-preact": "^3.7.1"
   },
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=22.22.3 <23 || >=24.15.0 <25 || >=25.9.0"
   }
 }