Install managed runtimes from tarballs

chrysb · chrysb · commit 7d33761f90a0 · 2026-04-06T08:49:29.000-07:00
diff --git a/lib/server/alphaclaw-runtime.js b/lib/server/alphaclaw-runtime.js
@@ -3,7 +3,10 @@ const path = require("path");
 
 const { kRootDir } = require("./constants");
 const { compareVersionParts } = require("./helpers");
-const { computePackageFingerprint } = require("./package-fingerprint");
+const {
+  computePackageFingerprint,
+  packLocalPackageForInstall,
+} = require("./package-fingerprint");
 
 const getManagedAlphaclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
   path.join(rootDir, ".alphaclaw-runtime");
@@ -104,14 +107,30 @@ const installManagedAlphaclawRuntime = ({
     fsModule,
     runtimeDir,
   });
-  execSyncImpl(
-    `npm install ${shellQuote(normalizedSpec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
-    {
-      cwd: runtimeDir,
-      stdio: "inherit",
-      timeout: 180000,
-    },
-  );
+  let packedSource = null;
+  try {
+    const installTarget = normalizedSourcePath
+      ? (() => {
+          packedSource = packLocalPackageForInstall({
+            execSyncImpl,
+            fsModule,
+            packageRoot: normalizedSourcePath,
+            tempDirPrefix: "alphaclaw-runtime-pack-",
+          });
+          return packedSource.tarballPath;
+        })()
+      : normalizedSpec;
+    execSyncImpl(
+      `npm install ${shellQuote(installTarget)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+      {
+        cwd: runtimeDir,
+        stdio: "inherit",
+        timeout: 180000,
+      },
+    );
+  } finally {
+    packedSource?.cleanup?.();
+  }
   return {
     spec: normalizedSpec,
     version: readManagedAlphaclawRuntimeVersion({
diff --git a/lib/server/openclaw-runtime.js b/lib/server/openclaw-runtime.js
@@ -6,14 +6,23 @@ const {
   compareVersionParts,
   normalizeOpenclawVersion,
 } = require("./helpers");
-const { computePackageFingerprint } = require("./package-fingerprint");
+const {
+  computePackageFingerprint,
+  packLocalPackageForInstall,
+  resolvePackageRootFromEntryPath,
+} = require("./package-fingerprint");
 
 const getManagedOpenclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
   path.join(rootDir, ".openclaw-runtime");
 
 const getBundledOpenclawPackageRoot = ({
+  fsModule = fs,
   resolveImpl = require.resolve,
-} = {}) => path.dirname(resolveImpl("openclaw/package.json"));
+} = {}) =>
+  resolvePackageRootFromEntryPath({
+    fsModule,
+    entryPath: resolveImpl("openclaw"),
+  });
 
 const getManagedOpenclawPackageRoot = ({ runtimeDir } = {}) =>
   path.join(
@@ -86,8 +95,14 @@ const readBundledOpenclawVersion = ({
   resolveImpl = require.resolve,
 } = {}) => {
   try {
-    const pkgPath = resolveImpl("openclaw/package.json");
-    const pkg = JSON.parse(fsModule.readFileSync(pkgPath, "utf8"));
+    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;
@@ -157,14 +172,30 @@ const installManagedOpenclawRuntime = ({
     fsModule,
     runtimeDir,
   });
-  execSyncImpl(
-    `npm install ${shellQuote(normalizedSpec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
-    {
-      cwd: runtimeDir,
-      stdio: "inherit",
-      timeout: 180000,
-    },
-  );
+  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,
+        stdio: "inherit",
+        timeout: 180000,
+      },
+    );
+  } finally {
+    packedSource?.cleanup?.();
+  }
   const installedVersion = readManagedOpenclawRuntimeVersion({
     fsModule,
     runtimeDir,
@@ -191,7 +222,10 @@ const syncManagedOpenclawRuntimeWithBundled = ({
   resolveImpl,
   alphaclawRoot,
 } = {}) => {
-  const bundledPackageRoot = getBundledOpenclawPackageRoot({ resolveImpl });
+  const bundledPackageRoot = getBundledOpenclawPackageRoot({
+    fsModule,
+    resolveImpl,
+  });
   const bundledVersion = readBundledOpenclawVersion({
     fsModule,
     resolveImpl,
diff --git a/lib/server/package-fingerprint.js b/lib/server/package-fingerprint.js
@@ -1,5 +1,6 @@
 const crypto = require("crypto");
 const fs = require("fs");
+const os = require("os");
 const path = require("path");
 
 const kIgnoredDirectoryNames = new Set([".git", "node_modules"]);
@@ -114,6 +115,74 @@ const computePackageFingerprint = ({
   return hash.digest("hex");
 };
 
+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 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,
+  packLocalPackageForInstall,
+  resolvePackageRootFromEntryPath,
 };
diff --git a/tests/server/alphaclaw-runtime.test.js b/tests/server/alphaclaw-runtime.test.js
@@ -46,6 +46,11 @@ const writeAlphaclawPackage = ({
   );
 };
 
+const parsePackDestination = (command) => {
+  const match = String(command || "").match(/--pack-destination '([^']+)'/);
+  return match ? match[1] : "";
+};
+
 describe("server/alphaclaw-runtime", () => {
   let tmpDir;
 
@@ -156,6 +161,13 @@ describe("server/alphaclaw-runtime", () => {
       version: "0.8.9",
     });
     const execSyncImpl = vi.fn((command, options) => {
+      if (String(command).startsWith("npm pack ")) {
+        const packDestination = parsePackDestination(command);
+        const tarballPath = path.join(packDestination, "alphaclaw-runtime.tgz");
+        fs.mkdirSync(packDestination, { recursive: true });
+        fs.writeFileSync(tarballPath, "tarball");
+        return "alphaclaw-runtime.tgz\n";
+      }
       writeAlphaclawPackage({
         packageRoot: getManagedAlphaclawPackageRoot({ runtimeDir: options.cwd }),
         version: "0.8.9",
@@ -177,8 +189,9 @@ describe("server/alphaclaw-runtime", () => {
       bundledVersion: "0.8.9",
       runtimeVersion: "0.8.9",
     });
+    expect(execSyncImpl.mock.calls[0][0]).toContain(`npm pack '${bundleDir}'`);
     expect(execSyncImpl).toHaveBeenCalledWith(
-      `npm install '${bundleDir}' --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+      expect.stringMatching(/npm install '.*alphaclaw-runtime\.tgz' --omit=dev --no-save --save=false --package-lock=false --prefer-online/),
       {
         cwd: runtimeDir,
         stdio: "inherit",
@@ -202,6 +215,13 @@ describe("server/alphaclaw-runtime", () => {
       usageTrackerBody: "module.exports = 'old';\n",
     });
     const execSyncImpl = vi.fn((command, options) => {
+      if (String(command).startsWith("npm pack ")) {
+        const packDestination = parsePackDestination(command);
+        const tarballPath = path.join(packDestination, "alphaclaw-runtime.tgz");
+        fs.mkdirSync(packDestination, { recursive: true });
+        fs.writeFileSync(tarballPath, "tarball");
+        return "alphaclaw-runtime.tgz\n";
+      }
       writeAlphaclawPackage({
         packageRoot: getManagedAlphaclawPackageRoot({ runtimeDir: options.cwd }),
         version: "0.8.9",
@@ -224,8 +244,9 @@ describe("server/alphaclaw-runtime", () => {
       bundledVersion: "0.8.9",
       runtimeVersion: "0.8.9",
     });
+    expect(execSyncImpl.mock.calls[0][0]).toContain(`npm pack '${bundleDir}'`);
     expect(execSyncImpl).toHaveBeenCalledWith(
-      `npm install '${bundleDir}' --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
+      expect.stringMatching(/npm install '.*alphaclaw-runtime\.tgz' --omit=dev --no-save --save=false --package-lock=false --prefer-online/),
       {
         cwd: runtimeDir,
         stdio: "inherit",
diff --git a/tests/server/openclaw-runtime.test.js b/tests/server/openclaw-runtime.test.js
