@chrysb/alphaclaw 0.8.7-beta.0 → 0.8.7-beta.1

package/bin/alphaclaw.js

@@ -19,6 +19,11 @@ const {
 const {
   applyPendingOpenclawUpdate,
 } = require("../lib/server/pending-openclaw-update");
+const {
+  getManagedOpenclawRuntimeDir,
+  prependManagedOpenclawBinToPath,
+  syncManagedOpenclawRuntimeWithBundled,
+} = require("../lib/server/openclaw-runtime");
 
 const kUsageTrackerPluginPath = path.resolve(
   __dirname,
@@ -206,21 +211,34 @@ if (fs.existsSync(pendingUpdateMarker)) {
 }
 
 const pendingOpenclawUpdateMarker = path.join(rootDir, ".openclaw-update-pending");
+const managedOpenclawRuntimeDir = getManagedOpenclawRuntimeDir({ rootDir });
 if (fs.existsSync(pendingOpenclawUpdateMarker)) {
-  const alphaPkgRoot = path.resolve(__dirname, "..");
-  const nmIndex = alphaPkgRoot.lastIndexOf(
-    `${path.sep}node_modules${path.sep}`,
-  );
-  const installDir =
-    nmIndex >= 0 ? alphaPkgRoot.slice(0, nmIndex) : alphaPkgRoot;
   applyPendingOpenclawUpdate({
     execSyncImpl: execSync,
     fsModule: fs,
-    installDir,
+    installDir: managedOpenclawRuntimeDir,
     logger: console,
     markerPath: pendingOpenclawUpdateMarker,
   });
 }
+try {
+  syncManagedOpenclawRuntimeWithBundled({
+    execSyncImpl: execSync,
+    fsModule: fs,
+    logger: console,
+    runtimeDir: managedOpenclawRuntimeDir,
+  });
+} catch (error) {
+  console.log(
+    `[alphaclaw] Could not sync managed OpenClaw runtime from bundled install: ${error.message}`,
+  );
+}
+prependManagedOpenclawBinToPath({
+  env: process.env,
+  fsModule: fs,
+  logger: console,
+  runtimeDir: managedOpenclawRuntimeDir,
+});
 
 // ---------------------------------------------------------------------------
 // 3. Symlink ~/.openclaw -> <root>/.openclaw

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/pending-openclaw-update.js

@@ -1,3 +1,7 @@
+const {
+  installManagedOpenclawRuntime,
+} = require("./openclaw-runtime");
+
 const buildPendingOpenclawInstallSpec = (marker = {}) => {
   const explicitSpec = String(marker?.spec || "").trim();
   if (explicitSpec) {
@@ -7,9 +11,6 @@ const buildPendingOpenclawInstallSpec = (marker = {}) => {
   return `openclaw@${targetVersion}`;
 };
 
-const shellQuote = (value) =>
-  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
-
 const applyPendingOpenclawUpdate = ({
   execSyncImpl,
   fsModule,
@@ -36,14 +37,13 @@ const applyPendingOpenclawUpdate = ({
   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,
-      },
-    );
+    installManagedOpenclawRuntime({
+      execSyncImpl,
+      fsModule,
+      logger,
+      runtimeDir: installDir,
+      spec,
+    });
     fsModule.unlinkSync(markerPath);
     logger.log("[alphaclaw] OpenClaw update applied successfully");
     return {

package/package.json

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