@chrysb/alphaclaw 0.8.7 → 0.8.8

package/lib/release/managed-release.js

@@ -0,0 +1,180 @@
+const fs = require("fs");
+const path = require("path");
+
+const kTemplateDefinitions = {
+  railway: {
+    id: "railway",
+    packageName: "openclaw-railway",
+    description:
+      "OpenClaw on Railway — one-click deploy, powered by @chrysb/alphaclaw",
+    includeCompose: false,
+  },
+  render: {
+    id: "render",
+    packageName: "openclaw-render",
+    description:
+      "OpenClaw on Render — one-click deploy, powered by @chrysb/alphaclaw",
+    includeCompose: false,
+  },
+  apex: {
+    id: "apex",
+    packageName: "openclaw-apex",
+    description:
+      "OpenClaw on Apex — managed template, powered by @chrysb/alphaclaw",
+    includeCompose: true,
+  },
+};
+
+const readJsonFile = (filePath) => JSON.parse(fs.readFileSync(filePath, "utf8"));
+
+const normalizeValue = (value) => String(value || "").trim();
+
+const createReleaseId = ({ alphaclawVersion, openclawVersion }) =>
+  `alphaclaw-${normalizeValue(alphaclawVersion)}_openclaw-${normalizeValue(openclawVersion)}`;
+
+const readCurrentReleaseMetadata = ({ repoRoot }) => {
+  const packageJson = readJsonFile(path.join(repoRoot, "package.json"));
+  const alphaclawVersion = normalizeValue(packageJson.version);
+  const openclawVersion = normalizeValue(packageJson.dependencies?.openclaw);
+  if (!alphaclawVersion) {
+    throw new Error("AlphaClaw package.json is missing version.");
+  }
+  if (!openclawVersion) {
+    throw new Error("AlphaClaw package.json is missing dependencies.openclaw.");
+  }
+  return {
+    alphaclawVersion,
+    openclawVersion,
+    releaseId: createReleaseId({
+      alphaclawVersion,
+      openclawVersion,
+    }),
+  };
+};
+
+const resolveReleaseMetadata = ({
+  repoRoot,
+  alphaclawVersion,
+  openclawVersion,
+}) => {
+  const normalizedAlphaClawVersion = normalizeValue(alphaclawVersion);
+  const normalizedOpenClawVersion = normalizeValue(openclawVersion);
+  if (!normalizedAlphaClawVersion && !normalizedOpenClawVersion) {
+    return readCurrentReleaseMetadata({ repoRoot });
+  }
+  if (!normalizedAlphaClawVersion || !normalizedOpenClawVersion) {
+    throw new Error("alphaclawVersion and openclawVersion overrides must be provided together.");
+  }
+  return {
+    alphaclawVersion: normalizedAlphaClawVersion,
+    openclawVersion: normalizedOpenClawVersion,
+    releaseId: createReleaseId({
+      alphaclawVersion: normalizedAlphaClawVersion,
+      openclawVersion: normalizedOpenClawVersion,
+    }),
+  };
+};
+
+const getTemplateDefinition = (templateId = "") => {
+  const normalizedTemplateId = normalizeValue(templateId).toLowerCase();
+  const definition = kTemplateDefinitions[normalizedTemplateId];
+  if (!definition) {
+    throw new Error(`Unsupported templateId: ${templateId}`);
+  }
+  return definition;
+};
+
+const buildManagedBundlePackageJson = ({
+  templateId = "apex",
+  alphaclawVersion,
+  openclawVersion,
+  alphaclawPackageSpec = "",
+}) => {
+  const definition = getTemplateDefinition(templateId);
+  return {
+    name: definition.packageName,
+    version: "2.0.0",
+    private: true,
+    description: definition.description,
+    scripts: {
+      dev: "docker compose up --build",
+      "dev:stop": "docker compose down",
+      "dev:clean": "docker compose down -v",
+      "dev:logs": "docker compose logs -f",
+      "dev:shell": "docker compose exec openclaw bash",
+    },
+    dependencies: {
+      "@chrysb/alphaclaw":
+        normalizeValue(alphaclawPackageSpec) || normalizeValue(alphaclawVersion),
+      openclaw: normalizeValue(openclawVersion),
+    },
+    engines: {
+      node: ">=22.12.0",
+    },
+  };
+};
+
+const buildManagedBundleDockerfile = ({
+  includeVendorDir = false,
+} = {}) => `FROM node:22-slim
+
+WORKDIR /app
+
+${includeVendorDir ? "COPY vendor/ ./vendor/\n" : ""}COPY package.json package-lock.json ./
+RUN npm ci --omit=dev --no-audit --no-fund && npm cache clean --force
+
+ENV PATH="/app/node_modules/.bin:$PATH"
+ENV ALPHACLAW_ROOT_DIR=/data
+
+RUN mkdir -p /data
+
+EXPOSE 3000
+
+CMD ["alphaclaw", "start"]
+`;
+
+const buildManagedBundleCompose = () => `services:
+  openclaw:
+    build: .
+    restart: unless-stopped
+    env_file:
+      - /opt/alphaclaw/shared/.env
+    volumes:
+      - openclaw-data:/data
+      - /opt/alphaclaw/shared/.env:/data/.env
+  caddy:
+    image: caddy:2
+    restart: unless-stopped
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    volumes:
+      - caddy_data:/data
+      - caddy_config:/config
+      - /opt/alphaclaw/shared/Caddyfile:/etc/caddy/Caddyfile:ro
+    ports:
+      - "\${ALPHACLAW_HTTP_PORT:-80}:80"
+      - "\${ALPHACLAW_HTTPS_PORT:-443}:443"
+volumes:
+  openclaw-data:
+  caddy_data:
+  caddy_config:
+`;
+
+const buildTemplateDependencies = ({
+  alphaclawVersion,
+  openclawVersion,
+}) => ({
+  "@chrysb/alphaclaw": normalizeValue(alphaclawVersion),
+  openclaw: normalizeValue(openclawVersion),
+});
+
+module.exports = {
+  buildManagedBundleCompose,
+  buildManagedBundleDockerfile,
+  buildManagedBundlePackageJson,
+  buildTemplateDependencies,
+  createReleaseId,
+  getTemplateDefinition,
+  readCurrentReleaseMetadata,
+  resolveReleaseMetadata,
+};

