Queue AlphaClaw and OpenClaw installs across restarts

bin/alphaclaw.js

@@ -13,14 +13,26 @@ const { buildSecretReplacements } = require("../lib/server/helpers");
 const {
   migrateManagedInternalFiles,
 } = require("../lib/server/internal-files-migration");
-
-const kUsageTrackerPluginPath = path.resolve(
-  __dirname,
-  "..",
-  "lib",
-  "plugin",
-  "usage-tracker",
-);
+const {
+  applyPendingAlphaclawUpdate,
+} = require("../lib/server/pending-alphaclaw-update");
+const {
+  getManagedAlphaclawCliPath,
+  getManagedAlphaclawRuntimeDir,
+  syncManagedAlphaclawRuntimeWithBundled,
+} = require("../lib/server/alphaclaw-runtime");
+const {
+  applyPendingOpenclawUpdate,
+} = require("../lib/server/pending-openclaw-update");
+const {
+  getManagedOpenclawRuntimeDir,
+  prependManagedOpenclawBinToPath,
+  syncManagedOpenclawRuntimeWithBundled,
+} = require("../lib/server/openclaw-runtime");
+const {
+  ensurePluginsShell,
+  ensureUsageTrackerPluginEntry,
+} = require("../lib/server/usage-tracker-config");
 
 // ---------------------------------------------------------------------------
 // Parse CLI flags
