@chrysb/alphaclaw 0.8.8 → 0.8.10

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

@@ -2,7 +2,6 @@ const path = require("path");
 const { spawn, execSync } = require("child_process");
 const fs = require("fs");
 const net = require("net");
-const { getManagedOpenclawBinPath } = require("./openclaw-runtime");
 const {
   ALPHACLAW_DIR,
   OPENCLAW_DIR,
@@ -49,16 +48,6 @@ const gatewayEnv = () => ({
   XDG_CONFIG_HOME: OPENCLAW_DIR,
 });
 
-const shellQuote = (value) =>
-  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
-
-const getOpenclawCommandPath = () => {
-  const managedBinPath = getManagedOpenclawBinPath();
-  return fs.existsSync(managedBinPath) ? managedBinPath : "openclaw";
-};
-
-const getOpenclawCommandPrefix = () => shellQuote(getOpenclawCommandPath());
-
 const writeOnboardingMarker = (reason) => {
   fs.mkdirSync(ALPHACLAW_DIR, { recursive: true });
   fs.writeFileSync(
@@ -130,10 +119,9 @@ const isGatewayRunning = () =>
   });
 
 const runGatewayCmd = (cmd) => {
-  const openclawCommandPrefix = getOpenclawCommandPrefix();
-  console.log(`[alphaclaw] Running: ${openclawCommandPrefix} gateway ${cmd}`);
+  console.log(`[alphaclaw] Running: openclaw gateway ${cmd}`);
   try {
-    const out = execSync(`${openclawCommandPrefix} gateway ${cmd}`, {
+    const out = execSync(`openclaw gateway ${cmd}`, {
       env: gatewayEnv(),
       timeout: 15000,
       encoding: "utf8",
@@ -158,7 +146,7 @@ const launchGatewayProcess = () => {
     return gatewayChild;
   }
   gatewayStderrTail = [];
-  const child = spawn(getOpenclawCommandPath(), ["gateway", "run"], {
+  const child = spawn("openclaw", ["gateway", "run"], {
     env: gatewayEnv(),
     stdio: ["pipe", "pipe", "pipe"],
   });
@@ -318,7 +306,7 @@ const syncChannelConfig = (savedVars, mode = "all") => {
             const appToken = savedMap[def.extraEnvKeys?.[0]];
             if (!appToken) continue;
             execSync(
-              `${getOpenclawCommandPrefix()} channels add --channel slack --bot-token "${token}" --app-token "${appToken}"`,
+              `openclaw channels add --channel slack --bot-token "${token}" --app-token "${appToken}"`,
               { env, timeout: 15000, encoding: "utf8" },
             );
             let raw = fs.readFileSync(configPath, "utf8");
@@ -330,14 +318,11 @@ const syncChannelConfig = (savedVars, mode = "all") => {
             }
             fs.writeFileSync(configPath, raw);
           } else {
-            execSync(
-              `${getOpenclawCommandPrefix()} channels add --channel ${ch} --token "${token}"`,
-              {
-                env,
-                timeout: 15000,
-                encoding: "utf8",
-              },
-            );
+            execSync(`openclaw channels add --channel ${ch} --token "${token}"`, {
+              env,
+              timeout: 15000,
+              encoding: "utf8",
+            });
             const raw = fs.readFileSync(configPath, "utf8");
             if (raw.includes(token)) {
               fs.writeFileSync(
@@ -359,14 +344,11 @@ const syncChannelConfig = (savedVars, mode = "all") => {
       ) {
         console.log(`[alphaclaw] Removing channel: ${ch}`);
         try {
-          execSync(
-            `${getOpenclawCommandPrefix()} channels remove --channel ${ch} --delete`,
-            {
-              env,
-              timeout: 15000,
-              encoding: "utf8",
-            },
-          );
+          execSync(`openclaw channels remove --channel ${ch} --delete`, {
+            env,
+            timeout: 15000,
+            encoding: "utf8",
+          });
           console.log(`[alphaclaw] Channel ${ch} removed`);
         } catch (e) {
           console.error(

package/lib/server/init/register-server-routes.js

@@ -90,13 +90,7 @@ const registerServerRoutes = ({
     loginThrottle,
   });
 
-  registerPageRoutes({
-    app,
-    requireAuth,
-    isGatewayRunning,
-    alphaclawVersionService,
-    openclawVersionService,
-  });
+  registerPageRoutes({ app, requireAuth, isGatewayRunning });
   registerModelRoutes({
     app,
     shellCmd,

package/lib/server/openclaw-version.js

@@ -1,13 +1,14 @@
-const { execFileSync } = 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 { getManagedOpenclawBinPath } = require("./openclaw-runtime");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
 
 const createOpenclawVersionService = ({
@@ -23,14 +24,6 @@ const createOpenclawVersionService = ({
   };
   let kOpenclawUpdateInProgress = false;
 
-  const buildOpenclawInstallSpec = (version = "latest") =>
-    `openclaw@${String(version || "").trim() || "latest"}`;
-
-  const getOpenclawCommandPath = () => {
-    const managedBinPath = getManagedOpenclawBinPath();
-    return fs.existsSync(managedBinPath) ? managedBinPath : "openclaw";
-  };
-
   const readOpenclawVersion = () => {
     const now = Date.now();
     if (
@@ -40,9 +33,9 @@ const createOpenclawVersionService = ({
       return kOpenclawVersionCache.value;
     }
     try {
-      const raw = execFileSync(getOpenclawCommandPath(), ["--version"], {
+      const raw = execSync("openclaw --version", {
         env: gatewayEnv(),
-        timeout: 10000,
+        timeout: 5000,
         encoding: "utf8",
       }).trim();
       const version = normalizeOpenclawVersion(raw);
@@ -66,16 +59,11 @@ const createOpenclawVersionService = ({
       };
     }
     try {
-      const raw = execFileSync(
-        getOpenclawCommandPath(),
-        ["update", "status", "--json"],
-        {
+      const raw = execSync("openclaw update status --json", {
         env: gatewayEnv(),
-          timeout: 30000,
-          maxBuffer: 4 * 1024 * 1024,
-          encoding: "utf8",
-        },
-      ).trim();
+        timeout: 8000,
+        encoding: "utf8",
+      }).trim();
       const parsed = parseJsonObjectFromNoisyOutput(raw);
       if (!parsed) {
         throw new Error("openclaw update status returned invalid JSON payload");
@@ -99,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 {
@@ -128,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/pages.js

@@ -1,19 +1,11 @@
 const path = require("path");
 
-const registerPageRoutes = ({
-  app,
-  requireAuth,
-  isGatewayRunning,
-  alphaclawVersionService,
-  openclawVersionService,
-}) => {
+const registerPageRoutes = ({ app, requireAuth, isGatewayRunning }) => {
   app.get("/health", async (req, res) => {
     const running = await isGatewayRunning();
     res.json({
       status: running ? "healthy" : "starting",
       gateway: running ? "running" : "starting",
-      alphaclawVersion: alphaclawVersionService?.readAlphaclawVersion?.() || null,
-      openclawVersion: openclawVersionService?.readOpenclawVersion?.() || null,
     });
   });
 

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,