@chrysb/alphaclaw 0.8.7-beta.3 → 0.8.7-beta.5

package/lib/server/alphaclaw-runtime.js

@@ -7,6 +7,7 @@ const {
   computePackageFingerprint,
   isPackageRootSymlink,
   packLocalPackageForInstall,
+  seedRuntimeFromBundledInstall,
 } = require("./package-fingerprint");
 
 const getManagedAlphaclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
@@ -141,6 +142,37 @@ const installManagedAlphaclawRuntime = ({
   };
 };
 
+const seedManagedAlphaclawRuntimeFromBundledInstall = ({
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  packageRoot,
+} = {}) => {
+  const seedResult = seedRuntimeFromBundledInstall({
+    fsModule,
+    packageRoot,
+    runtimeDir,
+    runtimePackageJson: {
+      name: "alphaclaw-runtime",
+      private: true,
+    },
+  });
+  if (!seedResult.seeded) {
+    return {
+      seeded: false,
+      version: null,
+    };
+  }
+  logger.log("[alphaclaw] Seeded managed AlphaClaw runtime from bundled node_modules");
+  return {
+    seeded: true,
+    version: readManagedAlphaclawRuntimeVersion({
+      fsModule,
+      runtimeDir,
+    }),
+  };
+};
+
 const syncManagedAlphaclawRuntimeWithBundled = ({
   execSyncImpl,
   fsModule = fs,
@@ -210,6 +242,29 @@ const syncManagedAlphaclawRuntimeWithBundled = ({
     );
   }
 
+  if (!runtimeVersion) {
+    try {
+      const seedResult = seedManagedAlphaclawRuntimeFromBundledInstall({
+        fsModule,
+        logger,
+        runtimeDir,
+        packageRoot,
+      });
+      if (seedResult.seeded) {
+        return {
+          checked: true,
+          synced: true,
+          bundledVersion,
+          runtimeVersion: seedResult.version || bundledVersion,
+        };
+      }
+    } catch (error) {
+      logger.log(
+        `[alphaclaw] Could not seed managed AlphaClaw runtime from bundled node_modules: ${error.message}`,
+      );
+    }
+  }
+
   const installResult = installManagedAlphaclawRuntime({
     execSyncImpl,
     fsModule,
@@ -234,5 +289,6 @@ module.exports = {
   installManagedAlphaclawRuntime,
   readBundledAlphaclawVersion,
   readManagedAlphaclawRuntimeVersion,
+  seedManagedAlphaclawRuntimeFromBundledInstall,
   syncManagedAlphaclawRuntimeWithBundled,
 };

package/lib/server/gateway.js

@@ -2,6 +2,7 @@ const path = require("path");
 const { spawn, execSync } = require("child_process");
 const fs = require("fs");
 const net = require("net");
+const { getManagedOpenclawBinPath } = require("./openclaw-runtime");
 const {
   ALPHACLAW_DIR,
   OPENCLAW_DIR,
@@ -48,6 +49,16 @@ const gatewayEnv = () => ({
   XDG_CONFIG_HOME: OPENCLAW_DIR,
 });
 
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+const getOpenclawCommandPath = () => {
+  const managedBinPath = getManagedOpenclawBinPath();
+  return fs.existsSync(managedBinPath) ? managedBinPath : "openclaw";
+};
+
+const getOpenclawCommandPrefix = () => shellQuote(getOpenclawCommandPath());
+
 const writeOnboardingMarker = (reason) => {
   fs.mkdirSync(ALPHACLAW_DIR, { recursive: true });
   fs.writeFileSync(
@@ -119,9 +130,10 @@ const isGatewayRunning = () =>
   });
 
 const runGatewayCmd = (cmd) => {
-  console.log(`[alphaclaw] Running: openclaw gateway ${cmd}`);
+  const openclawCommandPrefix = getOpenclawCommandPrefix();
+  console.log(`[alphaclaw] Running: ${openclawCommandPrefix} gateway ${cmd}`);
   try {
-    const out = execSync(`openclaw gateway ${cmd}`, {
+    const out = execSync(`${openclawCommandPrefix} gateway ${cmd}`, {
       env: gatewayEnv(),
       timeout: 15000,
       encoding: "utf8",
@@ -146,7 +158,7 @@ const launchGatewayProcess = () => {
     return gatewayChild;
   }
   gatewayStderrTail = [];
-  const child = spawn("openclaw", ["gateway", "run"], {
+  const child = spawn(getOpenclawCommandPath(), ["gateway", "run"], {
     env: gatewayEnv(),
     stdio: ["pipe", "pipe", "pipe"],
   });
@@ -306,7 +318,7 @@ const syncChannelConfig = (savedVars, mode = "all") => {
             const appToken = savedMap[def.extraEnvKeys?.[0]];
             if (!appToken) continue;
             execSync(
-              `openclaw channels add --channel slack --bot-token "${token}" --app-token "${appToken}"`,
+              `${getOpenclawCommandPrefix()} channels add --channel slack --bot-token "${token}" --app-token "${appToken}"`,
               { env, timeout: 15000, encoding: "utf8" },
             );
             let raw = fs.readFileSync(configPath, "utf8");
@@ -318,11 +330,14 @@ const syncChannelConfig = (savedVars, mode = "all") => {
             }
             fs.writeFileSync(configPath, raw);
           } else {
-            execSync(`openclaw channels add --channel ${ch} --token "${token}"`, {
-              env,
-              timeout: 15000,
-              encoding: "utf8",
-            });
+            execSync(
+              `${getOpenclawCommandPrefix()} channels add --channel ${ch} --token "${token}"`,
+              {
+                env,
+                timeout: 15000,
+                encoding: "utf8",
+              },
+            );
             const raw = fs.readFileSync(configPath, "utf8");
             if (raw.includes(token)) {
               fs.writeFileSync(
@@ -344,11 +359,14 @@ const syncChannelConfig = (savedVars, mode = "all") => {
       ) {
         console.log(`[alphaclaw] Removing channel: ${ch}`);
         try {
-          execSync(`openclaw channels remove --channel ${ch} --delete`, {
-            env,
-            timeout: 15000,
-            encoding: "utf8",
-          });
+          execSync(
+            `${getOpenclawCommandPrefix()} channels remove --channel ${ch} --delete`,
+            {
+              env,
+              timeout: 15000,
+              encoding: "utf8",
+            },
+          );
           console.log(`[alphaclaw] Channel ${ch} removed`);
         } catch (e) {
           console.error(

package/lib/server/openclaw-runtime.js

@@ -280,7 +280,7 @@ const syncManagedOpenclawRuntimeWithBundled = ({
     logger.log(
       runtimeVersion
         ? `[alphaclaw] Managed OpenClaw runtime ${runtimeVersion} is older than bundled ${bundledVersion}; syncing runtime...`
-        : `[alphaclaw] Managed OpenClaw runtime missing; seeding bundled OpenClaw ${bundledVersion}...`,
+        : `[alphaclaw] Managed OpenClaw runtime missing; installing bundled OpenClaw ${bundledVersion}...`,
     );
   }
 

package/lib/server/package-fingerprint.js

@@ -142,6 +142,76 @@ const resolvePackageRootFromEntryPath = ({
   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,
@@ -198,5 +268,7 @@ module.exports = {
   computePackageFingerprint,
   isPackageRootSymlink,
   packLocalPackageForInstall,
+  resolveInstallRootFromPackageRoot,
   resolvePackageRootFromEntryPath,
+  seedRuntimeFromBundledInstall,
 };

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

@@ -1,3 +1,5 @@
+const path = require("path");
+
 const {
   installManagedAlphaclawRuntime,
 } = require("./alphaclaw-runtime");
@@ -36,13 +38,23 @@ const applyPendingAlphaclawUpdate = ({
   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: installDir,
+      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 {
@@ -52,6 +64,9 @@ const applyPendingAlphaclawUpdate = ({
     };
   } catch (error) {
     logger.log(`[alphaclaw] Update install failed: ${error.message}`);
+    try {
+      fsModule.rmSync(tempInstallDir, { recursive: true, force: true });
+    } catch {}
     try {
       fsModule.unlinkSync(markerPath);
     } catch {}

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

@@ -1,3 +1,5 @@
+const path = require("path");
+
 const {
   installManagedOpenclawRuntime,
 } = require("./openclaw-runtime");
@@ -36,14 +38,24 @@ const applyPendingOpenclawUpdate = ({
   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: installDir,
+      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 {
@@ -53,6 +65,9 @@ const applyPendingOpenclawUpdate = ({
     };
   } 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 {}

package/package.json

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