@chrysb/alphaclaw 0.8.7 → 0.8.8

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/init/register-server-routes.js

@@ -90,7 +90,13 @@ const registerServerRoutes = ({
     loginThrottle,
   });
 
-  registerPageRoutes({ app, requireAuth, isGatewayRunning });
+  registerPageRoutes({
+    app,
+    requireAuth,
+    isGatewayRunning,
+    alphaclawVersionService,
+    openclawVersionService,
+  });
   registerModelRoutes({
     app,
     shellCmd,

package/lib/server/openclaw-runtime.js

@@ -0,0 +1,428 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { kRootDir } = require("./constants");
+const {
+  compareVersionParts,
+  normalizeOpenclawVersion,
+} = require("./helpers");
+const {
+  computePackageFingerprint,
+  isPackageRootSymlink,
+  packLocalPackageForInstall,
+  resolvePackageRootFromEntryPath,
+} = require("./package-fingerprint");
+
+const getManagedOpenclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
+  path.join(rootDir, ".openclaw-runtime");
+
+const getBundledOpenclawPackageRoot = ({
+  fsModule = fs,
+  resolveImpl = require.resolve,
+} = {}) =>
+  resolvePackageRootFromEntryPath({
+    fsModule,
+    entryPath: resolveImpl("openclaw"),
+  });
+
+const getManagedOpenclawPackageRoot = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedOpenclawRuntimeDir(),
+    "node_modules",
+    "openclaw",
+  );
+
+const getManagedOpenclawBinDir = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedOpenclawRuntimeDir(),
+    "node_modules",
+    ".bin",
+  );
+
+const getManagedOpenclawBinPath = ({ runtimeDir } = {}) =>
+  path.join(getManagedOpenclawBinDir({ runtimeDir }), "openclaw");
+
+const getManagedOpenclawPackageJsonPath = ({ runtimeDir } = {}) =>
+  path.join(
+    getManagedOpenclawPackageRoot({ runtimeDir }),
+    "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 packageRoot = getBundledOpenclawPackageRoot({
+      fsModule,
+      resolveImpl,
+    });
+    if (!packageRoot) return null;
+    const pkg = JSON.parse(
+      fsModule.readFileSync(path.join(packageRoot, "package.json"), "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 kDisableBundledPluginPostinstallEnv =
+  "OPENCLAW_DISABLE_BUNDLED_PLUGIN_POSTINSTALL";
+const kBundledPluginPostinstallFailureMarker =
+  "[postinstall] could not install bundled plugin deps:";
+
+const runManagedOpenclawBundledPluginPostinstall = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+} = {}) => {
+  const packageRoot = getManagedOpenclawPackageRoot({ runtimeDir });
+  const postinstallScriptPath = path.join(
+    packageRoot,
+    "scripts",
+    "postinstall-bundled-plugins.mjs",
+  );
+  if (!fsModule.existsSync(postinstallScriptPath)) {
+    return false;
+  }
+  const env = { ...process.env };
+  delete env[kDisableBundledPluginPostinstallEnv];
+  const logDir = fsModule.mkdtempSync(
+    path.join(os.tmpdir(), "openclaw-bundled-postinstall-"),
+  );
+  const logPath = path.join(logDir, "postinstall.log");
+  let commandError = null;
+  let output = "";
+  let stdoutFd;
+  let stderrFd;
+  try {
+    stdoutFd = fsModule.openSync(logPath, "a");
+    stderrFd = fsModule.openSync(logPath, "a");
+    try {
+      execSyncImpl(
+        `${shellQuote(process.execPath)} ${shellQuote(postinstallScriptPath)}`,
+        {
+          cwd: packageRoot,
+          env,
+          stdio: ["ignore", stdoutFd, stderrFd],
+          timeout: 180000,
+        },
+      );
+    } catch (error) {
+      commandError = error;
+    }
+  } finally {
+    if (typeof stdoutFd === "number") {
+      try {
+        fsModule.closeSync(stdoutFd);
+      } catch {}
+    }
+    if (typeof stderrFd === "number") {
+      try {
+        fsModule.closeSync(stderrFd);
+      } catch {}
+    }
+    try {
+      output = String(fsModule.readFileSync(logPath, "utf8") || "").trim();
+    } catch {
+      output = "";
+    }
+    try {
+      fsModule.rmSync(logDir, { recursive: true, force: true });
+    } catch {}
+  }
+  if (output) {
+    logger.log(output);
+  }
+  if (output.includes(kBundledPluginPostinstallFailureMarker)) {
+    throw new Error(output);
+  }
+  if (commandError) {
+    throw commandError;
+  }
+  return true;
+};
+
+const installManagedOpenclawRuntime = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  spec,
+  sourcePath,
+  alphaclawRoot,
+} = {}) => {
+  const normalizedSourcePath = String(sourcePath || "").trim();
+  const normalizedSpec = normalizedSourcePath
+    ? normalizedSourcePath
+    : String(spec || "").trim() || "openclaw@latest";
+  ensureManagedOpenclawRuntimeProject({
+    fsModule,
+    runtimeDir,
+  });
+  let packedSource = null;
+  try {
+    const installTarget = normalizedSourcePath
+      ? (() => {
+          packedSource = packLocalPackageForInstall({
+            execSyncImpl,
+            fsModule,
+            packageRoot: normalizedSourcePath,
+            tempDirPrefix: "openclaw-runtime-pack-",
+          });
+          return packedSource.tarballPath;
+        })()
+      : normalizedSpec;
+    execSyncImpl(
+      `npm install ${shellQuote(installTarget)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+      {
+        cwd: runtimeDir,
+        env: {
+          ...process.env,
+          [kDisableBundledPluginPostinstallEnv]: "1",
+        },
+        stdio: "inherit",
+        timeout: 180000,
+      },
+    );
+  } finally {
+    packedSource?.cleanup?.();
+  }
+  runManagedOpenclawBundledPluginPostinstall({
+    execSyncImpl,
+    fsModule,
+    logger,
+    runtimeDir,
+  });
+  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 bundledPackageRoot = getBundledOpenclawPackageRoot({
+    fsModule,
+    resolveImpl,
+  });
+  const bundledVersion = readBundledOpenclawVersion({
+    fsModule,
+    resolveImpl,
+  });
+  if (!bundledVersion) {
+    return {
+      checked: false,
+      synced: false,
+      bundledVersion: null,
+      runtimeVersion: readManagedOpenclawRuntimeVersion({ fsModule, runtimeDir }),
+    };
+  }
+
+  const runtimeVersion = readManagedOpenclawRuntimeVersion({
+    fsModule,
+    runtimeDir,
+  });
+  const runtimePackageRoot = getManagedOpenclawPackageRoot({ runtimeDir });
+  const runtimePackageRootIsSymlink = isPackageRootSymlink({
+    fsModule,
+    packageRoot: runtimePackageRoot,
+  });
+  const bundledFingerprint = computePackageFingerprint({
+    fsModule,
+    packageRoot: bundledPackageRoot,
+  });
+  const runtimeFingerprint = computePackageFingerprint({
+    fsModule,
+    packageRoot: runtimePackageRoot,
+    packageJsonPath: getManagedOpenclawPackageJsonPath({ runtimeDir }),
+  });
+  if (runtimeVersion && compareVersionParts(runtimeVersion, bundledVersion) >= 0) {
+    if (
+      compareVersionParts(runtimeVersion, bundledVersion) > 0 ||
+      (!runtimePackageRootIsSymlink &&
+        (!bundledFingerprint || runtimeFingerprint === bundledFingerprint))
+    ) {
+      return {
+        checked: true,
+        synced: false,
+        bundledVersion,
+        runtimeVersion,
+      };
+    }
+    logger.log(
+      runtimePackageRootIsSymlink
+        ? `[alphaclaw] Managed OpenClaw runtime ${runtimeVersion} is symlinked to the bundled package; refreshing runtime...`
+        : `[alphaclaw] Managed OpenClaw runtime ${runtimeVersion} differs from bundled ${bundledVersion}; refreshing runtime...`,
+    );
+  } else {
+    logger.log(
+      runtimeVersion
+        ? `[alphaclaw] Managed OpenClaw runtime ${runtimeVersion} is older than bundled ${bundledVersion}; syncing runtime...`
+        : `[alphaclaw] Managed OpenClaw runtime missing; installing bundled OpenClaw ${bundledVersion}...`,
+    );
+  }
+
+  const installResult = installManagedOpenclawRuntime({
+    execSyncImpl,
+    fsModule,
+    logger,
+    runtimeDir,
+    sourcePath: bundledPackageRoot,
+    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,
+  getBundledOpenclawPackageRoot,
+  getManagedOpenclawBinDir,
+  getManagedOpenclawBinPath,
+  getManagedOpenclawPackageRoot,
+  getManagedOpenclawPackageJsonPath,
+  getManagedOpenclawRuntimeDir,
+  installManagedOpenclawRuntime,
+  prependManagedOpenclawBinToPath,
+  readBundledOpenclawVersion,
+  readManagedOpenclawRuntimeVersion,
+  runManagedOpenclawBundledPluginPostinstall,
+  syncManagedOpenclawRuntimeWithBundled,
+};