@chrysb/alphaclaw 0.8.6 → 0.8.7-beta.1

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-runtime.js

@@ -0,0 +1,260 @@
+const fs = require("fs");
+const path = require("path");
+
+const { kRootDir } = require("./constants");
+const {
+  compareVersionParts,
+  normalizeOpenclawVersion,
+} = require("./helpers");
+
+const getManagedOpenclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
+  path.join(rootDir, ".openclaw-runtime");
+
+const getManagedOpenclawBinDir = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedOpenclawRuntimeDir(),
+    "node_modules",
+    ".bin",
+  );
+
+const getManagedOpenclawBinPath = ({ runtimeDir } = {}) =>
+  path.join(getManagedOpenclawBinDir({ runtimeDir }), "openclaw");
+
+const getManagedOpenclawPackageJsonPath = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedOpenclawRuntimeDir(),
+    "node_modules",
+    "openclaw",
+    "package.json",
+  );
+
+const ensureManagedOpenclawRuntimeProject = ({
+  fsModule = fs,
+  runtimeDir,
+} = {}) => {
+  const resolvedRuntimeDir = runtimeDir || getManagedOpenclawRuntimeDir();
+  const packageJsonPath = path.join(resolvedRuntimeDir, "package.json");
+  fsModule.mkdirSync(resolvedRuntimeDir, { recursive: true });
+  if (!fsModule.existsSync(packageJsonPath)) {
+    fsModule.writeFileSync(
+      packageJsonPath,
+      JSON.stringify(
+        {
+          name: "alphaclaw-openclaw-runtime",
+          private: true,
+        },
+        null,
+        2,
+      ),
+    );
+  }
+  return {
+    runtimeDir: resolvedRuntimeDir,
+    packageJsonPath,
+  };
+};
+
+const readManagedOpenclawRuntimeVersion = ({
+  fsModule = fs,
+  runtimeDir,
+} = {}) => {
+  try {
+    const pkg = JSON.parse(
+      fsModule.readFileSync(
+        getManagedOpenclawPackageJsonPath({ runtimeDir }),
+        "utf8",
+      ),
+    );
+    return normalizeOpenclawVersion(pkg?.version || "");
+  } catch {
+    return null;
+  }
+};
+
+const readBundledOpenclawVersion = ({
+  fsModule = fs,
+  resolveImpl = require.resolve,
+} = {}) => {
+  try {
+    const pkgPath = resolveImpl("openclaw/package.json");
+    const pkg = JSON.parse(fsModule.readFileSync(pkgPath, "utf8"));
+    return normalizeOpenclawVersion(pkg?.version || "");
+  } catch {
+    return null;
+  }
+};
+
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+const applyManagedOpenclawPatch = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  version,
+  alphaclawRoot = path.resolve(__dirname, "..", ".."),
+} = {}) => {
+  const normalizedVersion = normalizeOpenclawVersion(version);
+  if (!normalizedVersion) return false;
+  const patchesDir = path.join(alphaclawRoot, "patches");
+  const patchFileName = `openclaw+${normalizedVersion}.patch`;
+  const patchFilePath = path.join(patchesDir, patchFileName);
+  if (!fsModule.existsSync(patchFilePath)) {
+    return false;
+  }
+
+  const runtimePatchDirName = ".alphaclaw-patches";
+  const runtimePatchDirPath = path.join(runtimeDir, runtimePatchDirName);
+  try {
+    if (fsModule.existsSync(runtimePatchDirPath)) {
+      fsModule.rmSync(runtimePatchDirPath, { recursive: true, force: true });
+    }
+  } catch {}
+  fsModule.symlinkSync(patchesDir, runtimePatchDirPath);
+
+  const patchPackageMain = require.resolve("patch-package/dist/index.js", {
+    paths: [alphaclawRoot],
+  });
+  logger.log(
+    `[alphaclaw] Applying bundled OpenClaw patch for ${normalizedVersion}...`,
+  );
+  execSyncImpl(
+    `${shellQuote(process.execPath)} ${shellQuote(patchPackageMain)} --patch-dir ${shellQuote(runtimePatchDirName)}`,
+    {
+      cwd: runtimeDir,
+      stdio: "inherit",
+      timeout: 120000,
+    },
+  );
+  return true;
+};
+
+const installManagedOpenclawRuntime = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  spec,
+  alphaclawRoot,
+} = {}) => {
+  const normalizedSpec = String(spec || "").trim() || "openclaw@latest";
+  ensureManagedOpenclawRuntimeProject({
+    fsModule,
+    runtimeDir,
+  });
+  execSyncImpl(
+    `npm install ${shellQuote(normalizedSpec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+    {
+      cwd: runtimeDir,
+      stdio: "inherit",
+      timeout: 180000,
+    },
+  );
+  const installedVersion = readManagedOpenclawRuntimeVersion({
+    fsModule,
+    runtimeDir,
+  });
+  applyManagedOpenclawPatch({
+    execSyncImpl,
+    fsModule,
+    logger,
+    runtimeDir,
+    version: installedVersion,
+    alphaclawRoot,
+  });
+  return {
+    spec: normalizedSpec,
+    version: installedVersion,
+  };
+};
+
+const syncManagedOpenclawRuntimeWithBundled = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  resolveImpl,
+  alphaclawRoot,
+} = {}) => {
+  const bundledVersion = readBundledOpenclawVersion({
+    fsModule,
+    resolveImpl,
+  });
+  if (!bundledVersion) {
+    return {
+      checked: false,
+      synced: false,
+      bundledVersion: null,
+      runtimeVersion: readManagedOpenclawRuntimeVersion({ fsModule, runtimeDir }),
+    };
+  }
+
+  const runtimeVersion = readManagedOpenclawRuntimeVersion({
+    fsModule,
+    runtimeDir,
+  });
+  if (runtimeVersion && compareVersionParts(runtimeVersion, bundledVersion) >= 0) {
+    return {
+      checked: true,
+      synced: false,
+      bundledVersion,
+      runtimeVersion,
+    };
+  }
+
+  logger.log(
+    runtimeVersion
+      ? `[alphaclaw] Managed OpenClaw runtime ${runtimeVersion} is older than bundled ${bundledVersion}; syncing runtime...`
+      : `[alphaclaw] Managed OpenClaw runtime missing; seeding bundled OpenClaw ${bundledVersion}...`,
+  );
+  const installResult = installManagedOpenclawRuntime({
+    execSyncImpl,
+    fsModule,
+    logger,
+    runtimeDir,
+    spec: `openclaw@${bundledVersion}`,
+    alphaclawRoot,
+  });
+  return {
+    checked: true,
+    synced: true,
+    bundledVersion,
+    runtimeVersion: installResult.version || bundledVersion,
+  };
+};
+
+const prependManagedOpenclawBinToPath = ({
+  env = process.env,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+} = {}) => {
+  const resolvedRuntimeDir = runtimeDir || getManagedOpenclawRuntimeDir();
+  const binDir = getManagedOpenclawBinDir({ runtimeDir: resolvedRuntimeDir });
+  const binPath = getManagedOpenclawBinPath({ runtimeDir: resolvedRuntimeDir });
+  if (!fsModule.existsSync(binPath)) {
+    return false;
+  }
+  const currentEntries = String(env.PATH || "")
+    .split(path.delimiter)
+    .filter(Boolean);
+  const nextEntries = [binDir, ...currentEntries.filter((entry) => entry !== binDir)];
+  env.PATH = nextEntries.join(path.delimiter);
+  logger.log(`[alphaclaw] Using managed OpenClaw runtime from ${resolvedRuntimeDir}`);
+  return true;
+};
+
+module.exports = {
+  applyManagedOpenclawPatch,
+  ensureManagedOpenclawRuntimeProject,
+  getManagedOpenclawBinDir,
+  getManagedOpenclawBinPath,
+  getManagedOpenclawPackageJsonPath,
+  getManagedOpenclawRuntimeDir,
+  installManagedOpenclawRuntime,
+  prependManagedOpenclawBinToPath,
+  readBundledOpenclawVersion,
+  readManagedOpenclawRuntimeVersion,
+  syncManagedOpenclawRuntimeWithBundled,
+};

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) {