@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/scripts/workspace-prepare.mjs

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+/**
+ * One-shot local workspace setup for a monorepo that consumes repo-local
+ * eliza + plugin checkouts alongside npm-published peers.
+ *
+ *   1. git submodule sync + update (recursive, init all)
+ *   2. snapshot every workspace package.json on disk
+ *   3. rewrite in-repo dependency specifiers to "workspace:*" (fix-workspace-deps)
+ *   4. bun install (refresh lockfile + postinstall)
+ *   5. restore package.json files from the snapshot — so "workspace:*" does
+ *      NOT persist on disk and plugin submodules stay clean in `git status`
+ *
+ * Why snapshot+restore instead of commit-it-forever:
+ *   Plugin submodules (eliza/plugins/plugin-*) are PUBLISHED TO NPM from their
+ *   own repos. Their committed package.json uses "@elizaos/core": "alpha"
+ *   so npm consumers can install them. If we left "workspace:*" on disk
+ *   after install, users would see dirty submodules and (worse) could
+ *   accidentally commit it back to the plugin repos, breaking npm install.
+ *
+ *   Bun's root-package.json `overrides` field handles the runtime redirect
+ *   to workspace packages regardless of what specifier the plugin declares,
+ *   so the on-disk rewrite is only needed for the duration of `bun install`.
+ *
+ * Usage:
+ *   bun scripts/workspace-prepare.mjs
+ *   bun scripts/workspace-prepare.mjs --remote         # submodule update --remote
+ *   bun scripts/workspace-prepare.mjs --skip-fix-deps  # no rewrite at all
+ *   bun scripts/workspace-prepare.mjs --skip-install   # no bun install
+ *   bun scripts/workspace-prepare.mjs --leave-on-disk  # opt out of restore (rare)
+ *   bun scripts/workspace-prepare.mjs --help
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { collectWorkspaceMaps } from "./lib/workspace-discovery.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+const REMOTE = process.argv.includes("--remote");
+const SKIP_FIX = process.argv.includes("--skip-fix-deps");
+const SKIP_INSTALL = process.argv.includes("--skip-install");
+const LEAVE_ON_DISK = process.argv.includes("--leave-on-disk");
+
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+  console.log(`workspace-prepare — submodule sync/update, fix-deps, bun install, restore
+
+  bun scripts/workspace-prepare.mjs [options]
+
+Options:
+  --remote         Pass --remote to git submodule update (follow branch tips; changes SHAs)
+  --skip-fix-deps  Skip the rewrite step entirely (equivalent to plain bun install)
+  --skip-install   Submodules + fix-deps only (no bun install, no restore)
+  --leave-on-disk  Leave "workspace:*" in package.json after install (legacy; rare)
+  --help, -h       This message
+`);
+  process.exit(0);
+}
+
+function run(label, cmd, args) {
+  console.log(`\n[workspace-prepare] ${label}\n  ${cmd} ${args.join(" ")}\n`);
+  const r = spawnSync(cmd, args, {
+    cwd: root,
+    stdio: "inherit",
+    env: process.env,
+  });
+  const code = r.status ?? 1;
+  if (code !== 0) {
+    console.error(`\n[workspace-prepare] failed: ${cmd} exited ${code}`);
+    process.exit(code);
+  }
+}
+
+// ── 1. submodules ─────────────────────────────────────────────────────
+
+const gitDir = resolve(root, ".git");
+if (existsSync(gitDir)) {
+  run("submodule sync", "git", ["submodule", "sync", "--recursive"]);
+  const updateArgs = ["submodule", "update", "--init", "--recursive"];
+  if (REMOTE) {
+    updateArgs.push("--remote");
+  }
+  run("submodule update", "git", updateArgs);
+} else {
+  console.log(
+    "[workspace-prepare] No .git — skipping submodule sync/update (e.g. npm tarball checkout)",
+  );
+}
+
+// ── 2. snapshot every workspace package.json ──────────────────────────
+//
+// We read-then-restore by raw bytes (not JSON round-trip) so the file is
+// byte-identical after install: no whitespace drift, no key reordering.
+
+/** @type {Map<string, string>} path -> original raw contents */
+const snapshot = new Map();
+
+if (!SKIP_FIX && !LEAVE_ON_DISK) {
+  const rootPkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const patterns = rootPkg.workspaces || [];
+  const { workspaceDirs } = collectWorkspaceMaps(root, patterns);
+  for (const dir of workspaceDirs) {
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      snapshot.set(pkgPath, readFileSync(pkgPath, "utf8"));
+    }
+  }
+  console.log(
+    `\n[workspace-prepare] snapshotted ${snapshot.size} package.json file(s) for post-install restore\n`,
+  );
+}
+
+function restoreSnapshot() {
+  if (snapshot.size === 0) return;
+  let restored = 0;
+  for (const [pkgPath, original] of snapshot) {
+    const current = existsSync(pkgPath) ? readFileSync(pkgPath, "utf8") : null;
+    if (current !== original) {
+      writeFileSync(pkgPath, original, "utf8");
+      restored++;
+    }
+  }
+  console.log(
+    `\n[workspace-prepare] restored ${restored} package.json file(s) to pre-install state\n`,
+  );
+}
+
+// Best-effort restore on unexpected exit so a Ctrl+C mid-install doesn't
+// leave the repo in a half-rewritten state.
+if (snapshot.size > 0) {
+  let restoredAlready = false;
+  const cleanup = () => {
+    if (restoredAlready) return;
+    restoredAlready = true;
+    try {
+      restoreSnapshot();
+    } catch (err) {
+      console.error(
+        "[workspace-prepare] snapshot restore failed:",
+        err instanceof Error ? err.message : err,
+      );
+    }
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(143);
+  });
+  process.on("uncaughtException", (err) => {
+    cleanup();
+    console.error(err);
+    process.exit(1);
+  });
+}
+
+// ── 3. rewrite to workspace:* ────────────────────────────────────────
+
+if (!SKIP_FIX) {
+  run("fix in-repo deps → workspace:*", "bun", [
+    resolve(root, "scripts/fix-workspace-deps.mjs"),
+  ]);
+} else {
+  console.log(
+    "\n[workspace-prepare] --skip-fix-deps: leaving dependency specifiers as-is\n",
+  );
+}
+
+// ── 4. bun install ───────────────────────────────────────────────────
+
+if (!SKIP_INSTALL) {
+  run("install", "bun", ["install"]);
+} else {
+  console.log(
+    "\n[workspace-prepare] --skip-install: not running bun install\n",
+  );
+}
+
+// ── 5. restore package.json from snapshot ────────────────────────────
+
+if (!SKIP_FIX && !LEAVE_ON_DISK && !SKIP_INSTALL) {
+  restoreSnapshot();
+} else if (LEAVE_ON_DISK) {
+  console.log(
+    "\n[workspace-prepare] --leave-on-disk: keeping workspace:* in package.json (legacy)\n",
+  );
+}
+
+console.log("\n[workspace-prepare] done.\n");

