@chrysb/alphaclaw 0.8.8 → 0.8.10

package/lib/server/openclaw-runtime.js

@@ -1,428 +0,0 @@
-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,
-};

package/lib/server/package-fingerprint.js

@@ -1,274 +0,0 @@
-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,
-};