@chrysb/alphaclaw 0.8.5 → 0.8.7-beta.0

package/lib/server/openclaw-version.js

@@ -1,12 +1,10 @@
-const { exec, execSync } = require("child_process");
+const { execSync } = require("child_process");
 const fs = require("fs");
-const os = require("os");
 const path = require("path");
 const {
   kVersionCacheTtlMs,
   kLatestVersionCacheTtlMs,
-  kNpmPackageRoot,
-  kOpenclawUpdateCopyTimeoutMs,
+  kRootDir,
 } = require("./constants");
 const { normalizeOpenclawVersion } = require("./helpers");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
@@ -24,6 +22,9 @@ const createOpenclawVersionService = ({
   };
   let kOpenclawUpdateInProgress = false;
 
+  const buildOpenclawInstallSpec = (version = "latest") =>
+    `openclaw@${String(version || "").trim() || "latest"}`;
+
   const readOpenclawVersion = () => {
     const now = Date.now();
     if (
@@ -87,118 +88,6 @@ const createOpenclawVersionService = ({
     }
   };
 
-  const findInstallDir = () => {
-    // Resolve the consumer app root (for example /app in Docker), not this package directory.
-    let dir = kNpmPackageRoot;
-    while (dir !== path.dirname(dir)) {
-      const parent = path.dirname(dir);
-      if (
-        path.basename(parent) === "node_modules" ||
-        parent.includes(`${path.sep}node_modules${path.sep}`)
-      ) {
-        dir = parent;
-        continue;
-      }
-      const pkgPath = path.join(parent, "package.json");
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-          if (
-            pkg.dependencies?.["@chrysb/alphaclaw"] ||
-            pkg.devDependencies?.["@chrysb/alphaclaw"] ||
-            pkg.optionalDependencies?.["@chrysb/alphaclaw"]
-          ) {
-            return parent;
-          }
-        } catch {}
-      }
-      dir = parent;
-    }
-    return kNpmPackageRoot;
-  };
-
-  // Install to a temp directory, then copy into the real node_modules.
-  // Running `npm install` directly in the app dir causes EBUSY on Docker
-  // because npm tries to rename directories that the running process holds open.
-  // Copying individual files (cp -af) avoids the rename syscall entirely.
-  const installLatestOpenclaw = () =>
-    new Promise((resolve, reject) => {
-      const installDir = findInstallDir();
-      const tmpDir = fs.mkdtempSync(
-        path.join(os.tmpdir(), "openclaw-update-"),
-      );
-      const cleanup = () => {
-        try {
-          fs.rmSync(tmpDir, { recursive: true, force: true });
-        } catch {}
-      };
-
-      fs.writeFileSync(
-        path.join(tmpDir, "package.json"),
-        JSON.stringify({
-          private: true,
-          dependencies: { openclaw: "latest" },
-        }),
-      );
-
-      const npmEnv = {
-        ...process.env,
-        npm_config_update_notifier: "false",
-        npm_config_fund: "false",
-        npm_config_audit: "false",
-      };
-
-      console.log(
-        `[alphaclaw] Running: npm install openclaw@latest in temp dir (target: ${installDir})`,
-      );
-      exec(
-        "npm install --omit=dev --prefer-online --package-lock=false",
-        { cwd: tmpDir, env: npmEnv, timeout: 180000 },
-        (installErr, stdout, stderr) => {
-          if (installErr) {
-            const message = String(stderr || installErr.message || "").trim();
-            console.log(
-              `[alphaclaw] openclaw install error: ${message.slice(0, 200)}`,
-            );
-            cleanup();
-            return reject(
-              new Error(message || "Failed to install openclaw@latest"),
-            );
-          }
-          if (stdout?.trim()) {
-            console.log(
-              `[alphaclaw] openclaw install stdout: ${stdout.trim().slice(0, 300)}`,
-            );
-          }
-
-          const src = path.join(tmpDir, "node_modules");
-          const dest = path.join(installDir, "node_modules");
-          exec(
-            `cp -af "${src}/." "${dest}/"`,
-            { timeout: kOpenclawUpdateCopyTimeoutMs },
-            (cpErr) => {
-              cleanup();
-              if (cpErr) {
-                console.log(
-                  `[alphaclaw] openclaw copy error: ${(cpErr.message || "").slice(0, 200)}`,
-                );
-                return reject(
-                  new Error(
-                    `Failed to copy updated openclaw files: ${cpErr.message}`,
-                  ),
-                );
-              }
-              console.log("[alphaclaw] openclaw install completed");
-              resolve({
-                stdout: stdout?.trim() || "",
-                stderr: stderr?.trim() || "",
-              });
-            },
-          );
-        },
-      );
-    });
-
   const getVersionStatus = async (refresh) => {
     const currentVersion = readOpenclawVersion();
     try {
@@ -228,27 +117,67 @@ const createOpenclawVersionService = ({
     kOpenclawUpdateInProgress = true;
     const previousVersion = readOpenclawVersion();
     try {
-      await installLatestOpenclaw();
-      kOpenclawVersionCache = { value: null, fetchedAt: 0 };
-      const currentVersion = readOpenclawVersion();
-      const { latestVersion, hasUpdate } = readOpenclawUpdateStatus({
-        refresh: true,
-      });
-      let restarted = false;
-      if (isOnboarded()) {
-        restartGateway();
-        restarted = true;
+      let latestVersion = null;
+      let hasUpdate = false;
+      try {
+        const updateStatus = readOpenclawUpdateStatus({ refresh: true });
+        latestVersion = updateStatus.latestVersion || null;
+        hasUpdate = !!updateStatus.hasUpdate;
+      } catch (error) {
+        console.log(
+          `[alphaclaw] Could not resolve exact OpenClaw version before restart: ${error.message || "unknown error"}`,
+        );
       }
+
+      if (!hasUpdate && latestVersion && latestVersion === previousVersion) {
+        return {
+          status: 200,
+          body: {
+            ok: true,
+            previousVersion,
+            currentVersion: previousVersion,
+            latestVersion,
+            hasUpdate: false,
+            restarted: false,
+            restarting: false,
+            updated: false,
+          },
+        };
+      }
+
+      const targetVersion = latestVersion || "latest";
+      const spec = buildOpenclawInstallSpec(targetVersion);
+      const markerPath = path.join(kRootDir, ".openclaw-update-pending");
+      fs.writeFileSync(
+        markerPath,
+        JSON.stringify({
+          from: previousVersion,
+          to: targetVersion,
+          spec,
+          ts: Date.now(),
+        }),
+      );
+      console.log(
+        `[alphaclaw] OpenClaw update marker written to ${markerPath} for ${spec}`,
+      );
+      kOpenclawVersionCache = { value: previousVersion, fetchedAt: 0 };
+      kOpenclawUpdateStatusCache = {
+        latestVersion,
+        hasUpdate,
+        fetchedAt: 0,
+      };
       return {
         status: 200,
         body: {
           ok: true,
           previousVersion,
-          currentVersion,
+          currentVersion: previousVersion,
+          targetVersion: targetVersion === "latest" ? null : targetVersion,
           latestVersion,
-          hasUpdate,
-          restarted,
-          updated: previousVersion !== currentVersion,
+          hasUpdate: true,
+          restarted: false,
+          restarting: true,
+          updated: previousVersion !== targetVersion,
         },
       };
     } catch (err) {

package/lib/server/pending-alphaclaw-update.js

@@ -0,0 +1,71 @@
+const buildPendingAlphaclawInstallSpec = (marker = {}) => {
+  const explicitSpec = String(marker?.spec || "").trim();
+  if (explicitSpec) {
+    return explicitSpec;
+  }
+  const targetVersion = String(marker?.to || "").trim() || "latest";
+  return `@chrysb/alphaclaw@${targetVersion}`;
+};
+
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+const applyPendingAlphaclawUpdate = ({
+  execSyncImpl,
+  fsModule,
+  installDir,
+  logger = console,
+  markerPath,
+}) => {
+  if (!fsModule.existsSync(markerPath)) {
+    return {
+      attempted: false,
+      installed: false,
+      spec: "",
+    };
+  }
+
+  let marker = {};
+  try {
+    marker = JSON.parse(fsModule.readFileSync(markerPath, "utf8"));
+  } catch {
+    marker = {};
+  }
+
+  const spec = buildPendingAlphaclawInstallSpec(marker);
+  logger.log(`[alphaclaw] Pending update detected, installing ${spec}...`);
+
+  try {
+    execSyncImpl(
+      `npm install ${shellQuote(spec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+      {
+        cwd: installDir,
+        stdio: "inherit",
+        timeout: 180000,
+      },
+    );
+    fsModule.unlinkSync(markerPath);
+    logger.log("[alphaclaw] Update applied successfully");
+    return {
+      attempted: true,
+      installed: true,
+      spec,
+    };
+  } catch (error) {
+    logger.log(`[alphaclaw] Update install failed: ${error.message}`);
+    try {
+      fsModule.unlinkSync(markerPath);
+    } catch {}
+    return {
+      attempted: true,
+      installed: false,
+      spec,
+      error,
+    };
+  }
+};
+
+module.exports = {
+  applyPendingAlphaclawUpdate,
+  buildPendingAlphaclawInstallSpec,
+};

package/lib/server/pending-openclaw-update.js

@@ -0,0 +1,71 @@
+const buildPendingOpenclawInstallSpec = (marker = {}) => {
+  const explicitSpec = String(marker?.spec || "").trim();
+  if (explicitSpec) {
+    return explicitSpec;
+  }
+  const targetVersion = String(marker?.to || "").trim() || "latest";
+  return `openclaw@${targetVersion}`;
+};
+
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+const applyPendingOpenclawUpdate = ({
+  execSyncImpl,
+  fsModule,
+  installDir,
+  logger = console,
+  markerPath,
+}) => {
+  if (!fsModule.existsSync(markerPath)) {
+    return {
+      attempted: false,
+      installed: false,
+      spec: "",
+    };
+  }
+
+  let marker = {};
+  try {
+    marker = JSON.parse(fsModule.readFileSync(markerPath, "utf8"));
+  } catch {
+    marker = {};
+  }
+
+  const spec = buildPendingOpenclawInstallSpec(marker);
+  logger.log(`[alphaclaw] Pending OpenClaw update detected, installing ${spec}...`);
+
+  try {
+    execSyncImpl(
+      `npm install ${shellQuote(spec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+      {
+        cwd: installDir,
+        stdio: "inherit",
+        timeout: 180000,
+      },
+    );
+    fsModule.unlinkSync(markerPath);
+    logger.log("[alphaclaw] OpenClaw update applied successfully");
+    return {
+      attempted: true,
+      installed: true,
+      spec,
+    };
+  } catch (error) {
+    logger.log(`[alphaclaw] OpenClaw update install failed: ${error.message}`);
+    try {
+      fsModule.unlinkSync(markerPath);
+    } catch {}
+    return {
+      attempted: true,
+      installed: false,
+      spec,
+      error,
+    };
+  }
+};
+
+module.exports = {
+  applyPendingOpenclawUpdate,
+  buildPendingOpenclawInstallSpec,
+};

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/system.js

@@ -588,7 +588,12 @@ const registerSystemRoutes = ({
     console.log(
       `[alphaclaw] /api/openclaw/update result: status=${result.status} ok=${result.body?.ok === true}`,
     );
-    res.status(result.status).json(result.body);
+    if (result.status === 200 && result.body?.ok && result.body?.restarting) {
+      res.json(result.body);
+      setTimeout(() => alphaclawVersionService.restartProcess(), 1000);
+    } else {
+      res.status(result.status).json(result.body);
+    }
   });
 
   app.get("/api/alphaclaw/version", async (req, 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.5",
+  "version": "0.8.7-beta.0",
   "publishConfig": {
     "access": "public"
   },