@chrysb/alphaclaw 0.8.6 → 0.8.7-beta.0

package/lib/server/alphaclaw-version.js

@@ -1,6 +1,4 @@
-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");
@@ -8,7 +6,6 @@ const {
   kLatestVersionCacheTtlMs,
   kAlphaclawRegistryUrl,
   kNpmPackageRoot,
-  kOpenclawUpdateCopyTimeoutMs,
   kRootDir,
 } = require("./constants");
 
@@ -26,6 +23,9 @@ 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,120 +108,6 @@ 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 ||
@@ -277,18 +163,33 @@ const createAlphaclawVersionService = () => {
     kUpdateInProgress = true;
     const previousVersion = readAlphaclawVersion();
     try {
-      await installLatestAlphaclaw();
-      // Write marker to persistent volume so the update survives container recreation
-      const markerPath = path.join(kRootDir, ".alphaclaw-update-pending");
+      let targetVersion = "latest";
       try {
-        fs.writeFileSync(
-          markerPath,
-          JSON.stringify({ from: previousVersion, ts: Date.now() }),
+        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"}`,
         );
-        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,
@@ -299,15 +200,17 @@ 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,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.6",
+  "version": "0.8.7-beta.0",
   "publishConfig": {
     "access": "public"
   },