package/scripts/worktree-env.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+# Generate .env.worktree for isolated multi-instance dev.
+#
+# Usage:
+#   bash scripts/worktree-env.sh [slot]
+#
+# slot: integer offset (default 1). Slot 0 = default ports, slot 1 = +100,
+#       slot 2 = +200, etc. Each slot gets its own state directory too.
+#
+# The generated .env.worktree is auto-loaded by dev-ui.mjs, dev-platform.mjs,
+# and run-node.mjs before port resolution, so `bun run dev` Just Works.
+
+set -euo pipefail
+
+SLOT=${1:-1}
+OFFSET=$((SLOT * 100))
+
+API_PORT=$((31337 + OFFSET))
+UI_PORT=$((2138 + OFFSET))
+HOME_PORT=$((2142 + OFFSET))
+GATEWAY_PORT=$((18789 + OFFSET))
+STATE_DIR="~/.eliza-wt-${SLOT}"
+
+cat > .env.worktree <<EOF
+# Worktree isolation — slot ${SLOT}
+# Generated by: bash scripts/worktree-env.sh ${SLOT}
+# Regenerate with a different slot number to change ports.
+
+ELIZA_API_PORT=${API_PORT}
+ELIZA_PORT=${UI_PORT}
+ELIZA_HOME_PORT=${HOME_PORT}
+ELIZA_GATEWAY_PORT=${GATEWAY_PORT}
+ELIZA_STATE_DIR=${STATE_DIR}
+EOF
+
+echo "Wrote .env.worktree (slot ${SLOT})"
+echo "  API:     ${API_PORT}"
+echo "  UI:      ${UI_PORT}"
+echo "  Home:    ${HOME_PORT}"
+echo "  Gateway: ${GATEWAY_PORT}"
+echo "  State:   ${STATE_DIR}"

