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

package/bin/alphaclaw.js

@@ -29,14 +29,10 @@ const {
   prependManagedOpenclawBinToPath,
   syncManagedOpenclawRuntimeWithBundled,
 } = require("../lib/server/openclaw-runtime");
-
-const kUsageTrackerPluginPath = path.resolve(
-  __dirname,
-  "..",
-  "lib",
-  "plugin",
-  "usage-tracker",
-);
+const {
+  ensurePluginsShell,
+  ensureUsageTrackerPluginEntry,
+} = require("../lib/server/usage-tracker-config");
 
 // ---------------------------------------------------------------------------
 // Parse CLI flags
@@ -294,36 +290,6 @@ if (fs.existsSync(pendingUpdateMarker)) {
   }
 }
 
-const pendingOpenclawUpdateMarker = path.join(rootDir, ".openclaw-update-pending");
-const managedOpenclawRuntimeDir = getManagedOpenclawRuntimeDir({ rootDir });
-if (fs.existsSync(pendingOpenclawUpdateMarker)) {
-  applyPendingOpenclawUpdate({
-    execSyncImpl: execSync,
-    fsModule: fs,
-    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
 // ---------------------------------------------------------------------------
@@ -630,7 +596,41 @@ if (!kSetupPassword) {
 }
 
 // ---------------------------------------------------------------------------
-// 7. Set OPENCLAW_HOME globally so all child processes inherit it
+// 7. Prepare managed OpenClaw runtime
+// ---------------------------------------------------------------------------
+
+const pendingOpenclawUpdateMarker = path.join(rootDir, ".openclaw-update-pending");
+const managedOpenclawRuntimeDir = getManagedOpenclawRuntimeDir({ rootDir });
+if (fs.existsSync(pendingOpenclawUpdateMarker)) {
+  applyPendingOpenclawUpdate({
+    execSyncImpl: execSync,
+    fsModule: fs,
+    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,
+});
+
+// ---------------------------------------------------------------------------
+// 8. Set OPENCLAW_HOME globally so all child processes inherit it
 // ---------------------------------------------------------------------------
 
 process.env.OPENCLAW_HOME = rootDir;
@@ -639,7 +639,7 @@ process.env.GOG_KEYRING_PASSWORD =
   process.env.GOG_KEYRING_PASSWORD || "alphaclaw";
 
 // ---------------------------------------------------------------------------
-// 8. Install gog (Google Workspace CLI) if not present
+// 9. Install gog (Google Workspace CLI) if not present
 // ---------------------------------------------------------------------------
 
 process.env.XDG_CONFIG_HOME = openclawDir;
@@ -672,7 +672,7 @@ if (!gogInstalled) {
 }
 
 // ---------------------------------------------------------------------------
-// 9. Install/reconcile system cron entry
+// 10. Install/reconcile system cron entry
 // ---------------------------------------------------------------------------
 
 const packagedHourlyGitSyncPath = path.join(setupDir, "hourly-git-sync.sh");
@@ -738,7 +738,7 @@ if (fs.existsSync(hourlyGitSyncPath)) {
 }
 
 // ---------------------------------------------------------------------------
-// 9. Start cron daemon if available
+// 11. Start cron daemon if available
 // ---------------------------------------------------------------------------
 
 try {
@@ -752,7 +752,7 @@ try {
 } catch {}
 
 // ---------------------------------------------------------------------------
-// 10. Reconcile channels if already onboarded
+// 12. Reconcile channels if already onboarded
 // ---------------------------------------------------------------------------
 
 const configPath = path.join(openclawDir, "openclaw.json");
@@ -900,10 +900,7 @@ if (fs.existsSync(configPath)) {
   try {
     const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
     if (!cfg.channels) cfg.channels = {};
-    if (!cfg.plugins) cfg.plugins = {};
-    if (!cfg.plugins.load) cfg.plugins.load = {};
-    if (!Array.isArray(cfg.plugins.load.paths)) cfg.plugins.load.paths = [];
-    if (!cfg.plugins.entries) cfg.plugins.entries = {};
+    ensurePluginsShell(cfg);
     let changed = false;
 
     if (process.env.TELEGRAM_BOT_TOKEN && !cfg.channels.telegram) {
@@ -929,12 +926,7 @@ if (fs.existsSync(configPath)) {
       console.log("[alphaclaw] Discord added");
       changed = true;
     }
-    if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
-      cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
-      changed = true;
-    }
-    if (cfg.plugins.entries["usage-tracker"]?.enabled !== true) {
-      cfg.plugins.entries["usage-tracker"] = { enabled: true };
+    if (ensureUsageTrackerPluginEntry(cfg)) {
       changed = true;
     }
 

package/lib/server/alphaclaw-runtime.js

@@ -3,26 +3,36 @@ const path = require("path");
 
 const { kRootDir } = require("./constants");
 const { compareVersionParts } = require("./helpers");
+const {
+  computePackageFingerprint,
+  isPackageRootSymlink,
+  packLocalPackageForInstall,
+  seedRuntimeFromBundledInstall,
+} = require("./package-fingerprint");
 
 const getManagedAlphaclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
   path.join(rootDir, ".alphaclaw-runtime");
 
-const getManagedAlphaclawCliPath = ({ runtimeDir } = {}) =>
+const getBundledAlphaclawPackageRoot = () => path.resolve(__dirname, "..", "..");
+
+const getManagedAlphaclawPackageRoot = ({ runtimeDir } = {}) =>
   path.join(
     runtimeDir || getManagedAlphaclawRuntimeDir(),
     "node_modules",
     "@chrysb",
     "alphaclaw",
+  );
+
+const getManagedAlphaclawCliPath = ({ runtimeDir } = {}) =>
+  path.join(
+    getManagedAlphaclawPackageRoot({ runtimeDir }),
     "bin",
     "alphaclaw.js",
   );
 
 const getManagedAlphaclawPackageJsonPath = ({ runtimeDir } = {}) =>
   path.join(
-    runtimeDir || getManagedAlphaclawRuntimeDir(),
-    "node_modules",
-    "@chrysb",
-    "alphaclaw",
+    getManagedAlphaclawPackageRoot({ runtimeDir }),
     "package.json",
   );
 
@@ -89,21 +99,40 @@ const installManagedAlphaclawRuntime = ({
   fsModule = fs,
   runtimeDir,
   spec,
+  sourcePath,
 } = {}) => {
-  const normalizedSpec =
-    String(spec || "").trim() || "@chrysb/alphaclaw@latest";
+  const normalizedSourcePath = String(sourcePath || "").trim();
+  const normalizedSpec = normalizedSourcePath
+    ? normalizedSourcePath
+    : 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,
-    },
-  );
+  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({
@@ -113,16 +142,48 @@ 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,
   logger = console,
   runtimeDir,
+  packageRoot = getBundledAlphaclawPackageRoot(),
   packageJsonPath,
 } = {}) => {
   const bundledVersion = readBundledAlphaclawVersion({
     fsModule,
-    packageJsonPath,
+    packageJsonPath: packageJsonPath || path.join(packageRoot, "package.json"),
   });
   if (!bundledVersion) {
     return {
@@ -140,25 +201,75 @@ const syncManagedAlphaclawRuntimeWithBundled = ({
     fsModule,
     runtimeDir,
   });
+  const runtimePackageRoot = getManagedAlphaclawPackageRoot({ runtimeDir });
+  const runtimePackageRootIsSymlink = isPackageRootSymlink({
+    fsModule,
+    packageRoot: runtimePackageRoot,
+  });
+  const bundledFingerprint = computePackageFingerprint({
+    fsModule,
+    packageRoot,
+    packageJsonPath: packageJsonPath || path.join(packageRoot, "package.json"),
+  });
+  const runtimeFingerprint = computePackageFingerprint({
+    fsModule,
+    packageRoot: runtimePackageRoot,
+    packageJsonPath: getManagedAlphaclawPackageJsonPath({ runtimeDir }),
+  });
   if (runtimeVersion && compareVersionParts(runtimeVersion, bundledVersion) >= 0) {
-    return {
-      checked: true,
-      synced: false,
-      bundledVersion,
-      runtimeVersion,
-    };
+    if (
+      compareVersionParts(runtimeVersion, bundledVersion) > 0 ||
+      (!runtimePackageRootIsSymlink &&
+        (!bundledFingerprint || runtimeFingerprint === bundledFingerprint))
+    ) {
+      return {
+        checked: true,
+        synced: false,
+        bundledVersion,
+        runtimeVersion,
+      };
+    }
+    logger.log(
+      runtimePackageRootIsSymlink
+        ? `[alphaclaw] Managed AlphaClaw runtime ${runtimeVersion} is symlinked to the bundled package; refreshing runtime...`
+        : `[alphaclaw] Managed AlphaClaw runtime ${runtimeVersion} differs from bundled ${bundledVersion}; refreshing runtime...`,
+    );
+  } else {
+    logger.log(
+      runtimeVersion
+        ? `[alphaclaw] Managed AlphaClaw runtime ${runtimeVersion} is older than bundled ${bundledVersion}; syncing runtime...`
+        : `[alphaclaw] Managed AlphaClaw runtime missing; seeding bundled AlphaClaw ${bundledVersion}...`,
+    );
+  }
+
+  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}`,
+      );
+    }
   }
 
-  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}`,
+    sourcePath: packageRoot,
   });
   return {
     checked: true,
@@ -170,11 +281,14 @@ const syncManagedAlphaclawRuntimeWithBundled = ({
 
 module.exports = {
   ensureManagedAlphaclawRuntimeProject,
+  getBundledAlphaclawPackageRoot,
   getManagedAlphaclawCliPath,
   getManagedAlphaclawPackageJsonPath,
+  getManagedAlphaclawPackageRoot,
   getManagedAlphaclawRuntimeDir,
   installManagedAlphaclawRuntime,
   readBundledAlphaclawVersion,
   readManagedAlphaclawRuntimeVersion,
+  seedManagedAlphaclawRuntimeFromBundledInstall,
   syncManagedAlphaclawRuntimeWithBundled,
 };

package/lib/server/openclaw-runtime.js

@@ -6,10 +6,33 @@ const {
   compareVersionParts,
   normalizeOpenclawVersion,
 } = require("./helpers");
+const {
+  computePackageFingerprint,
+  isPackageRootSymlink,
+  packLocalPackageForInstall,
+  resolvePackageRootFromEntryPath,
+  seedRuntimeFromBundledInstall,
+} = 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(),
@@ -22,9 +45,7 @@ const getManagedOpenclawBinPath = ({ runtimeDir } = {}) =>
 
 const getManagedOpenclawPackageJsonPath = ({ runtimeDir } = {}) =>
   path.join(
-    runtimeDir || getManagedOpenclawRuntimeDir(),
-    "node_modules",
-    "openclaw",
+    getManagedOpenclawPackageRoot({ runtimeDir }),
     "package.json",
   );
 
@@ -76,8 +97,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;
@@ -136,21 +163,41 @@ const installManagedOpenclawRuntime = ({
   logger = console,
   runtimeDir,
   spec,
+  sourcePath,
   alphaclawRoot,
 } = {}) => {
-  const normalizedSpec = String(spec || "").trim() || "openclaw@latest";
+  const normalizedSourcePath = String(sourcePath || "").trim();
+  const normalizedSpec = normalizedSourcePath
+    ? normalizedSourcePath
+    : 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,
-    },
-  );
+  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,
@@ -169,6 +216,48 @@ const installManagedOpenclawRuntime = ({
   };
 };
 
+const seedManagedOpenclawRuntimeFromBundledInstall = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  bundledPackageRoot,
+  alphaclawRoot,
+} = {}) => {
+  const seedResult = seedRuntimeFromBundledInstall({
+    fsModule,
+    packageRoot: bundledPackageRoot,
+    runtimeDir,
+    runtimePackageJson: {
+      name: "alphaclaw-openclaw-runtime",
+      private: true,
+    },
+  });
+  if (!seedResult.seeded) {
+    return {
+      seeded: false,
+      version: null,
+    };
+  }
+  const installedVersion = readManagedOpenclawRuntimeVersion({
+    fsModule,
+    runtimeDir,
+  });
+  applyManagedOpenclawPatch({
+    execSyncImpl,
+    fsModule,
+    logger,
+    runtimeDir,
+    version: installedVersion,
+    alphaclawRoot,
+  });
+  logger.log("[alphaclaw] Seeded managed OpenClaw runtime from bundled node_modules");
+  return {
+    seeded: true,
+    version: installedVersion,
+  };
+};
+
 const syncManagedOpenclawRuntimeWithBundled = ({
   execSyncImpl,
   fsModule = fs,
@@ -177,6 +266,10 @@ const syncManagedOpenclawRuntimeWithBundled = ({
   resolveImpl,
   alphaclawRoot,
 } = {}) => {
+  const bundledPackageRoot = getBundledOpenclawPackageRoot({
+    fsModule,
+    resolveImpl,
+  });
   const bundledVersion = readBundledOpenclawVersion({
     fsModule,
     resolveImpl,
@@ -194,26 +287,77 @@ const syncManagedOpenclawRuntimeWithBundled = ({
     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) {
-    return {
-      checked: true,
-      synced: false,
-      bundledVersion,
-      runtimeVersion,
-    };
+    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; seeding bundled OpenClaw ${bundledVersion}...`,
+    );
+  }
+
+  if (!runtimeVersion) {
+    try {
+      const seedResult = seedManagedOpenclawRuntimeFromBundledInstall({
+        execSyncImpl,
+        fsModule,
+        logger,
+        runtimeDir,
+        bundledPackageRoot,
+        alphaclawRoot,
+      });
+      if (seedResult.seeded) {
+        return {
+          checked: true,
+          synced: true,
+          bundledVersion,
+          runtimeVersion: seedResult.version || bundledVersion,
+        };
+      }
+    } catch (error) {
+      logger.log(
+        `[alphaclaw] Could not seed managed OpenClaw runtime from bundled node_modules: ${error.message}`,
+      );
+    }
   }
 
-  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}`,
+    sourcePath: bundledPackageRoot,
     alphaclawRoot,
   });
   return {
@@ -248,13 +392,16 @@ const prependManagedOpenclawBinToPath = ({
 module.exports = {
   applyManagedOpenclawPatch,
   ensureManagedOpenclawRuntimeProject,
+  getBundledOpenclawPackageRoot,
   getManagedOpenclawBinDir,
   getManagedOpenclawBinPath,
+  getManagedOpenclawPackageRoot,
   getManagedOpenclawPackageJsonPath,
   getManagedOpenclawRuntimeDir,
   installManagedOpenclawRuntime,
   prependManagedOpenclawBinToPath,
   readBundledOpenclawVersion,
   readManagedOpenclawRuntimeVersion,
+  seedManagedOpenclawRuntimeFromBundledInstall,
   syncManagedOpenclawRuntimeWithBundled,
 };

package/lib/server/package-fingerprint.js

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

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/lib/server/usage-tracker-config.js

@@ -8,6 +8,27 @@ const kUsageTrackerPluginPath = path.resolve(
   "usage-tracker",
 );
 
+const normalizePluginPath = (value = "") =>
+  String(value || "")
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/\/+$/, "");
+
+const isUsageTrackerPluginPath = (value = "") => {
+  const normalizedValue = normalizePluginPath(value);
+  const normalizedCanonicalPath = normalizePluginPath(kUsageTrackerPluginPath);
+  if (!normalizedValue) return false;
+  if (
+    normalizedValue === normalizedCanonicalPath ||
+    normalizedValue.startsWith(`${normalizedCanonicalPath}/`)
+  ) {
+    return true;
+  }
+  return /(?:^|\/)(?:node_modules\/@chrysb\/alphaclaw\/lib|lib)\/plugin\/usage-tracker(?:\/.*)?$/.test(
+    normalizedValue,
+  );
+};
+
 const ensurePluginsShell = (cfg = {}) => {
   if (!cfg.plugins || typeof cfg.plugins !== "object") cfg.plugins = {};
   if (!Array.isArray(cfg.plugins.allow)) cfg.plugins.allow = [];
@@ -32,9 +53,11 @@ const ensurePluginAllowed = ({ cfg = {}, pluginKey = "" }) => {
 const ensureUsageTrackerPluginEntry = (cfg = {}) => {
   const before = JSON.stringify(cfg);
   ensurePluginAllowed({ cfg, pluginKey: "usage-tracker" });
-  if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
-    cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
-  }
+  const nextPaths = cfg.plugins.load.paths.filter(
+    (entry) => !isUsageTrackerPluginPath(entry),
+  );
+  nextPaths.push(kUsageTrackerPluginPath);
+  cfg.plugins.load.paths = nextPaths;
   cfg.plugins.entries["usage-tracker"] = {
     ...(cfg.plugins.entries["usage-tracker"] &&
     typeof cfg.plugins.entries["usage-tracker"] === "object"
@@ -64,6 +87,7 @@ const ensureUsageTrackerPluginConfig = ({ fsModule, openclawDir }) => {
 
 module.exports = {
   kUsageTrackerPluginPath,
+  isUsageTrackerPluginPath,
   ensurePluginsShell,
   ensurePluginAllowed,
   ensureUsageTrackerPluginEntry,

package/package.json

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