@@ -125,6 +137,26 @@ const resolveGithubRepoPath = (value) =>
     .replace(/^git@github\.com:/, "")
     .replace(/^https:\/\/github\.com\//, "")
     .replace(/\.git$/, "");
+const isContainerRuntime = () =>
+  process.env.RAILWAY_ENVIRONMENT ||
+  process.env.RENDER ||
+  process.env.FLY_APP_NAME ||
+  fs.existsSync("/.dockerenv");
+const restartAfterPendingUpdate = () => {
+  if (isContainerRuntime()) {
+    console.log("[alphaclaw] Restarting via container crash (exit 1)...");
+    process.exit(1);
+  }
+  console.log("[alphaclaw] Spawning new process and exiting...");
+  const { spawn } = require("child_process");
+  const child = spawn(process.argv[0], process.argv.slice(1), {
+    detached: true,
+    stdio: "inherit",
+    env: process.env,
+  });
+  child.unref();
+  process.exit(0);
+};
 
 // ---------------------------------------------------------------------------
 // 1. Resolve root directory (before requiring any lib/ modules)
@@ -142,10 +174,89 @@ if (portFlag) {
   process.env.PORT = portFlag;
 }
 
+const kManagedAlphaclawRuntimeEnvFlag = "ALPHACLAW_MANAGED_RUNTIME_ACTIVE";
+const shouldBootstrapManagedAlphaclawRuntime =
+  command === "start" &&
+  process.env[kManagedAlphaclawRuntimeEnvFlag] !== "1";
+
 // ---------------------------------------------------------------------------
 // 2. Create directory structure
 // ---------------------------------------------------------------------------
 
+if (shouldBootstrapManagedAlphaclawRuntime) {
+  const { spawn } = require("child_process");
+  const managedAlphaclawRuntimeDir = getManagedAlphaclawRuntimeDir({ rootDir });
+  const pendingUpdateMarker = path.join(rootDir, ".alphaclaw-update-pending");
+  if (fs.existsSync(pendingUpdateMarker)) {
+    applyPendingAlphaclawUpdate({
+      execSyncImpl: execSync,
+      fsModule: fs,
+      installDir: managedAlphaclawRuntimeDir,
+      logger: console,
+      markerPath: pendingUpdateMarker,
+    });
+  }
+  try {
+    syncManagedAlphaclawRuntimeWithBundled({
+      execSyncImpl: execSync,
+      fsModule: fs,
+      logger: console,
+      runtimeDir: managedAlphaclawRuntimeDir,
+    });
+  } catch (error) {
+    console.log(
+      `[alphaclaw] Could not sync managed AlphaClaw runtime from bundled install: ${error.message}`,
+    );
+  }
+
+  const managedAlphaclawCliPath = getManagedAlphaclawCliPath({
+    runtimeDir: managedAlphaclawRuntimeDir,
+  });
+  if (!fs.existsSync(managedAlphaclawCliPath)) {
+    console.error(
+      `[alphaclaw] Managed AlphaClaw runtime missing CLI at ${managedAlphaclawCliPath}`,
+    );
+    process.exit(1);
+  }
+
+  const runtimeChild = spawn(
+    process.argv[0],
+    [managedAlphaclawCliPath, ...process.argv.slice(2)],
+    {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        [kManagedAlphaclawRuntimeEnvFlag]: "1",
+        ALPHACLAW_BOOTSTRAP_CLI_PATH: __filename,
+      },
+    },
+  );
+
+  const forwardSignal = (signal) => {
+    if (runtimeChild.exitCode === null && !runtimeChild.killed) {
+      runtimeChild.kill(signal);
+    }
+  };
+
+  process.on("SIGTERM", () => forwardSignal("SIGTERM"));
+  process.on("SIGINT", () => forwardSignal("SIGINT"));
+
+  runtimeChild.on("error", (error) => {
+    console.error(
+      `[alphaclaw] Managed AlphaClaw runtime launch failed: ${error.message}`,
+    );
+    process.exit(1);
+  });
+
+  runtimeChild.on("exit", (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(Number.isInteger(code) ? code : 0);
+  });
+} else {
+
 const openclawDir = path.join(rootDir, ".openclaw");
 fs.mkdirSync(openclawDir, { recursive: true });
 const { hourlyGitSyncPath } = migrateManagedInternalFiles({
@@ -155,34 +266,27 @@ const { hourlyGitSyncPath } = migrateManagedInternalFiles({
 console.log(`[alphaclaw] Root directory: ${rootDir}`);
 
 // Check for pending update marker (written by the update endpoint before restart).
-// In environments where the container filesystem is ephemeral (Railway, etc.),
-// the npm install from the update endpoint is lost on restart. This re-runs it
-// from the fresh container using the persistent volume marker.
+// We perform a real npm install during boot rather than copy-merging node_modules
+// while the old process is still running. That keeps AlphaClaw and any newly
+// pinned OpenClaw version in a coherent npm tree.
 const pendingUpdateMarker = path.join(rootDir, ".alphaclaw-update-pending");
 if (fs.existsSync(pendingUpdateMarker)) {
-  console.log(
-    "[alphaclaw] Pending update detected, installing @chrysb/alphaclaw@latest...",
-  );
   const alphaPkgRoot = path.resolve(__dirname, "..");
   const nmIndex = alphaPkgRoot.lastIndexOf(
     `${path.sep}node_modules${path.sep}`,
   );
   const installDir =
     nmIndex >= 0 ? alphaPkgRoot.slice(0, nmIndex) : alphaPkgRoot;
-  try {
-    execSync(
-      "npm install @chrysb/alphaclaw@latest --omit=dev --prefer-online",
-      {
-        cwd: installDir,
-        stdio: "inherit",
-        timeout: 180000,
-      },
-    );
-    fs.unlinkSync(pendingUpdateMarker);
-    console.log("[alphaclaw] Update applied successfully");
-  } catch (e) {
-    console.log(`[alphaclaw] Update install failed: ${e.message}`);
-    fs.unlinkSync(pendingUpdateMarker);
+  const pendingUpdate = applyPendingAlphaclawUpdate({
+    execSyncImpl: execSync,
+    fsModule: fs,
+    installDir,
+    logger: console,
+    markerPath: pendingUpdateMarker,
+  });
+  if (pendingUpdate.installed) {
+    console.log("[alphaclaw] Restarting to load updated code...");
+    restartAfterPendingUpdate();
   }
 }
 
@@ -492,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;
@@ -501,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;
@@ -534,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");
@@ -600,7 +738,7 @@ if (fs.existsSync(hourlyGitSyncPath)) {
 }
 
 // ---------------------------------------------------------------------------
-// 9. Start cron daemon if available
+// 11. Start cron daemon if available
 // ---------------------------------------------------------------------------
 
 try {
@@ -614,7 +752,7 @@ try {
 } catch {}
 
 // ---------------------------------------------------------------------------
-// 10. Reconcile channels if already onboarded
+// 12. Reconcile channels if already onboarded
 // ---------------------------------------------------------------------------
 
 const configPath = path.join(openclawDir, "openclaw.json");
@@ -762,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) {
@@ -791,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;
     }
 
@@ -898,3 +1028,4 @@ try {
 
 console.log("[alphaclaw] Setup complete -- starting server");
 require("../lib/server.js");
+}

lib/public/js/app.js

@@ -202,6 +202,7 @@ const App = () => {
         onPreviewBrowseFile=${browseActions.handleBrowsePreviewFile}
         acHasUpdate=${controllerState.acHasUpdate}
         acLatest=${controllerState.acLatest}
+        acRestarting=${controllerState.acRestarting}
         acUpdating=${controllerState.acUpdating}
         onAcUpdate=${controllerActions.handleAcUpdate}
         agents=${agentsState.agents}
@@ -384,6 +385,7 @@ const App = () => {
                         restartingGateway=${controllerState.restartingGateway}
                         onRestartGateway=${controllerActions.handleGatewayRestart}
                         restartSignal=${controllerState.gatewayRestartSignal}
+                        openclawRestarting=${controllerState.openclawRestarting}
                         openclawUpdateInProgress=${controllerState.openclawUpdateInProgress}
                         onOpenclawVersionActionComplete=${controllerActions.handleOpenclawVersionActionComplete}
                         onOpenclawUpdate=${controllerActions.handleOpenclawUpdate}
@@ -419,6 +421,7 @@ const App = () => {
                         restartingGateway=${controllerState.restartingGateway}
                         onRestartGateway=${controllerActions.handleGatewayRestart}
                         restartSignal=${controllerState.gatewayRestartSignal}
+                        openclawRestarting=${controllerState.openclawRestarting}
                         openclawUpdateInProgress=${controllerState.openclawUpdateInProgress}
                         onOpenclawVersionActionComplete=${controllerActions.handleOpenclawVersionActionComplete}
                         onOpenclawUpdate=${controllerActions.handleOpenclawUpdate}

lib/public/js/components/gateway.js

@@ -27,6 +27,7 @@ const VersionRow = ({
   fetchVersion,
   applyUpdate,
   updateInProgress = false,
+  updateLoadingLabel = "Updating...",
   onActionComplete = () => {},
 }) => {
   const [checking, setChecking] = useState(false);
@@ -236,7 +237,7 @@ const VersionRow = ({
                   ? updateIdleLabel
                   : "Check updates"}
                 loadingLabel=${isUpdateActionActive
-                  ? "Updating..."
+                  ? updateLoadingLabel
                   : "Checking..."}
                 className="hidden md:inline-flex"
               />
@@ -250,7 +251,7 @@ const VersionRow = ({
                   ? updateIdleLabel
                   : "Check updates"}
                 loadingLabel=${isUpdateActionActive
-                  ? "Updating..."
+                  ? updateLoadingLabel
                   : "Checking..."}
               />
             `}
@@ -272,7 +273,7 @@ const VersionRow = ({
           loading=${updateButtonLoading}
           warning=${isUpdateActionActive}
           idleLabel=${updateIdleLabel}
-          loadingLabel="Updating..."
+          loadingLabel=${updateLoadingLabel}
           className="flex-1 h-9 px-3"
         />
       </div>
@@ -299,6 +300,7 @@ export const Gateway = ({
   onOpenWatchdog,
   onRepair,
   repairing = false,
+  openclawRestarting = false,
   openclawUpdateInProgress = false,
   onOpenclawVersionActionComplete = () => {},
   onOpenclawUpdate = updateOpenclaw,
@@ -443,6 +445,7 @@ export const Gateway = ({
         fetchVersion=${fetchOpenclawVersion}
         applyUpdate=${onOpenclawUpdate}
         updateInProgress=${openclawUpdateInProgress}
+        updateLoadingLabel=${openclawRestarting ? "Restarting..." : "Updating..."}
         onActionComplete=${onOpenclawVersionActionComplete}
       />
     </div>