package/scripts/write-build-info.ts

@@ -0,0 +1,69 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const rootDir = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+);
+const distDir = path.join(rootDir, "dist");
+const pkgPath = path.join(rootDir, "package.json");
+
+const readPackageVersion = () => {
+  try {
+    const raw = fs.readFileSync(pkgPath, "utf8");
+    const parsed = JSON.parse(raw) as { version?: string };
+    return parsed.version ?? null;
+  } catch {
+    return null;
+  }
+};
+
+const resolveCommit = () => {
+  const envCommit =
+    process.env.GIT_COMMIT?.trim() || process.env.GIT_SHA?.trim();
+  if (envCommit) {
+    return envCommit;
+  }
+  try {
+    return execSync("git rev-parse HEAD", {
+      cwd: rootDir,
+      stdio: ["ignore", "pipe", "ignore"],
+    })
+      .toString()
+      .trim();
+  } catch {
+    return null;
+  }
+};
+
+const detectChannel = (version: string | null): string => {
+  if (!version) return "unknown";
+  if (version.includes("-nightly")) return "nightly";
+  if (version.includes("-beta")) return "beta";
+  if (version.includes("-rc")) return "rc";
+  if (version.includes("-")) return "prerelease";
+  return "stable";
+};
+
+const version = readPackageVersion();
+const commit = resolveCommit();
+const channel = detectChannel(version);
+
+const buildInfo = {
+  version,
+  channel,
+  commit,
+  builtAt: new Date().toISOString(),
+};
+
+fs.mkdirSync(distDir, { recursive: true });
+fs.writeFileSync(
+  path.join(distDir, "package.json"),
+  `${JSON.stringify({ type: "module" })}\n`,
+);
+fs.writeFileSync(
+  path.join(distDir, "build-info.json"),
+  `${JSON.stringify(buildInfo, null, 2)}\n`,
+);

package/scripts/write-homepage-release-data.mjs

