fix: harden beta packaging checks

Author: Shaw

.github/workflows/mobile-build-smoke.yml

@@ -67,10 +67,9 @@ jobs:
           echo "Built app at: $APP_PATH"
           BUNDLE_ID=$(/usr/libexec/PlistBuddy -c "Print :CFBundleIdentifier" "$APP_PATH/Info.plist")
           echo "Bundle ID: $BUNDLE_ID"
-          # iOS project under packages/app-core/platforms/ios is currently
-          # ai.elizaos.app. Allow a future eliza brand id alongside it.
+          # Allow the current Capacitor app ID and legacy/beta app IDs.
           case "$BUNDLE_ID" in
-            ai.elizaos.app|ai.elizaos.Eliza) ;;
+            app.eliza|ai.elizaos.app|ai.elizaos.Eliza) ;;
             *)
               echo "ERROR: Unexpected bundle ID: $BUNDLE_ID"
               exit 1

.github/workflows/test-packaging.yml

@@ -206,21 +206,33 @@ jobs:
         run: |
           set -euo pipefail
           ARTIFACTS_DIR="artifacts"
-          for tarball in "$ARTIFACTS_DIR"/*.tgz; do
-            [ -f "$tarball" ] || continue
-            echo "::group::Testing $(basename "$tarball")"
-            TEST_DIR=$(mktemp -d)
-            cd "$TEST_DIR"
-            echo '{"name":"tarball-test","private":true,"type":"module"}' > package.json
-            npm install "$OLDPWD/$tarball" --ignore-scripts 2>&1
-            # Verify the package has a valid entry point
-            PKG_MANIFEST=$(find node_modules/@elizaos -mindepth 2 -maxdepth 2 -name package.json | head -n 1)
-            PKG_NAME=$(node -p "require('$PKG_MANIFEST').name" 2>/dev/null || echo "unknown")
+          tarballs=("$ARTIFACTS_DIR"/*.tgz)
+          if [ ! -f "${tarballs[0]}" ]; then
+            echo "::error::No tarballs found in $ARTIFACTS_DIR"
+            exit 1
+          fi
+
+          TEST_DIR=$(mktemp -d)
+          ROOT_DIR="$PWD"
+          install_paths=()
+          for tarball in "${tarballs[@]}"; do
+            install_paths+=("$ROOT_DIR/$tarball")
+          done
+          cd "$TEST_DIR"
+          echo '{"name":"tarball-test","private":true,"type":"module"}' > package.json
+          npm install "${install_paths[@]}" --ignore-scripts 2>&1
+
+          for tarball in "${tarballs[@]}"; do
+            echo "::group::Checking $(basename "$tarball")"
+            PKG_NAME=$(tar -xOf "$ROOT_DIR/$tarball" package/package.json | node -e "process.stdin.setEncoding('utf8'); let data = ''; process.stdin.on('data', chunk => data += chunk); process.stdin.on('end', () => console.log(JSON.parse(data).name));")
+            PKG_MANIFEST="node_modules/${PKG_NAME}/package.json"
+            test -f "$PKG_MANIFEST"
             echo "Installed: $PKG_NAME"
-            cd "$OLDPWD"
-            rm -rf "$TEST_DIR"
             echo "::endgroup::"
           done
+
+          cd "$ROOT_DIR"
+          rm -rf "$TEST_DIR"
           echo "All JS tarballs passed installation test"
 
       - name: Upload tarball artifacts

packages/app-core/packaging/snap/snapcraft.yaml

@@ -336,12 +336,12 @@ parts:
       node "$APP_CORE_SCRIPTS_DIR/ensure-shared-i18n-data.mjs"
 
       # patch-deps removes @types packages from node_modules and Bun's cache.
-      # Preserve the two packages needed by declaration builds outside
-      # node_modules before patch-deps runs.
+      # Preserve the packages needed by declaration builds outside node_modules
+      # before patch-deps runs.
       SNAP_BUILD_TYPES_DIR=".snap-build-types"
       rm -rf "$SNAP_BUILD_TYPES_DIR"
       mkdir -p "$SNAP_BUILD_TYPES_DIR/@types"
-      for type_pkg in node bun; do
+      for type_pkg in node bun fs-extra fast-redact markdown-it jsonfile linkify-it mdurl; do
         type_target=""
         if [ -d "node_modules/@types/$type_pkg" ]; then
           type_target="node_modules/@types/$type_pkg"
@@ -366,7 +366,7 @@ parts:
       # needs for the build, then remove them again before copying node_modules
       # into the snap runtime payload.
       mkdir -p node_modules/@types
-      for type_pkg in node bun; do
+      for type_pkg in node bun fs-extra fast-redact markdown-it jsonfile linkify-it mdurl; do
         type_target="$SNAP_BUILD_TYPES_DIR/@types/$type_pkg"
         if [ ! -d "$type_target" ]; then
           echo "Failed to restore @types/$type_pkg after patch-deps" >&2

packages/app-core/scripts/pack-upstreams.mjs

@@ -6,7 +6,13 @@
  */
 
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+} from "node:fs";
 import path from "node:path";
 import { resolveRepoRootFromImportMeta } from "./lib/repo-root.mjs";
 
