@chrysb/alphaclaw 0.8.7-beta.4 → 0.8.7

package/lib/server/alphaclaw-version.js

@@ -1,4 +1,6 @@
+const childProcess = require("child_process");
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 const https = require("https");
 const http = require("http");
@@ -6,6 +8,7 @@ const {
   kLatestVersionCacheTtlMs,
   kAlphaclawRegistryUrl,
   kNpmPackageRoot,
+  kOpenclawUpdateCopyTimeoutMs,
   kRootDir,
 } = require("./constants");
 
@@ -23,9 +26,6 @@ const isNewerVersion = (latest, current) => {
   return l.patch > c.patch;
 };
 
-const buildAlphaclawInstallSpec = (version = "latest") =>
-  `@chrysb/alphaclaw@${String(version || "").trim() || "latest"}`;
-
 const createAlphaclawVersionService = () => {
   let kUpdateStatusCache = {
     latestVersion: null,
@@ -108,6 +108,120 @@ const createAlphaclawVersionService = () => {
     return { latestVersion, hasUpdate };
   };
 
+  const findInstallDir = () => {
+    // Walk up from kNpmPackageRoot to find the consuming project's directory
+    // (the one with node_modules/@chrysb/alphaclaw). In Docker this is /app.
+    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;
+    }
+    // Fallback: if running directly (not from node_modules), use kNpmPackageRoot
+    return kNpmPackageRoot;
+  };
+
+  const installLatestAlphaclaw = () =>
+    new Promise((resolve, reject) => {
+      const installDir = findInstallDir();
+      const tmpDir = fs.mkdtempSync(
+        path.join(os.tmpdir(), "alphaclaw-update-"),
+      );
+
+      const cleanup = () => {
+        try {
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        } catch {}
+      };
+
+      fs.writeFileSync(
+        path.join(tmpDir, "package.json"),
+        JSON.stringify({
+          private: true,
+          dependencies: { "@chrysb/alphaclaw": "latest" },
+        }),
+      );
+
+      const npmEnv = {
+        ...process.env,
+        npm_config_update_notifier: "false",
+        npm_config_fund: "false",
+        npm_config_audit: "false",
+      };
+
+      console.log(
+        `[alphaclaw] Running: npm install @chrysb/alphaclaw@latest in temp dir (target: ${installDir})`,
+      );
+      childProcess.exec(
+        "npm install --omit=dev --prefer-online --package-lock=false",
+        {
+          cwd: tmpDir,
+          env: npmEnv,
+          timeout: 180000,
+        },
+        (err, stdout, stderr) => {
+          if (err) {
+            const message = String(stderr || err.message || "").trim();
+            console.log(
+              `[alphaclaw] alphaclaw install error: ${message.slice(0, 200)}`,
+            );
+            cleanup();
+            return reject(
+              new Error(
+                message || "Failed to install @chrysb/alphaclaw@latest",
+              ),
+            );
+          }
+          if (stdout?.trim()) {
+            console.log(
+              `[alphaclaw] alphaclaw install stdout: ${stdout.trim().slice(0, 300)}`,
+            );
+          }
+
+          const src = path.join(tmpDir, "node_modules");
+          const dest = path.join(installDir, "node_modules");
+          childProcess.exec(
+            `cp -af "${src}/." "${dest}/"`,
+            { timeout: kOpenclawUpdateCopyTimeoutMs },
+            (copyErr) => {
+              cleanup();
+              if (copyErr) {
+                console.log(
+                  `[alphaclaw] alphaclaw copy error: ${(copyErr.message || "").slice(0, 200)}`,
+                );
+                return reject(
+                  new Error(
+                    `Failed to copy updated AlphaClaw files: ${copyErr.message}`,
+                  ),
+                );
+              }
+              console.log("[alphaclaw] alphaclaw install completed");
+              resolve({ stdout: stdout?.trim(), stderr: stderr?.trim() });
+            },
+          );
+        },
+      );
+    });
+
   const isContainer = () =>
     process.env.RAILWAY_ENVIRONMENT ||
     process.env.RENDER ||
@@ -126,15 +240,9 @@ const createAlphaclawVersionService = () => {
     // On bare metal / Mac / Linux, spawn a replacement process then exit.
     console.log("[alphaclaw] Spawning new process and exiting...");
     const { spawn } = require("child_process");
-    const nextEnv = { ...process.env };
-    delete nextEnv.ALPHACLAW_MANAGED_RUNTIME_ACTIVE;
-    const bootstrapCliPath =
-      String(process.env.ALPHACLAW_BOOTSTRAP_CLI_PATH || "").trim() ||
-      process.argv[1];
-    const child = spawn(process.argv[0], [bootstrapCliPath, ...process.argv.slice(2)], {
+    const child = spawn(process.argv[0], process.argv.slice(1), {
       detached: true,
       stdio: "inherit",
-      env: nextEnv,
     });
     child.unref();
     process.exit(0);
@@ -169,33 +277,18 @@ const createAlphaclawVersionService = () => {
     kUpdateInProgress = true;
     const previousVersion = readAlphaclawVersion();
     try {
-      let targetVersion = "latest";
+      await installLatestAlphaclaw();
+      // Write marker to persistent volume so the update survives container recreation
+      const markerPath = path.join(kRootDir, ".alphaclaw-update-pending");
       try {
-        const updateStatus = await readAlphaclawUpdateStatus({ refresh: true });
-        if (updateStatus.latestVersion) {
-          targetVersion = updateStatus.latestVersion;
-        }
-      } catch (error) {
-        console.log(
-          `[alphaclaw] Could not resolve exact AlphaClaw version before restart: ${error.message || "unknown error"}`,
+        fs.writeFileSync(
+          markerPath,
+          JSON.stringify({ from: previousVersion, ts: Date.now() }),
         );
+        console.log(`[alphaclaw] Update marker written to ${markerPath}`);
+      } catch (e) {
+        console.log(`[alphaclaw] Could not write update marker: ${e.message}`);
       }
-
-      const spec = buildAlphaclawInstallSpec(targetVersion);
-      // Write marker to persistent volume so the update survives container recreation
-      const markerPath = path.join(kRootDir, ".alphaclaw-update-pending");
-      fs.writeFileSync(
-        markerPath,
-        JSON.stringify({
-          from: previousVersion,
-          to: targetVersion,
-          spec,
-          ts: Date.now(),
-        }),
-      );
-      console.log(
-        `[alphaclaw] Update marker written to ${markerPath} for ${spec}`,
-      );
       kUpdateStatusCache = {
         latestVersion: null,
         hasUpdate: false,
@@ -206,17 +299,15 @@ const createAlphaclawVersionService = () => {
         body: {
           ok: true,
           previousVersion,
-          targetVersion: targetVersion === "latest" ? null : targetVersion,
           restarting: true,
         },
       };
     } catch (err) {
+      kUpdateInProgress = false;
       return {
         status: 500,
         body: { ok: false, error: err.message || "Failed to update AlphaClaw" },
       };
-    } finally {
-      kUpdateInProgress = false;
     }
   };
 

package/lib/server/openclaw-version.js

@@ -1,10 +1,12 @@
-const { execSync } = require("child_process");
+const { exec, execSync } = require("child_process");
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 const {
   kVersionCacheTtlMs,
   kLatestVersionCacheTtlMs,
-  kRootDir,
+  kNpmPackageRoot,
+  kOpenclawUpdateCopyTimeoutMs,
 } = require("./constants");
 const { normalizeOpenclawVersion } = require("./helpers");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
@@ -22,9 +24,6 @@ const createOpenclawVersionService = ({
   };
   let kOpenclawUpdateInProgress = false;
 
-  const buildOpenclawInstallSpec = (version = "latest") =>
-    `openclaw@${String(version || "").trim() || "latest"}`;
-
   const readOpenclawVersion = () => {
     const now = Date.now();
     if (
@@ -88,6 +87,118 @@ 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 {
@@ -117,67 +228,27 @@ const createOpenclawVersionService = ({
     kOpenclawUpdateInProgress = true;
     const previousVersion = readOpenclawVersion();
     try {
-      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,
-          },
-        };
+      await installLatestOpenclaw();
+      kOpenclawVersionCache = { value: null, fetchedAt: 0 };
+      const currentVersion = readOpenclawVersion();
+      const { latestVersion, hasUpdate } = readOpenclawUpdateStatus({
+        refresh: true,
+      });
+      let restarted = false;
+      if (isOnboarded()) {
+        restartGateway();
+        restarted = true;
       }
-
-      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: previousVersion,
-          targetVersion: targetVersion === "latest" ? null : targetVersion,
+          currentVersion,
           latestVersion,
-          hasUpdate: true,
-          restarted: false,
-          restarting: true,
-          updated: previousVersion !== targetVersion,
+          hasUpdate,
+          restarted,
+          updated: previousVersion !== currentVersion,
         },
       };
     } catch (err) {

package/lib/server/routes/system.js

@@ -588,12 +588,7 @@ const registerSystemRoutes = ({
     console.log(
       `[alphaclaw] /api/openclaw/update result: status=${result.status} ok=${result.body?.ok === true}`,
     );
-    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);
-    }
+    res.status(result.status).json(result.body);
   });
 
   app.get("/api/alphaclaw/version", async (req, res) => {

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

@@ -8,27 +8,6 @@ const kUsageTrackerPluginPath = path.resolve(
   "usage-tracker",
 );
 
-const normalizePluginPath = (value = "") =>
-  String(value || "")
-    .trim()
-    .replace(/\\/g, "/")
-    .replace(/\/+$/, "");
-
-const isUsageTrackerPluginPath = (value = "") => {
-  const normalizedValue = normalizePluginPath(value);
-  const normalizedCanonicalPath = normalizePluginPath(kUsageTrackerPluginPath);
-  if (!normalizedValue) return false;
-  if (
-    normalizedValue === normalizedCanonicalPath ||
-    normalizedValue.startsWith(`${normalizedCanonicalPath}/`)
-  ) {
-    return true;
-  }
-  return /(?:^|\/)(?:node_modules\/@chrysb\/alphaclaw\/lib|lib)\/plugin\/usage-tracker(?:\/.*)?$/.test(
-    normalizedValue,
-  );
-};
-
 const ensurePluginsShell = (cfg = {}) => {
   if (!cfg.plugins || typeof cfg.plugins !== "object") cfg.plugins = {};
   if (!Array.isArray(cfg.plugins.allow)) cfg.plugins.allow = [];
@@ -53,11 +32,9 @@ const ensurePluginAllowed = ({ cfg = {}, pluginKey = "" }) => {
 const ensureUsageTrackerPluginEntry = (cfg = {}) => {
   const before = JSON.stringify(cfg);
   ensurePluginAllowed({ cfg, pluginKey: "usage-tracker" });
-  const nextPaths = cfg.plugins.load.paths.filter(
-    (entry) => !isUsageTrackerPluginPath(entry),
-  );
-  nextPaths.push(kUsageTrackerPluginPath);
-  cfg.plugins.load.paths = nextPaths;
+  if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
+    cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
+  }
   cfg.plugins.entries["usage-tracker"] = {
     ...(cfg.plugins.entries["usage-tracker"] &&
     typeof cfg.plugins.entries["usage-tracker"] === "object"
@@ -87,7 +64,6 @@ const ensureUsageTrackerPluginConfig = ({ fsModule, openclawDir }) => {
 
 module.exports = {
   kUsageTrackerPluginPath,
-  isUsageTrackerPluginPath,
   ensurePluginsShell,
   ensurePluginAllowed,
   ensureUsageTrackerPluginEntry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.7-beta.4",
+  "version": "0.8.7",
   "publishConfig": {
     "access": "public"
   },
@@ -36,7 +36,7 @@
   "dependencies": {
     "express": "^4.21.0",
     "http-proxy": "^1.18.1",
-    "openclaw": "2026.4.1",
+    "openclaw": "2026.4.5",
     "patch-package": "^8.0.1",
     "ws": "^8.19.0"
   },

package/patches/openclaw+2026.4.5.patch

@@ -0,0 +1,13 @@
+diff --git a/node_modules/openclaw/dist/server-Cv5hzFG4.js b/node_modules/openclaw/dist/server-Cv5hzFG4.js
+index 926102f391c94b0e8bb52c2d322c107636e267f3..9e04644fcb8cc406d9b50f2590c5e12788cb7b6e 100644
+--- a/node_modules/openclaw/dist/server-Cv5hzFG4.js
++++ b/node_modules/openclaw/dist/server-Cv5hzFG4.js
+@@ -26710,7 +26710,7 @@
+ 					close(1008, truncateCloseReason(authMessage));
+ 				};
+ 				const clearUnboundScopes = () => {
+-					if (scopes.length > 0) {
++					if (scopes.length > 0 && !sharedAuthOk) {
+ 						scopes = [];
+ 						connectParams.scopes = scopes;
+ 					}

package/lib/public/js/components/update-modal-helpers.js

@@ -1,12 +0,0 @@
-export const createUpdateModalSubmitHandler = ({
-  onClose = () => {},
-  onUpdate = async () => ({ ok: false }),
-}) => {
-  return async () => {
-    const result = await onUpdate();
-    if (result?.ok) {
-      onClose();
-    }
-    return result;
-  };
-};