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

package/bin/alphaclaw.js

@@ -16,6 +16,11 @@ const {
 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");
@@ -173,10 +178,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({
@@ -952,3 +1036,4 @@ try {
 
 console.log("[alphaclaw] Setup complete -- starting server");
 require("../lib/server.js");
+}

package/lib/server/alphaclaw-runtime.js

@@ -0,0 +1,180 @@
+const fs = require("fs");
+const path = require("path");
+
+const { kRootDir } = require("./constants");
+const { compareVersionParts } = require("./helpers");
+
+const getManagedAlphaclawRuntimeDir = ({ rootDir = kRootDir } = {}) =>
+  path.join(rootDir, ".alphaclaw-runtime");
+
+const getManagedAlphaclawCliPath = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedAlphaclawRuntimeDir(),
+    "node_modules",
+    "@chrysb",
+    "alphaclaw",
+    "bin",
+    "alphaclaw.js",
+  );
+
+const getManagedAlphaclawPackageJsonPath = ({ runtimeDir } = {}) =>
+  path.join(
+    runtimeDir || getManagedAlphaclawRuntimeDir(),
+    "node_modules",
+    "@chrysb",
+    "alphaclaw",
+    "package.json",
+  );
+
+const ensureManagedAlphaclawRuntimeProject = ({
+  fsModule = fs,
+  runtimeDir,
+} = {}) => {
+  const resolvedRuntimeDir = runtimeDir || getManagedAlphaclawRuntimeDir();
+  const packageJsonPath = path.join(resolvedRuntimeDir, "package.json");
+  fsModule.mkdirSync(resolvedRuntimeDir, { recursive: true });
+  if (!fsModule.existsSync(packageJsonPath)) {
+    fsModule.writeFileSync(
+      packageJsonPath,
+      JSON.stringify(
+        {
+          name: "alphaclaw-runtime",
+          private: true,
+        },
+        null,
+        2,
+      ),
+    );
+  }
+  return {
+    runtimeDir: resolvedRuntimeDir,
+    packageJsonPath,
+  };
+};
+
+const readManagedAlphaclawRuntimeVersion = ({
+  fsModule = fs,
+  runtimeDir,
+} = {}) => {
+  try {
+    const pkg = JSON.parse(
+      fsModule.readFileSync(
+        getManagedAlphaclawPackageJsonPath({ runtimeDir }),
+        "utf8",
+      ),
+    );
+    return String(pkg?.version || "").trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+const readBundledAlphaclawVersion = ({
+  fsModule = fs,
+  packageJsonPath = path.resolve(__dirname, "..", "..", "package.json"),
+} = {}) => {
+  try {
+    const pkg = JSON.parse(fsModule.readFileSync(packageJsonPath, "utf8"));
+    return String(pkg?.version || "").trim() || null;
+  } catch {
+    return null;
+  }
+};
+
+const shellQuote = (value) =>
+  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
+
+const installManagedAlphaclawRuntime = ({
+  execSyncImpl,
+  fsModule = fs,
+  runtimeDir,
+  spec,
+} = {}) => {
+  const normalizedSpec =
+    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,
+    },
+  );
+  return {
+    spec: normalizedSpec,
+    version: readManagedAlphaclawRuntimeVersion({
+      fsModule,
+      runtimeDir,
+    }),
+  };
+};
+
+const syncManagedAlphaclawRuntimeWithBundled = ({
+  execSyncImpl,
+  fsModule = fs,
+  logger = console,
+  runtimeDir,
+  packageJsonPath,
+} = {}) => {
+  const bundledVersion = readBundledAlphaclawVersion({
+    fsModule,
+    packageJsonPath,
+  });
+  if (!bundledVersion) {
+    return {
+      checked: false,
+      synced: false,
+      bundledVersion: null,
+      runtimeVersion: readManagedAlphaclawRuntimeVersion({
+        fsModule,
+        runtimeDir,
+      }),
+    };
+  }
+
+  const runtimeVersion = readManagedAlphaclawRuntimeVersion({
+    fsModule,
+    runtimeDir,
+  });
+  if (runtimeVersion && compareVersionParts(runtimeVersion, bundledVersion) >= 0) {
+    return {
+      checked: true,
+      synced: false,
+      bundledVersion,
+      runtimeVersion,
+    };
+  }
+
+  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}`,
+  });
+  return {
+    checked: true,
+    synced: true,
+    bundledVersion,
+    runtimeVersion: installResult.version || bundledVersion,
+  };
+};
+
+module.exports = {
+  ensureManagedAlphaclawRuntimeProject,
+  getManagedAlphaclawCliPath,
+  getManagedAlphaclawPackageJsonPath,
+  getManagedAlphaclawRuntimeDir,
+  installManagedAlphaclawRuntime,
+  readBundledAlphaclawVersion,
+  readManagedAlphaclawRuntimeVersion,
+  syncManagedAlphaclawRuntimeWithBundled,
+};

package/lib/server/alphaclaw-version.js

@@ -126,9 +126,15 @@ const createAlphaclawVersionService = () => {
     // On bare metal / Mac / Linux, spawn a replacement process then exit.
     console.log("[alphaclaw] Spawning new process and exiting...");
     const { spawn } = require("child_process");
-    const child = spawn(process.argv[0], process.argv.slice(1), {
+    const nextEnv = { ...process.env };
+    delete nextEnv.ALPHACLAW_MANAGED_RUNTIME_ACTIVE;
+    const bootstrapCliPath =
+      String(process.env.ALPHACLAW_BOOTSTRAP_CLI_PATH || "").trim() ||
+      process.argv[1];
+    const child = spawn(process.argv[0], [bootstrapCliPath, ...process.argv.slice(2)], {
       detached: true,
       stdio: "inherit",
+      env: nextEnv,
     });
     child.unref();
     process.exit(0);

package/lib/server/pending-alphaclaw-update.js

@@ -1,3 +1,7 @@
+const {
+  installManagedAlphaclawRuntime,
+} = require("./alphaclaw-runtime");
+
 const buildPendingAlphaclawInstallSpec = (marker = {}) => {
   const explicitSpec = String(marker?.spec || "").trim();
   if (explicitSpec) {
@@ -7,9 +11,6 @@ const buildPendingAlphaclawInstallSpec = (marker = {}) => {
   return `@chrysb/alphaclaw@${targetVersion}`;
 };
 
-const shellQuote = (value) =>
-  `'${String(value || "").replace(/'/g, `'\"'\"'`)}'`;
-
 const applyPendingAlphaclawUpdate = ({
   execSyncImpl,
   fsModule,
@@ -36,14 +37,12 @@ const applyPendingAlphaclawUpdate = ({
   logger.log(`[alphaclaw] Pending update detected, installing ${spec}...`);
 
   try {
-    execSyncImpl(
-      `npm install ${shellQuote(spec)} --omit=dev --no-save --save=false --package-lock=false --prefer-online`,
-      {
-        cwd: installDir,
-        stdio: "inherit",
-        timeout: 180000,
-      },
-    );
+    installManagedAlphaclawRuntime({
+      execSyncImpl,
+      fsModule,
+      runtimeDir: installDir,
+      spec,
+    });
     fsModule.unlinkSync(markerPath);
     logger.log("[alphaclaw] Update applied successfully");
     return {

package/package.json

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