@elizaos/app-core 2.0.0-beta.2 → 2.0.11-beta.5

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

@@ -2,7 +2,7 @@
 
 import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { buildRawGitHubAssetBase } from "./lib/asset-cdn.mjs";
@@ -11,6 +11,12 @@ 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 OS_MANIFEST_PATH = path.resolve(
+  REPO_ROOT,
+  "packages/os/release/beta-2026-05-16/manifest.json",
+);
+const GITHUB_RELEASES_BASE = `https://github.com/${REPOSITORY}/releases/download`;
+const ELIZAOS_DOWNLOADS_BASE = "https://downloads.elizaos.ai/os";
 const OUTPUT_PATH = path.resolve(
   REPO_ROOT,
   "packages/homepage/src/generated/release-data.ts",
@@ -18,7 +24,7 @@ const OUTPUT_PATH = path.resolve(
 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 installBaseUrl = "https://eliza.app";
 const scripts = {
   shell: {
     url: `${installBaseUrl}/install.sh`,
@@ -30,6 +36,49 @@ const scripts = {
   },
 };
 
+const storeTargets = [
+  {
+    platform: "ios",
+    label: "iOS App Store",
+    artifact: "iOS App Store",
+    status: "coming-soon",
+    reviewState: "not-submitted",
+    rolloutChannel: "TestFlight first",
+    fallbackArtifact: "TestFlight beta when approved",
+    url: null,
+  },
+  {
+    platform: "android",
+    label: "Google Play Store",
+    artifact: "Google Play Store",
+    status: "coming-soon",
+    reviewState: "not-submitted",
+    rolloutChannel: "APK bridge",
+    fallbackArtifact: "GitHub Release APK when signed",
+    url: null,
+  },
+  {
+    platform: "macos",
+    label: "Mac App Store",
+    artifact: "Mac App Store",
+    status: "coming-soon",
+    reviewState: "not-submitted",
+    rolloutChannel: "Signed DMG first",
+    fallbackArtifact: "macOS DMG",
+    url: null,
+  },
+  {
+    platform: "windows",
+    label: "Microsoft Store",
+    artifact: "Microsoft Store",
+    status: "coming-soon",
+    reviewState: "not-submitted",
+    rolloutChannel: "EXE first",
+    fallbackArtifact: "Windows EXE installer",
+    url: null,
+  },
+];
+
 const publishedAtFormatter = new Intl.DateTimeFormat("en-US", {
   month: "short",
   day: "numeric",
@@ -55,15 +104,24 @@ function formatBytes(bytes) {
 }
 
 function noteForAsset(name) {
+  if (/macos.*\.app\.tar\.gz$/i.test(name)) {
+    return "macOS app archive";
+  }
   if (/\.dmg$/i.test(name)) {
     return "DMG installer";
   }
+  if (/\.exe\.zip$/i.test(name)) {
+    return "Windows EXE archive";
+  }
   if (/\.msix$/i.test(name)) {
     return "MSIX package";
   }
   if (/\.exe$/i.test(name)) {
     return "Windows installer";
   }
+  if (/\.apk$/i.test(name)) {
+    return "Android APK";
+  }
   if (/\.zip$/i.test(name)) {
     return "ZIP package";
   }
@@ -76,6 +134,9 @@ function noteForAsset(name) {
   if (/\.tar\.gz$/i.test(name)) {
     return "tar.gz package";
   }
+  if (/\.tar\.zst$/i.test(name)) {
+    return "tar.zst package";
+  }
   return "Release asset";
 }
 
@@ -127,7 +188,7 @@ function pickAsset(assets, matchers) {
   return null;
 }
 
-function serializeDownload(id, label, asset) {
+function serializeDownload(id, label, asset, release) {
   return {
     id,
     label,
@@ -135,6 +196,11 @@ function serializeDownload(id, label, asset) {
     url: asset.browser_download_url,
     sizeLabel: formatBytes(asset.size ?? 0),
     note: noteForAsset(asset.name),
+    releaseTagName: release?.tag_name ?? "unavailable",
+    releaseUrl: release?.html_url ?? RELEASES_PAGE_URL,
+    releasePublishedAtLabel: release?.published_at
+      ? publishedAtFormatter.format(new Date(release.published_at))
+      : "unavailable",
   };
 }
 
@@ -143,13 +209,13 @@ function pickAssetFromReleases(releases, matchers) {
     const assets = Array.isArray(release.assets) ? release.assets : [];
     const asset = pickAsset(assets, matchers);
     if (asset) {
-      return asset;
+      return { asset, release };
     }
   }
   return null;
 }
 
-function buildRelease(release, allReleases = []) {
+function buildRelease(release) {
   if (!release) {
     return {
       tagName: "unavailable",
@@ -162,61 +228,99 @@ function buildRelease(release, allReleases = []) {
   }
 
   const assets = Array.isArray(release.assets) ? release.assets : [];
-  const releasesByRecency = sortReleasesByRecency(allReleases);
-  const prioritizedReleases = [
-    release,
-    ...releasesByRecency.filter((candidate) => candidate !== release),
-  ].filter(Boolean);
+  const prioritizedReleases = [release].filter(Boolean);
 
   const downloads = [
     {
       id: "macos-arm64",
       label: "macOS (Apple Silicon)",
-      asset: pickAssetFromReleases(prioritizedReleases, [
+      pick: 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),
+        (asset) =>
+          /macos-arm64/i.test(asset.name) &&
+          /\.app\.tar\.gz$/i.test(asset.name),
+        (asset) =>
+          /arm64/i.test(asset.name) && /\.app\.tar\.gz$/i.test(asset.name),
       ]),
     },
     {
       id: "macos-x64",
       label: "macOS (Intel)",
-      asset: pickAssetFromReleases(prioritizedReleases, [
+      pick: 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),
+        (asset) =>
+          /macos-x64/i.test(asset.name) && /\.app\.tar\.gz$/i.test(asset.name),
+        (asset) =>
+          /mac/i.test(asset.name) &&
+          !/arm64/i.test(asset.name) &&
+          /\.app\.tar\.gz$/i.test(asset.name),
       ]),
     },
     {
       id: "windows-x64",
       label: "Windows",
-      asset: pickAssetFromReleases(prioritizedReleases, [
+      pick: pickAssetFromReleases(prioritizedReleases, [
+        (asset) =>
+          /ElizaOSApp-Setup/i.test(asset.name) && /\.exe$/i.test(asset.name),
         (asset) => /setup/i.test(asset.name) && /\.exe$/i.test(asset.name),
         (asset) => /win/i.test(asset.name) && /\.exe$/i.test(asset.name),
+        (asset) =>
+          /windows-x64/i.test(asset.name) && /\.exe\.zip$/i.test(asset.name),
+        (asset) => /win/i.test(asset.name) && /\.exe\.zip$/i.test(asset.name),
         (asset) => /win/i.test(asset.name) && /\.msix$/i.test(asset.name),
       ]),
     },
     {
       id: "linux-x64",
       label: "Linux",
-      asset: pickAssetFromReleases(prioritizedReleases, [
+      pick: pickAssetFromReleases(prioritizedReleases, [
         (asset) => /linux/i.test(asset.name) && /\.appimage$/i.test(asset.name),
+        (asset) => /linux/i.test(asset.name) && /\.tar\.zst$/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, [
+      pick: pickAssetFromReleases(prioritizedReleases, [
         (asset) => /linux/i.test(asset.name) && /\.deb$/i.test(asset.name),
         (asset) => /\.deb$/i.test(asset.name),
       ]),
     },
+    {
+      id: "linux-rpm",
+      label: "Fedora / RHEL",
+      pick: pickAssetFromReleases(prioritizedReleases, [
+        (asset) => /linux/i.test(asset.name) && /\.rpm$/i.test(asset.name),
+        (asset) => /\.rpm$/i.test(asset.name),
+      ]),
+    },
+    {
+      id: "android-apk",
+      label: "Android APK",
+      pick: pickAssetFromReleases(prioritizedReleases, [
+        (asset) => /android/i.test(asset.name) && /\.apk$/i.test(asset.name),
+        (asset) => /Eliza-\d/i.test(asset.name) && /\.apk$/i.test(asset.name),
+        (asset) =>
+          /app-release/i.test(asset.name) && /\.apk$/i.test(asset.name),
+      ]),
+    },
   ]
-    .filter((entry) => entry.asset)
-    .map((entry) => serializeDownload(entry.id, entry.label, entry.asset));
+    .filter((entry) => entry.pick)
+    .map((entry) =>
+      serializeDownload(
+        entry.id,
+        entry.label,
+        entry.pick.asset,
+        entry.pick.release,
+      ),
+    );
 
   const checksumAsset =
     assets.find((asset) => asset.name === "SHA256SUMS.txt") ?? null;
@@ -238,11 +342,302 @@ function buildRelease(release, allReleases = []) {
   };
 }
 
-function buildPayload(release, allReleases = [], canaryRelease = null) {
+// Maps a manifest artifact kind/platform to the OsArtifact kind field.
+function manifestKindToArtifactKind(manifestKind, target) {
+  if (manifestKind === "raw-image") return "iso";
+  if (manifestKind === "vm-image") {
+    const hypervisor = target?.hypervisor ?? "";
+    if (/ova/i.test(hypervisor)) return "ova";
+    return "ova"; // all VM images surface as OVA-class for download UX
+  }
+  if (manifestKind === "android-image") return "apk";
+  if (manifestKind === "usb-installer") return "desktop-app";
+  return "iso";
+}
+
+function manifestPlatformToArtifactPlatform(target) {
+  const platform = target?.platform ?? "";
+  if (/android|cuttlefish/i.test(platform)) return "android";
+  if (/linux/i.test(platform)) return "linux";
+  if (/macos|apple/i.test(platform)) return "macos";
+  if (/windows|win/i.test(platform)) return "windows";
+  return "linux";
+}
+
+function buildOsArtifactsFromManifest(manifest, channel, version) {
+  const artifacts = Array.isArray(manifest?.artifacts)
+    ? manifest.artifacts
+    : [];
+  return artifacts.map((artifact) => ({
+    id: artifact.id,
+    label: artifact.filename.replace(/\.zst$|\.zip$/, ""),
+    description: artifact.notes ?? "",
+    platform: manifestPlatformToArtifactPlatform(artifact.target),
+    kind: manifestKindToArtifactKind(artifact.kind, artifact.target),
+    channel,
+    version,
+    downloadUrl: artifact.downloadUrl ?? null,
+    checksumUrl: null,
+    sizeBytes: artifact.sizeBytes ?? null,
+    sha256: artifact.sha256 ?? null,
+    releaseNotesUrl: null,
+    requiresHardware: undefined,
+  }));
+}
+
+function buildStaticOsArtifacts(channel, version) {
+  const releaseTag = `v${version}`;
+  const githubBase = `${GITHUB_RELEASES_BASE}/${releaseTag}`;
+  return [
+    {
+      id: `elizaos-linux-live-${channel}`,
+      label: "elizaOS Linux Live ISO",
+      description:
+        "Bootable ISO image for USB flashing and bare-metal installs. Flash to an 8 GB+ USB drive with the USB Installer app.",
+      platform: "linux",
+      kind: "iso",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "8 GB USB drive",
+    },
+    {
+      id: "elizaos-debian-package",
+      label: "elizaOS Debian / Ubuntu package",
+      description:
+        "Install elizaOS on an existing Debian or Ubuntu system via apt.",
+      platform: "linux",
+      kind: "deb",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+    },
+    {
+      id: "elizaos-vm-ova",
+      label: "elizaOS VM (OVA)",
+      description:
+        "OVA image for VirtualBox, VMware Fusion, and UTM. Import directly — no flashing required.",
+      platform: "cross-platform",
+      kind: "ova",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+    },
+    {
+      id: "elizaos-usb-installer-macos",
+      label: "USB Installer — macOS",
+      description:
+        "Desktop app for macOS (Apple Silicon + Intel) that writes the elizaOS ISO to a USB drive using diskutil and dd with native authorization.",
+      platform: "macos",
+      kind: "desktop-app",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "8 GB USB drive",
+    },
+    {
+      id: "elizaos-usb-installer-linux",
+      label: "USB Installer — Linux",
+      description:
+        "Desktop app for Linux that writes the elizaOS ISO to a USB drive using lsblk and dd via pkexec.",
+      platform: "linux",
+      kind: "desktop-app",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "8 GB USB drive",
+    },
+    {
+      id: "elizaos-usb-installer-windows",
+      label: "USB Installer — Windows",
+      description:
+        "Desktop app for Windows that writes the elizaOS ISO to a USB drive using PowerShell disk management.",
+      platform: "windows",
+      kind: "desktop-app",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "8 GB USB drive",
+    },
+    {
+      id: "elizaos-setup-macos",
+      label: "AOSP Flasher — macOS",
+      description:
+        "GUI tool for macOS that detects a connected Pixel via ADB, downloads the elizaOS AOSP build, and guides through bootloader unlock and flashing.",
+      platform: "macos",
+      kind: "desktop-app",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "Android device with unlocked bootloader",
+    },
+    {
+      id: "elizaos-setup-linux",
+      label: "AOSP Flasher — Linux",
+      description:
+        "GUI tool for Linux that detects a connected Pixel via ADB, downloads the elizaOS AOSP build, and guides through bootloader unlock and flashing.",
+      platform: "linux",
+      kind: "desktop-app",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "Android device with unlocked bootloader",
+    },
+    {
+      id: "elizaos-setup-windows",
+      label: "AOSP Flasher — Windows",
+      description:
+        "GUI tool for Windows that detects a connected Pixel via ADB, downloads the elizaOS AOSP build, and guides through bootloader unlock and flashing.",
+      platform: "windows",
+      kind: "desktop-app",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+      requiresHardware: "Android device with unlocked bootloader",
+    },
+    {
+      id: "elizaos-android-apk",
+      label: "elizaOS Android APK",
+      description:
+        "Sideload elizaOS onto any Android device without AOSP flashing. No unlocked bootloader required.",
+      platform: "android",
+      kind: "apk",
+      channel,
+      version,
+      downloadUrl: null,
+      checksumUrl: null,
+      sizeBytes: null,
+      sha256: null,
+      releaseNotesUrl: null,
+    },
+  ];
+}
+
+function pickAndroidApkAsset(release) {
+  const assets = Array.isArray(release?.assets) ? release.assets : [];
+  return (
+    assets.find(
+      (a) =>
+        /^elizaos-android-.*-release\.apk$/i.test(a.name) ||
+        /^Eliza-.*\.apk$/i.test(a.name),
+    ) ?? null
+  );
+}
+
+function pickAssetByNamePattern(release, pattern) {
+  const assets = Array.isArray(release?.assets) ? release.assets : [];
+  return assets.find((a) => pattern.test(a.name)) ?? null;
+}
+
+const STATIC_ARTIFACT_ASSET_PATTERNS = {
+  "elizaos-usb-installer-macos": /^elizaos-usb-installer-macos.*\.tar\.gz$/i,
+  "elizaos-usb-installer-linux": /^elizaos-usb-installer-linux.*\.tar\.gz$/i,
+  "elizaos-usb-installer-windows": /^elizaos-usb-installer-windows.*\.(zip|exe)$/i,
+  "elizaos-setup-macos": /^elizaos-setup-macos.*\.tar\.gz$/i,
+  "elizaos-setup-linux": /^elizaos-setup-linux.*\.tar\.gz$/i,
+  "elizaos-setup-windows": /^elizaos-setup-windows.*\.(zip|exe)$/i,
+  "elizaos-debian-package": /^elizaos.*\.deb$/i,
+  "elizaos-linux-live-beta": /^elizaos.*-linux.*\.(iso|raw\.img\.zst)$/i,
+  "elizaos-vm-ova": /^elizaos.*\.(ova|qcow2\.zst)$/i,
+};
+
+async function buildOsArtifacts(release) {
+  let manifest = null;
+  try {
+    const raw = await readFile(OS_MANIFEST_PATH, "utf8");
+    manifest = JSON.parse(raw);
+  } catch {
+    // Manifest not available — use static artifacts only.
+  }
+
+  const channel = manifest?.release?.channel ?? "beta";
+  const version = manifest?.release?.version ?? "2.0.0-beta.2-os.20260516";
+
+  const fromManifest = manifest
+    ? buildOsArtifactsFromManifest(manifest, channel, version)
+    : [];
+
+  // Deduplicate: static artifacts use well-known IDs not found in the manifest.
+  // Manifest artifacts use their own IDs. Merge with static list appended.
+  const staticArtifacts = buildStaticOsArtifacts(channel, version);
+
+  // Populate the elizaos-android-apk entry from the published release APK if present.
+  const apkAsset = pickAndroidApkAsset(release);
+  if (apkAsset) {
+    const apkEntry = staticArtifacts.find(
+      (a) => a.id === "elizaos-android-apk",
+    );
+    if (apkEntry) {
+      apkEntry.downloadUrl = apkAsset.browser_download_url;
+      apkEntry.sizeBytes = apkAsset.size ?? null;
+    }
+  }
+
+  // Populate USB installer / AOSP Flasher / Debian / ISO / OVA entries from
+  // matching release assets when present.
+  for (const [id, pattern] of Object.entries(STATIC_ARTIFACT_ASSET_PATTERNS)) {
+    const asset = pickAssetByNamePattern(release, pattern);
+    if (!asset) continue;
+    const entry = staticArtifacts.find((a) => a.id === id);
+    if (!entry) continue;
+    entry.downloadUrl = asset.browser_download_url;
+    entry.sizeBytes = asset.size ?? null;
+  }
+
+  // Remove any static artifact whose ID is already supplied by the manifest.
+  const manifestIds = new Set(fromManifest.map((a) => a.id));
+  const uniqueStatic = staticArtifacts.filter((a) => !manifestIds.has(a.id));
+
+  return [...fromManifest, ...uniqueStatic];
+}
+
+function buildPayload(
+  release,
+  canaryRelease = null,
+  stableRelease = release,
+  osArtifacts = [],
+) {
   const tagName = release?.tag_name ?? "unavailable";
   return {
     generatedAt: new Date().toISOString(),
     scripts,
+    storeTargets,
     cdn: {
       tagName,
       appAssetBaseUrl:
@@ -260,11 +655,10 @@ function buildPayload(release, allReleases = [], canaryRelease = null) {
               assetRoot: "packages/homepage/public",
             }),
     },
-    release: buildRelease(release, allReleases),
-    stableRelease: buildRelease(release, allReleases),
-    canaryRelease: canaryRelease
-      ? buildRelease(canaryRelease, allReleases)
-      : null,
+    release: buildRelease(release),
+    stableRelease: buildRelease(stableRelease),
+    canaryRelease: canaryRelease ? buildRelease(canaryRelease) : null,
+    osArtifacts,
   };
 }
 
@@ -279,6 +673,9 @@ export type ReleaseDataDownload = {
   url: string;
   sizeLabel: string;
   note: string;
+  releaseTagName: string;
+  releaseUrl: string;
+  releasePublishedAtLabel: string;
 };
 
 export type ReleaseDataChecksum = {
@@ -300,19 +697,48 @@ export type ReleaseDataScripts = {
   powershell: { url: string; command: string };
 };
 
+export type ReleaseDataStoreTarget = {
+  platform: string;
+  label: string;
+  artifact: string;
+  status: "coming-soon" | "beta" | "available";
+  reviewState: string;
+  rolloutChannel: string;
+  fallbackArtifact: string;
+  url: string | null;
+};
+
 export type ReleaseDataCdn = {
   tagName: string;
   appAssetBaseUrl: string;
   homepageAssetBaseUrl: string;
 };
 
+export type OsArtifact = {
+  id: string;
+  label: string;
+  description: string;
+  platform: 'linux' | 'android' | 'macos' | 'windows' | 'cross-platform';
+  kind: 'iso' | 'deb' | 'ova' | 'apk' | 'desktop-app';
+  channel: 'stable' | 'beta' | 'nightly';
+  version: string;
+  downloadUrl: string | null;
+  checksumUrl: string | null;
+  sizeBytes: number | null;
+  sha256: string | null;
+  releaseNotesUrl: string | null;
+  requiresHardware?: string;
+};
+
 export type ReleaseDataPayload = {
   generatedAt: string;
   scripts: ReleaseDataScripts;
+  storeTargets: ReleaseDataStoreTarget[];
   cdn: ReleaseDataCdn;
   release: ReleaseDataRelease;
   stableRelease: ReleaseDataRelease;
   canaryRelease: ReleaseDataRelease | null;
+  osArtifacts: OsArtifact[];
 };
 
 `;
@@ -369,11 +795,16 @@ async function main() {
     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));
+    // Prefer canary for android-apk lookup since it consistently ships APK assets.
+    const apkSourceRelease = canaryRelease ?? primaryRelease;
+    const osArtifacts = await buildOsArtifacts(apkSourceRelease);
+    await writePayload(
+      buildPayload(primaryRelease, canaryRelease, stableRelease, osArtifacts),
+    );
     const tag = primaryRelease?.tag_name ?? "no published release";
     const canaryTag = canaryRelease?.tag_name;
     console.log(
-      `homepage release data: stable=${tag}${canaryTag ? `, canary=${canaryTag}` : ""}`,
+      `homepage release data: stable=${tag}${canaryTag ? `, canary=${canaryTag}` : ""}, osArtifacts=${osArtifacts.length}`,
     );
   } catch (error) {
     if (existsSync(OUTPUT_PATH)) {
@@ -383,7 +814,8 @@ async function main() {
       return;
     }
 
-    await writePayload(buildPayload(null));
+    const fallbackOsArtifacts = await buildOsArtifacts(null);
+    await writePayload(buildPayload(null, null, null, fallbackOsArtifacts));
     console.warn(
       `homepage release data refresh failed, wrote fallback file: ${error instanceof Error ? error.message : String(error)}`,
     );

package/security/agent-vault-id.d.ts

@@ -3,7 +3,7 @@ import type { SecureStoreSecretKind } from "./platform-secure-store";
 export declare const ELIZA_AGENT_VAULT_SERVICE = "ai.elizaos.agent.vault";
 /**
  * Canonical state directory for this process. Mirrors the canonical
- * `MILADY_STATE_DIR` > `ELIZA_STATE_DIR` > `~/.${namespace}` precedence
+ * `ELIZA_STATE_DIR` > XDG state home precedence
  * and uses `realpathSync` when the path exists so symlinks normalize
  * consistently.
  */

package/security/agent-vault-id.js

@@ -6,7 +6,7 @@ import { resolveStateDir } from "@elizaos/core";
 export const ELIZA_AGENT_VAULT_SERVICE = "ai.elizaos.agent.vault";
 /**
  * Canonical state directory for this process. Mirrors the canonical
- * `MILADY_STATE_DIR` > `ELIZA_STATE_DIR` > `~/.${namespace}` precedence
+ * `ELIZA_STATE_DIR` > XDG state home precedence
  * and uses `realpathSync` when the path exists so symlinks normalize
  * consistently.
  */

package/security/hydrate-wallet-keys-from-platform-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrate-wallet-keys-from-platform-store.d.ts","sourceRoot":"","sources":["../../../../../src/security/hydrate-wallet-keys-from-platform-store.ts"],"names":[],"mappings":"AAoEA;;;;;;;;;;GAUG;AACH,wBAAsB,4CAA4C,IAAI,OAAO,CAAC,IAAI,CAAC,CAkDlF"}
+{"version":3,"file":"hydrate-wallet-keys-from-platform-store.d.ts","sourceRoot":"","sources":["../../../../../src/security/hydrate-wallet-keys-from-platform-store.ts"],"names":[],"mappings":"AA6EA;;;;;;;;;;GAUG;AACH,wBAAsB,4CAA4C,IAAI,OAAO,CAAC,IAAI,CAAC,CAkDlF"}