@chrysb/alphaclaw 0.8.8 → 0.8.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "publishConfig": {
     "access": "public"
   },
@@ -27,7 +27,6 @@
     "start": "node bin/alphaclaw.js start",
     "build:ui": "node scripts/build-ui.mjs",
     "postinstall": "node ./scripts/apply-openclaw-patches.js",
-    "release:managed": "node scripts/release-managed.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:watchdog": "vitest run tests/server/watchdog.test.js tests/server/watchdog-db.test.js tests/server/routes-watchdog.test.js",

package/lib/public/js/components/update-modal-helpers.js

@@ -1,12 +0,0 @@
-export const createUpdateModalSubmitHandler = ({
-  onClose = () => {},
-  onUpdate = async () => ({ ok: false }),
-}) => {
-  return async () => {
-    const result = await onUpdate();
-    if (result?.ok) {
-      onClose();
-    }
-    return result;
-  };
-};

package/lib/release/managed-release.js

@@ -1,180 +0,0 @@
-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

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