@@ -0,0 +1,393 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildRawGitHubAssetBase } from "./lib/asset-cdn.mjs";
+
+const REPOSITORY = "elizaos/eliza";
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+// SCRIPT_DIR is packages/app-core/scripts; the repo root is three levels up.
+const REPO_ROOT = path.resolve(SCRIPT_DIR, "..", "..", "..");
+const OUTPUT_PATH = path.resolve(
+  REPO_ROOT,
+  "packages/homepage/src/generated/release-data.ts",
+);
+const RELEASES_URL = `https://api.github.com/repos/${REPOSITORY}/releases?per_page=20`;
+const RELEASES_PAGE_URL = `https://github.com/${REPOSITORY}/releases`;
+
+const installBaseUrl = "https://eliza.ai";
+const scripts = {
+  shell: {
+    url: `${installBaseUrl}/install.sh`,
+    command: `curl -fsSL ${installBaseUrl}/install.sh | bash`,
+  },
+  powershell: {
+    url: `${installBaseUrl}/install.ps1`,
+    command: `irm ${installBaseUrl}/install.ps1 | iex`,
+  },
+};
+
+const publishedAtFormatter = new Intl.DateTimeFormat("en-US", {
+  month: "short",
+  day: "numeric",
+  year: "numeric",
+});
+
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes <= 0) {
+    return "size unavailable";
+  }
+
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex += 1;
+  }
+
+  const decimals = unitIndex === 0 ? 0 : 1;
+  return `${size.toFixed(decimals)} ${units[unitIndex]}`;
+}
+
+function noteForAsset(name) {
+  if (/\.dmg$/i.test(name)) {
+    return "DMG installer";
+  }
+  if (/\.msix$/i.test(name)) {
+    return "MSIX package";
+  }
+  if (/\.exe$/i.test(name)) {
+    return "Windows installer";
+  }
+  if (/\.zip$/i.test(name)) {
+    return "ZIP package";
+  }
+  if (/\.appimage$/i.test(name)) {
+    return "AppImage";
+  }
+  if (/\.deb$/i.test(name)) {
+    return "Debian package";
+  }
+  if (/\.tar\.gz$/i.test(name)) {
+    return "tar.gz package";
+  }
+  return "Release asset";
+}
+
+function sortReleasesByRecency(releases) {
+  return [...releases]
+    .filter((release) => !release.draft)
+    .sort((a, b) => {
+      const aTime = Date.parse(a.published_at ?? a.created_at ?? 0);
+      const bTime = Date.parse(b.published_at ?? b.created_at ?? 0);
+      return bTime - aTime;
+    });
+}
+
+function pickRelease(releases) {
+  const published = sortReleasesByRecency(releases);
+  // Pick the most recent release that has downloadable assets
+  return (
+    published.find((r) => Array.isArray(r.assets) && r.assets.length > 0) ??
+    published[0] ??
+    null
+  );
+}
+
+function pickStableRelease(releases) {
+  const stable = sortReleasesByRecency(releases).filter((r) => !r.prerelease);
+  return (
+    stable.find((r) => Array.isArray(r.assets) && r.assets.length > 0) ??
+    stable[0] ??
+    null
+  );
+}
+
+function pickCanaryRelease(releases) {
+  const canary = sortReleasesByRecency(releases).filter((r) => r.prerelease);
+  return (
+    canary.find((r) => Array.isArray(r.assets) && r.assets.length > 0) ??
+    canary[0] ??
+    null
+  );
+}
+
+function pickAsset(assets, matchers) {
+  for (const matcher of matchers) {
+    const asset = assets.find(matcher);
+    if (asset) {
+      return asset;
+    }
+  }
+  return null;
+}
+
+function serializeDownload(id, label, asset) {
+  return {
+    id,
+    label,
+    fileName: asset.name,
+    url: asset.browser_download_url,
+    sizeLabel: formatBytes(asset.size ?? 0),
+    note: noteForAsset(asset.name),
+  };
+}
+
+function pickAssetFromReleases(releases, matchers) {
+  for (const release of releases) {
+    const assets = Array.isArray(release.assets) ? release.assets : [];
+    const asset = pickAsset(assets, matchers);
+    if (asset) {
+      return asset;
+    }
+  }
+  return null;
+}
+
+function buildRelease(release, allReleases = []) {
+  if (!release) {
+    return {
+      tagName: "unavailable",
+      publishedAtLabel: "unavailable",
+      prerelease: false,
+      url: RELEASES_PAGE_URL,
+      downloads: [],
+      checksum: null,
+    };
+  }
+
+  const assets = Array.isArray(release.assets) ? release.assets : [];
+  const releasesByRecency = sortReleasesByRecency(allReleases);
+  const prioritizedReleases = [
+    release,
+    ...releasesByRecency.filter((candidate) => candidate !== release),
+  ].filter(Boolean);
+
+  const downloads = [
+    {
+      id: "macos-arm64",
+      label: "macOS (Apple Silicon)",
+      asset: pickAssetFromReleases(prioritizedReleases, [
+        (asset) =>
+          /macos-arm64/i.test(asset.name) && /\.dmg$/i.test(asset.name),
+        (asset) => /arm64/i.test(asset.name) && /\.dmg$/i.test(asset.name),
+      ]),
+    },
+    {
+      id: "macos-x64",
+      label: "macOS (Intel)",
+      asset: pickAssetFromReleases(prioritizedReleases, [
+        (asset) => /macos-x64/i.test(asset.name) && /\.dmg$/i.test(asset.name),
+        (asset) =>
+          /mac/i.test(asset.name) &&
+          !/arm64/i.test(asset.name) &&
+          /\.dmg$/i.test(asset.name),
+      ]),
+    },
+    {
+      id: "windows-x64",
+      label: "Windows",
+      asset: pickAssetFromReleases(prioritizedReleases, [
+        (asset) => /setup/i.test(asset.name) && /\.exe$/i.test(asset.name),
+        (asset) => /win/i.test(asset.name) && /\.exe$/i.test(asset.name),
+        (asset) => /win/i.test(asset.name) && /\.msix$/i.test(asset.name),
+      ]),
+    },
+    {
+      id: "linux-x64",
+      label: "Linux",
+      asset: pickAssetFromReleases(prioritizedReleases, [
+        (asset) => /linux/i.test(asset.name) && /\.appimage$/i.test(asset.name),
+        (asset) => /linux/i.test(asset.name) && /\.tar\.gz$/i.test(asset.name),
+      ]),
+    },
+    {
+      id: "linux-deb",
+      label: "Ubuntu / Debian",
+      asset: pickAssetFromReleases(prioritizedReleases, [
+        (asset) => /linux/i.test(asset.name) && /\.deb$/i.test(asset.name),
+        (asset) => /\.deb$/i.test(asset.name),
+      ]),
+    },
+  ]
+    .filter((entry) => entry.asset)
+    .map((entry) => serializeDownload(entry.id, entry.label, entry.asset));
+
+  const checksumAsset =
+    assets.find((asset) => asset.name === "SHA256SUMS.txt") ?? null;
+
+  return {
+    tagName: release.tag_name ?? "unavailable",
+    publishedAtLabel: release.published_at
+      ? publishedAtFormatter.format(new Date(release.published_at))
+      : "unavailable",
+    prerelease: Boolean(release.prerelease),
+    url: release.html_url ?? RELEASES_PAGE_URL,
+    downloads,
+    checksum: checksumAsset
+      ? {
+          fileName: checksumAsset.name,
+          url: checksumAsset.browser_download_url,
+        }
+      : null,
+  };
+}
+
+function buildPayload(release, allReleases = [], canaryRelease = null) {
+  const tagName = release?.tag_name ?? "unavailable";
+  return {
+    generatedAt: new Date().toISOString(),
+    scripts,
+    cdn: {
+      tagName,
+      appAssetBaseUrl:
+        tagName === "unavailable"
+          ? ""
+          : buildRawGitHubAssetBase({
+              releaseTag: tagName,
+              assetRoot: "packages/app/public",
+            }),
+      homepageAssetBaseUrl:
+        tagName === "unavailable"
+          ? ""
+          : buildRawGitHubAssetBase({
+              releaseTag: tagName,
+              assetRoot: "packages/homepage/public",
+            }),
+    },
+    release: buildRelease(release, allReleases),
+    stableRelease: buildRelease(release, allReleases),
+    canaryRelease: canaryRelease
+      ? buildRelease(canaryRelease, allReleases)
+      : null,
+  };
+}
+
+const TYPE_HEADER = `// Generated by packages/app-core/scripts/write-homepage-release-data.mjs.
+// Do not edit by hand — run \`bun run prebuild\` (or rerun the script directly)
+// to refresh from the GitHub Releases API.
+
+export type ReleaseDataDownload = {
+  id: string;
+  label: string;
+  fileName: string;
+  url: string;
+  sizeLabel: string;
+  note: string;
+};
+
+export type ReleaseDataChecksum = {
+  fileName: string;
+  url: string;
+};
+
+export type ReleaseDataRelease = {
+  tagName: string;
+  publishedAtLabel: string;
+  prerelease: boolean;
+  url: string;
+  downloads: ReleaseDataDownload[];
+  checksum: ReleaseDataChecksum | null;
+};
+
+export type ReleaseDataScripts = {
+  shell: { url: string; command: string };
+  powershell: { url: string; command: string };
+};
+
+export type ReleaseDataCdn = {
+  tagName: string;
+  appAssetBaseUrl: string;
+  homepageAssetBaseUrl: string;
+};
+
+export type ReleaseDataPayload = {
+  generatedAt: string;
+  scripts: ReleaseDataScripts;
+  cdn: ReleaseDataCdn;
+  release: ReleaseDataRelease;
+  stableRelease: ReleaseDataRelease;
+  canaryRelease: ReleaseDataRelease | null;
+};
+
+`;
+
+function toModule(payload) {
+  return `${TYPE_HEADER}export const releaseData: ReleaseDataPayload = ${JSON.stringify(payload, null, 2)};\n`;
+}
+
+async function fetchReleases() {
+  const headers = {
+    Accept: "application/vnd.github+json",
+    "User-Agent": "eliza-homepage-release-data",
+  };
+
+  const token = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  const response = await fetch(RELEASES_URL, { headers });
+  if (!response.ok) {
+    throw new Error(
+      `GitHub API returned ${response.status} ${response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+async function writePayload(payload) {
+  await mkdir(path.dirname(OUTPUT_PATH), { recursive: true });
+  await writeFile(OUTPUT_PATH, toModule(payload));
+  // Best-effort biome format; biome.json may exclude `src/generated/`, in which
+  // case biome exits non-zero. The generated file is JSON.stringify output and
+  // doesn't need formatting to be correct, so failures here are not fatal.
+  const relOutput = path.relative(REPO_ROOT, OUTPUT_PATH);
+  const biomeArgs = ["@biomejs/biome", "format", "--write", relOutput];
+  const bunx = process.platform === "win32" ? "bunx.cmd" : "bunx";
+  try {
+    execFileSync(bunx, biomeArgs, {
+      stdio: "ignore",
+      cwd: REPO_ROOT,
+      shell: false,
+    });
+  } catch {
+    // Ignore — the file is still valid TypeScript without biome's pass.
+  }
+}
+
+async function main() {
+  try {
+    const releases = await fetchReleases();
+    const stableRelease = pickStableRelease(releases);
+    const canaryRelease = pickCanaryRelease(releases);
+    // Use stable release as primary; fall back to any release if no stable exists
+    const primaryRelease = stableRelease ?? pickRelease(releases);
+    await writePayload(buildPayload(primaryRelease, releases, canaryRelease));
+    const tag = primaryRelease?.tag_name ?? "no published release";
+    const canaryTag = canaryRelease?.tag_name;
+    console.log(
+      `homepage release data: stable=${tag}${canaryTag ? `, canary=${canaryTag}` : ""}`,
+    );
+  } catch (error) {
+    if (existsSync(OUTPUT_PATH)) {
+      console.warn(
+        `homepage release data refresh failed, keeping existing file: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return;
+    }
+
+    await writePayload(buildPayload(null));
+    console.warn(
+      `homepage release data refresh failed, wrote fallback file: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+await main();