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

package/bin/alphaclaw.js

@@ -16,9 +16,19 @@ const {
 const {
   applyPendingAlphaclawUpdate,
 } = require("../lib/server/pending-alphaclaw-update");
+const {
+  getManagedAlphaclawCliPath,
+  getManagedAlphaclawRuntimeDir,
+  syncManagedAlphaclawRuntimeWithBundled,
+} = require("../lib/server/alphaclaw-runtime");
 const {
   applyPendingOpenclawUpdate,
 } = require("../lib/server/pending-openclaw-update");
+const {
+  getManagedOpenclawRuntimeDir,
+  prependManagedOpenclawBinToPath,
+  syncManagedOpenclawRuntimeWithBundled,
+} = require("../lib/server/openclaw-runtime");
 
 const kUsageTrackerPluginPath = path.resolve(
   __dirname,
@@ -168,10 +178,89 @@ if (portFlag) {
   process.env.PORT = portFlag;
 }
 
+const kManagedAlphaclawRuntimeEnvFlag = "ALPHACLAW_MANAGED_RUNTIME_ACTIVE";
+const shouldBootstrapManagedAlphaclawRuntime =
+  command === "start" &&
+  process.env[kManagedAlphaclawRuntimeEnvFlag] !== "1";
+
 // ---------------------------------------------------------------------------
 // 2. Create directory structure
 // ---------------------------------------------------------------------------
 
+if (shouldBootstrapManagedAlphaclawRuntime) {
+  const { spawn } = require("child_process");
+  const managedAlphaclawRuntimeDir = getManagedAlphaclawRuntimeDir({ rootDir });
+  const pendingUpdateMarker = path.join(rootDir, ".alphaclaw-update-pending");
+  if (fs.existsSync(pendingUpdateMarker)) {
+    applyPendingAlphaclawUpdate({
+      execSyncImpl: execSync,
+      fsModule: fs,
+      installDir: managedAlphaclawRuntimeDir,
+      logger: console,
+      markerPath: pendingUpdateMarker,
+    });
+  }
+  try {
+    syncManagedAlphaclawRuntimeWithBundled({
+      execSyncImpl: execSync,
+      fsModule: fs,
+      logger: console,
+      runtimeDir: managedAlphaclawRuntimeDir,
+    });
+  } catch (error) {
+    console.log(
+      `[alphaclaw] Could not sync managed AlphaClaw runtime from bundled install: ${error.message}`,
+    );
+  }
+
+  const managedAlphaclawCliPath = getManagedAlphaclawCliPath({
+    runtimeDir: managedAlphaclawRuntimeDir,
+  });
+  if (!fs.existsSync(managedAlphaclawCliPath)) {
+    console.error(
+      `[alphaclaw] Managed AlphaClaw runtime missing CLI at ${managedAlphaclawCliPath}`,
+    );
+    process.exit(1);
+  }
+
+  const runtimeChild = spawn(
+    process.argv[0],
+    [managedAlphaclawCliPath, ...process.argv.slice(2)],
+    {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        [kManagedAlphaclawRuntimeEnvFlag]: "1",
+        ALPHACLAW_BOOTSTRAP_CLI_PATH: __filename,
+      },
+    },
+  );
+
+  const forwardSignal = (signal) => {
+    if (runtimeChild.exitCode === null && !runtimeChild.killed) {
+      runtimeChild.kill(signal);
+    }
+  };
+
+  process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+  process.on("SIGINT", () => forwardSignal("SIGINT"));
+
+  runtimeChild.on("error", (error) => {
+    console.error(
+      `[alphaclaw] Managed AlphaClaw runtime launch failed: ${error.message}`,
+    );
+    process.exit(1);
+  });
+
+  runtimeChild.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(Number.isInteger(code) ? code : 0);
+  });
+} else {
+
 const openclawDir = path.join(rootDir, ".openclaw");
 fs.mkdirSync(openclawDir, { recursive: true });
 const { hourlyGitSyncPath } = migrateManagedInternalFiles({
@@ -206,21 +295,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
@@ -934,3 +1036,4 @@ try {
 
 console.log("[alphaclaw] Setup complete -- starting server");
 require("../lib/server.js");
+}

package/lib/server/alphaclaw-runtime.js

@@ -0,0 +1,180 @@
+const fs = require("fs");
+const path = require("path");
+
+const { kRootDir } = require("./constants");
+const { compareVersionParts } = require("./helpers");
+
+const getManagedAlphaclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
+  path.join(rootDir, ".alphaclaw-runtime");
+
+const getManagedAlphaclawCliPath = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedAlphaclawRuntimeDir(),
+    "node_modules",
+    "@chrysb",
+    "alphaclaw",
+    "bin",
+    "alphaclaw.js",
+  );
+
+const getManagedAlphaclawPackageJsonPath = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedAlphaclawRuntimeDir(),
+    "node_modules",
+    "@chrysb",
+    "alphaclaw",
+    "package.json",
+  );
+
+const ensureManagedAlphaclawRuntimeProject = ({
+  fsModule = fs,
+  runtimeDir,
+} = {}) => {
+  const resolvedRuntimeDir = runtimeDir || getManagedAlphaclawRuntimeDir();
+  const packageJsonPath = path.join(resolvedRuntimeDir, "package.json");
+  fsModule.mkdirSync(resolvedRuntimeDir, { recursive: true });
+  if (!fsModule.existsSync(packageJsonPath)) {
+    fsModule.writeFileSync(
+      packageJsonPath,
+      JSON.stringify(
+        {
+          name: "alphaclaw-runtime",
+          private: true,
+        },
+        null,
+        2,
+      ),
+    );
+  }
+  return {
+    runtimeDir: resolvedRuntimeDir,
+    packageJsonPath,
+  };
+};
+
+const readManagedAlphaclawRuntimeVersion = ({
+  fsModule = fs,
+  runtimeDir,
+} = {}) => {
+  try {
+    const pkg = JSON.parse(
+      fsModule.readFileSync(
+        getManagedAlphaclawPackageJsonPath({ runtimeDir }),
+        "utf8",
+      ),
+    );
+    return String(pkg?.version || "").trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+const readBundledAlphaclawVersion = ({
+  fsModule = fs,
+  packageJsonPath = path.resolve(__dirname, "..", "..", "package.json"),
+} = {}) => {
+  try {
+    const pkg = JSON.parse(fsModule.readFileSync(packageJsonPath, "utf8"));
+    return String(pkg?.version || "").trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+const installManagedAlphaclawRuntime = ({
+  execSyncImpl,
+  fsModule = fs,
+  runtimeDir,
+  spec,
+} = {}) => {
+  const normalizedSpec =
+    String(spec || "").trim() || "@chrysb/alphaclaw@latest";
+  ensureManagedAlphaclawRuntimeProject({
+    fsModule,
+    runtimeDir,
+  });
+  execSyncImpl(
+    `npm install ${shellQuote(normalizedSpec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+    {
+      cwd: runtimeDir,
+      stdio: "inherit",
+      timeout: 180000,
+    },
+  );
+  return {
+    spec: normalizedSpec,
+    version: readManagedAlphaclawRuntimeVersion({
+      fsModule,
+      runtimeDir,
+    }),
+  };
+};
+
+const syncManagedAlphaclawRuntimeWithBundled = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  packageJsonPath,
+} = {}) => {
+  const bundledVersion = readBundledAlphaclawVersion({
+    fsModule,
+    packageJsonPath,
+  });
+  if (!bundledVersion) {
+    return {
+      checked: false,
+      synced: false,
+      bundledVersion: null,
+      runtimeVersion: readManagedAlphaclawRuntimeVersion({
+        fsModule,
+        runtimeDir,
+      }),
+    };
+  }
+
+  const runtimeVersion = readManagedAlphaclawRuntimeVersion({
+    fsModule,
+    runtimeDir,
+  });
+  if (runtimeVersion && compareVersionParts(runtimeVersion, bundledVersion) >= 0) {
+    return {
+      checked: true,
+      synced: false,
+      bundledVersion,
+      runtimeVersion,
+    };
+  }
+
+  logger.log(
+    runtimeVersion
+      ? `[alphaclaw] Managed AlphaClaw runtime ${runtimeVersion} is older than bundled ${bundledVersion}; syncing runtime...`
+      : `[alphaclaw] Managed AlphaClaw runtime missing; seeding bundled AlphaClaw ${bundledVersion}...`,
+  );
+  const installResult = installManagedAlphaclawRuntime({
+    execSyncImpl,
+    fsModule,
+    runtimeDir,
+    spec: `@chrysb/alphaclaw@${bundledVersion}`,
+  });
+  return {
+    checked: true,
+    synced: true,
+    bundledVersion,
+    runtimeVersion: installResult.version || bundledVersion,
+  };
+};
+
+module.exports = {
+  ensureManagedAlphaclawRuntimeProject,
+  getManagedAlphaclawCliPath,
+  getManagedAlphaclawPackageJsonPath,
+  getManagedAlphaclawRuntimeDir,
+  installManagedAlphaclawRuntime,
+  readBundledAlphaclawVersion,
+  readManagedAlphaclawRuntimeVersion,
+  syncManagedAlphaclawRuntimeWithBundled,
+};

package/lib/server/alphaclaw-version.js

@@ -126,9 +126,15 @@ 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 child = spawn(process.argv[0], process.argv.slice(1), {
+    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)], {
       detached: true,
       stdio: "inherit",
+      env: nextEnv,
     });
     child.unref();
     process.exit(0);

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-alphaclaw-update.js

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

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.2",
   "publishConfig": {
     "access": "public"
   },