package/lib/server/alphaclaw-runtime.js

@@ -0,0 +1,294 @@
+const fs = require("fs");
+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 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(
+    getManagedAlphaclawPackageRoot({ runtimeDir }),
+    "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,
+  sourcePath,
+} = {}) => {
+  const normalizedSourcePath = String(sourcePath || "").trim();
+  const normalizedSpec = normalizedSourcePath
+    ? normalizedSourcePath
+    : String(spec || "").trim() || "@chrysb/alphaclaw@latest";
+  ensureManagedAlphaclawRuntimeProject({
+    fsModule,
+    runtimeDir,
+  });
+  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({
+      fsModule,
+      runtimeDir,
+    }),
+  };
+};
+
+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 || path.join(packageRoot, "package.json"),
+  });
+  if (!bundledVersion) {
+    return {
+      checked: false,
+      synced: false,
+      bundledVersion: null,
+      runtimeVersion: readManagedAlphaclawRuntimeVersion({
+        fsModule,
+        runtimeDir,
+      }),
+    };
+  }
+
+  const runtimeVersion = readManagedAlphaclawRuntimeVersion({
+    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) {
+    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}`,
+      );
+    }
+  }
+
+  const installResult = installManagedAlphaclawRuntime({
+    execSyncImpl,
+    fsModule,
+    runtimeDir,
+    sourcePath: packageRoot,
+  });
+  return {
+    checked: true,
+    synced: true,
+    bundledVersion,
+    runtimeVersion: installResult.version || bundledVersion,
+  };
+};
+
+module.exports = {
+  ensureManagedAlphaclawRuntimeProject,
+  getBundledAlphaclawPackageRoot,
+  getManagedAlphaclawCliPath,
+  getManagedAlphaclawPackageJsonPath,
+  getManagedAlphaclawPackageRoot,
+  getManagedAlphaclawRuntimeDir,
+  installManagedAlphaclawRuntime,
+  readBundledAlphaclawVersion,
+  readManagedAlphaclawRuntimeVersion,
+  seedManagedAlphaclawRuntimeFromBundledInstall,
+  syncManagedAlphaclawRuntimeWithBundled,
+};

package/lib/server/alphaclaw-version.js

@@ -1,6 +1,4 @@
-const childProcess = require("child_process");
 const fs = require("fs");
-const os = require("os");
 const path = require("path");
 const https = require("https");
 const http = require("http");
@@ -8,7 +6,6 @@ const {
   kLatestVersionCacheTtlMs,
   kAlphaclawRegistryUrl,
   kNpmPackageRoot,
-  kOpenclawUpdateCopyTimeoutMs,
   kRootDir,
 } = require("./constants");
 
@@ -26,6 +23,9 @@ const isNewerVersion = (latest, current) => {
   return l.patch > c.patch;
 };
 
+const buildAlphaclawInstallSpec = (version = "latest") =>
+  `@chrysb/alphaclaw@${String(version || "").trim() || "latest"}`;
+
 const createAlphaclawVersionService = () => {
   let kUpdateStatusCache = {
     latestVersion: null,
@@ -108,120 +108,6 @@ const createAlphaclawVersionService = () => {
     return { latestVersion, hasUpdate };
   };
 
-  const findInstallDir = () => {
-    // Walk up from kNpmPackageRoot to find the consuming project's directory
-    // (the one with node_modules/@chrysb/alphaclaw). In Docker this is /app.
-    let dir = kNpmPackageRoot;
-    while (dir !== path.dirname(dir)) {
-      const parent = path.dirname(dir);
-      if (
-        path.basename(parent) === "node_modules" ||
-        parent.includes(`${path.sep}node_modules${path.sep}`)
-      ) {
-        dir = parent;
-        continue;
-      }
-      const pkgPath = path.join(parent, "package.json");
-      if (fs.existsSync(pkgPath)) {
-        try {
-          const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-          if (
-            pkg.dependencies?.["@chrysb/alphaclaw"] ||
-            pkg.devDependencies?.["@chrysb/alphaclaw"] ||
-            pkg.optionalDependencies?.["@chrysb/alphaclaw"]
-          ) {
-            return parent;
-          }
-        } catch {}
-      }
-      dir = parent;
-    }
-    // Fallback: if running directly (not from node_modules), use kNpmPackageRoot
-    return kNpmPackageRoot;
-  };
-
-  const installLatestAlphaclaw = () =>
-    new Promise((resolve, reject) => {
-      const installDir = findInstallDir();
-      const tmpDir = fs.mkdtempSync(
-        path.join(os.tmpdir(), "alphaclaw-update-"),
-      );
-
-      const cleanup = () => {
-        try {
-          fs.rmSync(tmpDir, { recursive: true, force: true });
-        } catch {}
-      };
-
-      fs.writeFileSync(
-        path.join(tmpDir, "package.json"),
-        JSON.stringify({
-          private: true,
-          dependencies: { "@chrysb/alphaclaw": "latest" },
-        }),
-      );
-
-      const npmEnv = {
-        ...process.env,
-        npm_config_update_notifier: "false",
-        npm_config_fund: "false",
-        npm_config_audit: "false",
-      };
-
-      console.log(
-        `[alphaclaw] Running: npm install @chrysb/alphaclaw@latest in temp dir (target: ${installDir})`,
-      );
-      childProcess.exec(
-        "npm install --omit=dev --prefer-online --package-lock=false",
-        {
-          cwd: tmpDir,
-          env: npmEnv,
-          timeout: 180000,
-        },
-        (err, stdout, stderr) => {
-          if (err) {
-            const message = String(stderr || err.message || "").trim();
-            console.log(
-              `[alphaclaw] alphaclaw install error: ${message.slice(0, 200)}`,
-            );
-            cleanup();
-            return reject(
-              new Error(
-                message || "Failed to install @chrysb/alphaclaw@latest",
-              ),
-            );
-          }
-          if (stdout?.trim()) {
-            console.log(
-              `[alphaclaw] alphaclaw install stdout: ${stdout.trim().slice(0, 300)}`,
-            );
-          }
-
-          const src = path.join(tmpDir, "node_modules");
-          const dest = path.join(installDir, "node_modules");
-          childProcess.exec(
-            `cp -af "${src}/." "${dest}/"`,
-            { timeout: kOpenclawUpdateCopyTimeoutMs },
-            (copyErr) => {
-              cleanup();
-              if (copyErr) {
-                console.log(
-                  `[alphaclaw] alphaclaw copy error: ${(copyErr.message || "").slice(0, 200)}`,
-                );
-                return reject(
-                  new Error(
-                    `Failed to copy updated AlphaClaw files: ${copyErr.message}`,
-                  ),
-                );
-              }
-              console.log("[alphaclaw] alphaclaw install completed");
-              resolve({ stdout: stdout?.trim(), stderr: stderr?.trim() });
-            },
-          );
-        },
-      );
-    });
-
   const isContainer = () =>
     process.env.RAILWAY_ENVIRONMENT ||
     process.env.RENDER ||
@@ -240,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);
@@ -277,18 +169,33 @@ const createAlphaclawVersionService = () => {
     kUpdateInProgress = true;
     const previousVersion = readAlphaclawVersion();
     try {
-      await installLatestAlphaclaw();
-      // Write marker to persistent volume so the update survives container recreation
-      const markerPath = path.join(kRootDir, ".alphaclaw-update-pending");
+      let targetVersion = "latest";
       try {
-        fs.writeFileSync(
-          markerPath,
-          JSON.stringify({ from: previousVersion, ts: Date.now() }),
+        const updateStatus = await readAlphaclawUpdateStatus({ refresh: true });
+        if (updateStatus.latestVersion) {
+          targetVersion = updateStatus.latestVersion;
+        }
+      } catch (error) {
+        console.log(
+          `[alphaclaw] Could not resolve exact AlphaClaw version before restart: ${error.message || "unknown error"}`,
         );
-        console.log(`[alphaclaw] Update marker written to ${markerPath}`);
-      } catch (e) {
-        console.log(`[alphaclaw] Could not write update marker: ${e.message}`);
       }
+
+      const spec = buildAlphaclawInstallSpec(targetVersion);
+      // Write marker to persistent volume so the update survives container recreation
+      const markerPath = path.join(kRootDir, ".alphaclaw-update-pending");
+      fs.writeFileSync(
+        markerPath,
+        JSON.stringify({
+          from: previousVersion,
+          to: targetVersion,
+          spec,
+          ts: Date.now(),
+        }),
+      );
+      console.log(
+        `[alphaclaw] Update marker written to ${markerPath} for ${spec}`,
+      );
       kUpdateStatusCache = {
         latestVersion: null,
         hasUpdate: false,
@@ -299,15 +206,17 @@ const createAlphaclawVersionService = () => {
         body: {
           ok: true,
           previousVersion,
+          targetVersion: targetVersion === "latest" ? null : targetVersion,
           restarting: true,
         },
       };
     } catch (err) {
-      kUpdateInProgress = false;
       return {
         status: 500,
         body: { ok: false, error: err.message || "Failed to update AlphaClaw" },
       };
+    } finally {
+      kUpdateInProgress = false;
     }
   };