@@ -18,9 +24,10 @@ const ELIZA_ROOT = existsSync(
   ? ROOT
   : path.join(ROOT, "eliza");
 
-// Target packages to pack. These are the package boundary that Milady consumes
-// when it runs without a repo-local eliza checkout.
-const TARGETS = [
+// Seed packages to pack. Their local workspace dependencies are added
+// automatically so PR tarball install tests do not depend on already-published
+// beta packages.
+const SEED_TARGETS = [
   { label: "@elizaos/core", dir: path.join(ELIZA_ROOT, "packages", "core") },
   {
     label: "@elizaos/shared",
@@ -78,6 +85,195 @@ function readPackageJson(dir) {
   }
 }
 
+function collectWorkspacePackages(root) {
+  const packageRoots = [
+    path.join(root, "packages"),
+    path.join(root, "plugins"),
+    path.join(root, "cloud", "packages"),
+  ];
+  const packages = new Map();
+
+  for (const packageRoot of packageRoots) {
+    walk(packageRoot, (entryPath) => {
+      if (path.basename(entryPath) !== "package.json") {
+        return;
+      }
+      const pkgJson = readPackageJson(path.dirname(entryPath));
+      if (
+        !pkgJson ||
+        pkgJson.private === true ||
+        typeof pkgJson.name !== "string" ||
+        typeof pkgJson.version !== "string"
+      ) {
+        return;
+      }
+      if (!packages.has(pkgJson.name)) {
+        packages.set(pkgJson.name, {
+          label: pkgJson.name,
+          dir: path.dirname(entryPath),
+        });
+      }
+    });
+  }
+
+  for (const target of SEED_TARGETS) {
+    packages.set(target.label, target);
+  }
+
+  return packages;
+}
+
+function walk(dirPath, visit) {
+  let entries;
+  try {
+    entries = readdirSync(dirPath, { withFileTypes: true });
+  } catch (error) {
+    if (
+      error &&
+      typeof error === "object" &&
+      "code" in error &&
+      error.code === "ENOENT"
+    ) {
+      return;
+    }
+    throw error;
+  }
+
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (
+        [
+          "node_modules",
+          "dist",
+          ".git",
+          ".turbo",
+          "android",
+          "ios",
+          "build",
+        ].includes(entry.name)
+      ) {
+        continue;
+      }
+      walk(entryPath, visit);
+      continue;
+    }
+    visit(entryPath);
+  }
+}
+
+function collectLocalDependencyNames(pkgJson, workspacePackages) {
+  const names = new Set();
+  for (const sectionName of ["dependencies", "optionalDependencies"]) {
+    const section = pkgJson[sectionName];
+    if (!section || typeof section !== "object") {
+      continue;
+    }
+    for (const [name, spec] of Object.entries(section)) {
+      if (
+        typeof spec === "string" &&
+        spec.startsWith("workspace:") &&
+        workspacePackages.has(name)
+      ) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
+
+function resolveTargets() {
+  const workspacePackages = collectWorkspacePackages(ELIZA_ROOT);
+  const targets = new Map();
+  const queue = [...SEED_TARGETS.map((target) => target.label)];
+
+  for (let index = 0; index < queue.length; index += 1) {
+    const label = queue[index];
+    if (targets.has(label)) {
+      continue;
+    }
+
+    const target = workspacePackages.get(label);
+    if (!target) {
+      throw new Error(`[pack-upstreams] Missing local workspace package ${label}`);
+    }
+
+    const pkgJson = readPackageJson(target.dir);
+    if (!pkgJson) {
+      throw new Error(`[pack-upstreams] No package.json found in ${target.dir}`);
+    }
+
+    targets.set(label, target);
+    for (const dependencyName of collectLocalDependencyNames(
+      pkgJson,
+      workspacePackages,
+    )) {
+      if (!targets.has(dependencyName)) {
+        queue.push(dependencyName);
+      }
+    }
+  }
+
+  return {
+    targets: [...targets.values()],
+    workspacePackages,
+  };
+}
+
+function workspaceSpecToVersion(spec, version) {
+  if (spec === "workspace:^") {
+    return `^${version}`;
+  }
+  if (spec === "workspace:~") {
+    return `~${version}`;
+  }
+  return version;
+}
+
+function rewriteWorkspaceDependencies(packDir, pkgJson, workspacePackages) {
+  let changed = false;
+  const nextPkgJson = structuredClone(pkgJson);
+  for (const sectionName of [
+    "dependencies",
+    "optionalDependencies",
+    "peerDependencies",
+    "devDependencies",
+  ]) {
+    const section = nextPkgJson[sectionName];
+    if (!section || typeof section !== "object") {
+      continue;
+    }
+    for (const [name, spec] of Object.entries(section)) {
+      if (typeof spec !== "string" || !spec.startsWith("workspace:")) {
+        continue;
+      }
+      const workspacePackage = workspacePackages.get(name);
+      if (!workspacePackage) {
+        throw new Error(
+          `[pack-upstreams] ${pkgJson.name} depends on unknown workspace package ${name}`,
+        );
+      }
+      const dependencyPkgJson = readPackageJson(workspacePackage.dir);
+      if (!dependencyPkgJson?.version) {
+        throw new Error(
+          `[pack-upstreams] Could not resolve version for workspace package ${name}`,
+        );
+      }
+      section[name] = workspaceSpecToVersion(spec, dependencyPkgJson.version);
+      changed = true;
+    }
+  }
+
+  if (!changed) {
+    return null;
+  }
+
+  const packageJsonPath = path.join(packDir, "package.json");
+  const originalPackageJson = readFileSync(packageJsonPath, "utf8");
+  writeFileSync(packageJsonPath, `${JSON.stringify(nextPkgJson, null, 2)}\n`);
+  return () => writeFileSync(packageJsonPath, originalPackageJson);
+}
+
 function packageTarballName(pkgJson) {
   return `${pkgJson.name.replace(/^@/, "").replace("/", "-")}-${pkgJson.version}.tgz`;
 }
@@ -100,7 +296,14 @@ async function packUpstreams() {
     mkdirSync(ARTIFACTS_DIR, { recursive: true });
   }
 
-  for (const target of TARGETS) {
+  const { targets, workspacePackages } = resolveTargets();
+  console.log(
+    `[pack-upstreams] Packing ${targets.length} package(s): ${targets
+      .map((target) => target.label)
+      .join(", ")}`,
+  );
+
+  for (const target of targets) {
     const pkgDir = target.dir;
     if (!existsSync(pkgDir)) {
       throw new Error(
@@ -153,11 +356,20 @@ async function packUpstreams() {
     console.log(
       `[pack-upstreams] Packing ${packPkgJson.name} from ${packDir}...`,
     );
-    await runCommand(
-      "npm",
-      ["pack", "--pack-destination", ARTIFACTS_DIR],
+    const restorePackageJson = rewriteWorkspaceDependencies(
       packDir,
+      packPkgJson,
+      workspacePackages,
     );
+    try {
+      await runCommand(
+        "npm",
+        ["pack", "--pack-destination", ARTIFACTS_DIR],
+        packDir,
+      );
+    } finally {
+      restorePackageJson?.();
+    }
 
     if (!existsSync(destTarballPath)) {
       throw new Error(

packages/app-core/src/components/shell/RuntimeGate.cloud-provisioning.test.tsx

@@ -30,6 +30,7 @@ const {
   clientMock: {
     getCloudCompatAgents: vi.fn(),
     getCloudCompatAgent: vi.fn(),
+    getCloudCompatAgentStatus: vi.fn(),
     createCloudCompatAgent: vi.fn(),
     provisionCloudCompatAgent: vi.fn(),
     getCloudCompatJobStatus: vi.fn(),
@@ -297,6 +298,18 @@ describe("RuntimeGate cloud provisioning startup handoff", () => {
       success: true,
       data: RUNNING_AGENT,
     });
+    clientMock.getCloudCompatAgentStatus.mockResolvedValue({
+      success: true,
+      data: {
+        status: "running",
+        lastHeartbeat: null,
+        bridgeUrl: "https://agent-1.elizacloud.ai",
+        webUiUrl: null,
+        currentNode: null,
+        suspendedReason: null,
+        databaseStatus: "ready",
+      },
+    });
     clientMock.createCloudCompatAgent.mockResolvedValue({
       success: true,
       data: { agentId: "agent-1" },

packages/native-plugins/activity-tracker/native/macos/.npmignore

@@ -0,0 +1,2 @@
+# The compiled collector is intentionally shipped in the npm package.
+!activity-collector