@chrysb/alphaclaw 0.8.7 → 0.8.8

package/lib/server/openclaw-version.js

@@ -1,14 +1,13 @@
-const { exec, execSync } = require("child_process");
+const { execFileSync } = 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 { getManagedOpenclawBinPath } = require("./openclaw-runtime");
 const { parseJsonObjectFromNoisyOutput } = require("./utils/json");
 
 const createOpenclawVersionService = ({
@@ -24,6 +23,14 @@ 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 (
@@ -33,9 +40,9 @@ const createOpenclawVersionService = ({
       return kOpenclawVersionCache.value;
     }
     try {
-      const raw = execSync("openclaw --version", {
+      const raw = execFileSync(getOpenclawCommandPath(), ["--version"], {
         env: gatewayEnv(),
-        timeout: 5000,
+        timeout: 10000,
         encoding: "utf8",
       }).trim();
       const version = normalizeOpenclawVersion(raw);
@@ -59,11 +66,16 @@ const createOpenclawVersionService = ({
       };
     }
     try {
-      const raw = execSync("openclaw update status --json", {
+      const raw = execFileSync(
+        getOpenclawCommandPath(),
+        ["update", "status", "--json"],
+        {
         env: gatewayEnv(),
-        timeout: 8000,
-        encoding: "utf8",
-      }).trim();
+          timeout: 30000,
+          maxBuffer: 4 * 1024 * 1024,
+          encoding: "utf8",
+        },
+      ).trim();
       const parsed = parseJsonObjectFromNoisyOutput(raw);
       if (!parsed) {
         throw new Error("openclaw update status returned invalid JSON payload");
@@ -87,118 +99,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 +128,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/package-fingerprint.js

@@ -0,0 +1,274 @@
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const kIgnoredDirectoryNames = new Set([".git", "node_modules"]);
+
+const normalizeRelativePath = (packageRoot, absolutePath) =>
+  path.relative(packageRoot, absolutePath).split(path.sep).join("/");
+
+const addIncludedPath = ({ includeSet, value }) => {
+  const normalizedValue = String(value || "").trim();
+  if (!normalizedValue) return;
+  includeSet.add(normalizedValue.replace(/\/+$/, ""));
+};
+
+const collectIncludedPaths = ({ packageJson = {} } = {}) => {
+  const includeSet = new Set(["package.json"]);
+
+  if (Array.isArray(packageJson.files)) {
+    for (const entry of packageJson.files) {
+      addIncludedPath({ includeSet, value: entry });
+    }
+  }
+
+  if (typeof packageJson.bin === "string") {
+    addIncludedPath({ includeSet, value: packageJson.bin });
+  } else if (packageJson.bin && typeof packageJson.bin === "object") {
+    for (const entry of Object.values(packageJson.bin)) {
+      addIncludedPath({ includeSet, value: entry });
+    }
+  }
+
+  return Array.from(includeSet).sort((left, right) => left.localeCompare(right));
+};
+
+const walkIncludedFiles = ({
+  fsModule = fs,
+  packageRoot,
+  absolutePath,
+  files,
+}) => {
+  if (!fsModule.existsSync(absolutePath)) return;
+  const relativePath = normalizeRelativePath(packageRoot, absolutePath);
+  if (!relativePath || relativePath.startsWith("..")) return;
+
+  const stat = fsModule.lstatSync(absolutePath);
+  if (stat.isSymbolicLink()) {
+    files.push({
+      relativePath,
+      hash: `symlink:${fsModule.readlinkSync(absolutePath)}`,
+    });
+    return;
+  }
+  if (stat.isFile()) {
+    files.push({
+      relativePath,
+      hash: crypto
+        .createHash("sha256")
+        .update(fsModule.readFileSync(absolutePath))
+        .digest("hex"),
+    });
+    return;
+  }
+  if (!stat.isDirectory()) return;
+
+  const entries = fsModule
+    .readdirSync(absolutePath, { withFileTypes: true })
+    .sort((left, right) => left.name.localeCompare(right.name));
+
+  for (const entry of entries) {
+    if (entry.isDirectory() && kIgnoredDirectoryNames.has(entry.name)) continue;
+    walkIncludedFiles({
+      fsModule,
+      packageRoot,
+      absolutePath: path.join(absolutePath, entry.name),
+      files,
+    });
+  }
+};
+
+const computePackageFingerprint = ({
+  fsModule = fs,
+  packageRoot,
+  packageJsonPath = path.join(packageRoot, "package.json"),
+} = {}) => {
+  const resolvedPackageRoot = path.resolve(String(packageRoot || ""));
+  if (!resolvedPackageRoot || !fsModule.existsSync(packageJsonPath)) return null;
+
+  let packageJson;
+  try {
+    packageJson = JSON.parse(fsModule.readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return null;
+  }
+
+  const files = [];
+  for (const includePath of collectIncludedPaths({ packageJson })) {
+    walkIncludedFiles({
+      fsModule,
+      packageRoot: resolvedPackageRoot,
+      absolutePath: path.resolve(resolvedPackageRoot, includePath),
+      files,
+    });
+  }
+
+  const hash = crypto.createHash("sha256");
+  hash.update("package-fingerprint-v1");
+  for (const entry of files.sort((left, right) => left.relativePath.localeCompare(right.relativePath))) {
+    hash.update(entry.relativePath);
+    hash.update("\0");
+    hash.update(entry.hash);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+};
+
+const isPackageRootSymlink = ({
+  fsModule = fs,
+  packageRoot,
+} = {}) => {
+  const resolvedPackageRoot = path.resolve(String(packageRoot || ""));
+  if (!resolvedPackageRoot || !fsModule.existsSync(resolvedPackageRoot)) return false;
+  try {
+    return fsModule.lstatSync(resolvedPackageRoot).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+
+const resolvePackageRootFromEntryPath = ({
+  fsModule = fs,
+  entryPath,
+} = {}) => {
+  let cursor = path.dirname(path.resolve(String(entryPath || "")));
+  while (cursor && cursor !== path.dirname(cursor)) {
+    if (fsModule.existsSync(path.join(cursor, "package.json"))) {
+      return cursor;
+    }
+    cursor = path.dirname(cursor);
+  }
+  return null;
+};
+
+const resolveInstallRootFromPackageRoot = ({ packageRoot } = {}) => {
+  const resolvedPackageRoot = path.resolve(String(packageRoot || ""));
+  if (!resolvedPackageRoot) return "";
+  const nodeModulesSegment = `${path.sep}node_modules${path.sep}`;
+  const nodeModulesIndex = resolvedPackageRoot.lastIndexOf(nodeModulesSegment);
+  if (nodeModulesIndex < 0) {
+    return resolvedPackageRoot;
+  }
+  return resolvedPackageRoot.slice(0, nodeModulesIndex);
+};
+
+const seedRuntimeFromBundledInstall = ({
+  fsModule = fs,
+  packageRoot,
+  runtimeDir,
+  runtimePackageJson,
+} = {}) => {
+  const installRoot = resolveInstallRootFromPackageRoot({ packageRoot });
+  const bundledNodeModulesPath = path.join(installRoot, "node_modules");
+  if (!installRoot || !fsModule.existsSync(bundledNodeModulesPath)) {
+    return {
+      seeded: false,
+      installRoot,
+      bundledNodeModulesPath,
+    };
+  }
+
+  const resolvedRuntimeDir = path.resolve(String(runtimeDir || ""));
+  const runtimeParentDir = path.dirname(resolvedRuntimeDir);
+  fsModule.mkdirSync(runtimeParentDir, { recursive: true });
+  const tempRuntimeDir = fsModule.mkdtempSync(
+    path.join(runtimeParentDir, `${path.basename(resolvedRuntimeDir)}-seed-`),
+  );
+  let seeded = false;
+  try {
+    if (runtimePackageJson) {
+      fsModule.writeFileSync(
+        path.join(tempRuntimeDir, "package.json"),
+        JSON.stringify(runtimePackageJson, null, 2),
+      );
+    }
+    fsModule.cpSync(
+      bundledNodeModulesPath,
+      path.join(tempRuntimeDir, "node_modules"),
+      {
+        recursive: true,
+        dereference: true,
+        preserveTimestamps: true,
+      },
+    );
+    try {
+      fsModule.rmSync(resolvedRuntimeDir, { recursive: true, force: true });
+    } catch {}
+    fsModule.renameSync(tempRuntimeDir, resolvedRuntimeDir);
+    seeded = true;
+    return {
+      seeded: true,
+      installRoot,
+      bundledNodeModulesPath,
+      runtimeDir: resolvedRuntimeDir,
+    };
+  } finally {
+    if (!seeded) {
+      try {
+        fsModule.rmSync(tempRuntimeDir, { recursive: true, force: true });
+      } catch {}
+    }
+  }
+};
+
+const packLocalPackageForInstall = ({
+  execSyncImpl,
+  fsModule = fs,
+  packageRoot,
+  tempDirPrefix = "alphaclaw-package-pack-",
+} = {}) => {
+  const resolvedPackageRoot = path.resolve(String(packageRoot || ""));
+  const packDir = fsModule.mkdtempSync(path.join(os.tmpdir(), tempDirPrefix));
+  try {
+    const packStdout = String(
+      execSyncImpl(
+        `npm pack ${shellQuote(resolvedPackageRoot)} --quiet --ignore-scripts --pack-destination ${shellQuote(packDir)}`,
+        {
+          encoding: "utf8",
+          stdio: ["ignore", "pipe", "inherit"],
+          timeout: 180000,
+        },
+      ) || "",
+    )
+      .trim()
+      .split(/\r?\n/)
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+    const packFileName =
+      packStdout.at(-1) ||
+      fsModule.readdirSync(packDir).find((entry) => entry.endsWith(".tgz"));
+    if (!packFileName) {
+      throw new Error(`npm pack did not produce a tarball for ${resolvedPackageRoot}`);
+    }
+    const tarballPath = path.join(packDir, packFileName);
+    if (!fsModule.existsSync(tarballPath)) {
+      throw new Error(`Packed tarball missing at ${tarballPath}`);
+    }
+    return {
+      tarballPath,
+      cleanup: () => {
+        try {
+          fsModule.rmSync(packDir, { recursive: true, force: true });
+        } catch {}
+      },
+    };
+  } catch (error) {
+    try {
+      fsModule.rmSync(packDir, { recursive: true, force: true });
+    } catch {}
+    throw error;
+  }
+};
+
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+module.exports = {
+  computePackageFingerprint,
+  isPackageRootSymlink,
+  packLocalPackageForInstall,
+  resolveInstallRootFromPackageRoot,
+  resolvePackageRootFromEntryPath,
+  seedRuntimeFromBundledInstall,
+};

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

@@ -0,0 +1,85 @@
+const path = require("path");
+
+const {
+  installManagedAlphaclawRuntime,
+} = require("./alphaclaw-runtime");
+
+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 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}...`);
+
+  const resolvedInstallDir = path.resolve(String(installDir || ""));
+  const installParentDir = path.dirname(resolvedInstallDir);
+  const tempInstallDir = fsModule.mkdtempSync(
+    path.join(installParentDir, `${path.basename(resolvedInstallDir)}-pending-`),
+  );
+
+  try {
+    installManagedAlphaclawRuntime({
+      execSyncImpl,
+      fsModule,
+      runtimeDir: tempInstallDir,
+      spec,
+    });
+    try {
+      fsModule.rmSync(resolvedInstallDir, { recursive: true, force: true });
+    } catch {}
+    fsModule.renameSync(tempInstallDir, resolvedInstallDir);
+    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.rmSync(tempInstallDir, { recursive: true, force: true });
+    } catch {}
+    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,86 @@
+const path = require("path");
+
+const {
+  installManagedOpenclawRuntime,
+} = require("./openclaw-runtime");
+
+const buildPendingOpenclawInstallSpec = (marker = {}) => {
+  const explicitSpec = String(marker?.spec || "").trim();
+  if (explicitSpec) {
+    return explicitSpec;
+  }
+  const targetVersion = String(marker?.to || "").trim() || "latest";
+  return `openclaw@${targetVersion}`;
+};
+
+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}...`);
+
+  const resolvedInstallDir = path.resolve(String(installDir || ""));
+  const installParentDir = path.dirname(resolvedInstallDir);
+  const tempInstallDir = fsModule.mkdtempSync(
+    path.join(installParentDir, `${path.basename(resolvedInstallDir)}-pending-`),
+  );
+
+  try {
+    installManagedOpenclawRuntime({
+      execSyncImpl,
+      fsModule,
+      logger,
+      runtimeDir: tempInstallDir,
+      spec,
+    });
+    try {
+      fsModule.rmSync(resolvedInstallDir, { recursive: true, force: true });
+    } catch {}
+    fsModule.renameSync(tempInstallDir, resolvedInstallDir);
+    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.rmSync(tempInstallDir, { recursive: true, force: true });
+    } catch {}
+    try {
+      fsModule.unlinkSync(markerPath);
+    } catch {}
+    return {
+      attempted: true,
+      installed: false,
+      spec,
+      error,
+    };
+  }
+};
+
+module.exports = {
+  applyPendingOpenclawUpdate,
+  buildPendingOpenclawInstallSpec,
+};