@elizaos/app-core 2.0.3-beta.2 → 2.0.3-beta.4

package/scripts/lib/agent-source-watcher.mjs

@@ -20,7 +20,6 @@ import path from "node:path";
 export const HOT_RELOAD_FRONTEND_PACKAGES = new Set([
   "ui",
   "app",
-  "cloud-frontend",
   "os-homepage",
   "homepage",
   "docs",

package/scripts/lib/artifact-staleness.d.mts

@@ -0,0 +1,33 @@
+/**
+ * Type declarations for `artifact-staleness.mjs` — generic source-vs-artifact
+ * staleness used by the iOS MTP slice, iOS agent bundle, and desktop runtime
+ * package reuse gates (issue #9309).
+ */
+
+export function maxMtimeUnder(
+  dir: string,
+  opts?: {
+    exclude?: Set<string>;
+    exts?: Set<string> | null;
+    maxDepth?: number;
+  },
+): number;
+
+export function fileMtime(filePath: string): number;
+
+export interface ArtifactStaleness {
+  stale: boolean;
+  reason: string;
+  artifactMtime: number;
+  newestSourceMtime: number;
+  newestSource: string | null;
+}
+
+export function artifactStaleness(
+  artifactPath: string,
+  opts?: {
+    sourceDirs?: string[];
+    sourceFiles?: string[];
+    exts?: Set<string> | null;
+  },
+): ArtifactStaleness;

package/scripts/lib/artifact-staleness.mjs

@@ -0,0 +1,122 @@
+/**
+ * Generic source-vs-artifact staleness check (issue #9309).
+ *
+ * Several on-device build inputs are cached and reused across builds (the iOS
+ * llama.cpp MTP slice, the iOS agent bundle, desktop runtime packages). Each had
+ * a presence-only reuse gate that could silently reuse a STALE artifact after
+ * its sources changed. This module turns "reuse when present" into "reuse only
+ * when the artifact is newer than every source it was built from", so a changed
+ * input forces a rebuild instead of shipping old code.
+ *
+ * mtime is the right granularity here: these artifacts are heavy native/bundle
+ * builds keyed off large source trees, and the build host writes both, so an
+ * artifact older than any source file is unambiguously stale.
+ */
+import fs from "node:fs";
+import path from "node:path";
+
+const DEFAULT_EXCLUDE = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".git",
+  ".turbo",
+  "out",
+]);
+
+/**
+ * Largest mtime (ms) of any file under `dir`, skipping build/dep dirs.
+ * @param {string} dir
+ * @param {{ exclude?: Set<string>, exts?: Set<string>|null, maxDepth?: number }} [opts]
+ */
+export function maxMtimeUnder(
+  dir,
+  { exclude = DEFAULT_EXCLUDE, exts = null, maxDepth = 25 } = {},
+) {
+  let max = 0;
+  const walk = (current, depth) => {
+    if (depth > maxDepth) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (exclude.has(entry.name)) continue;
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full, depth + 1);
+        continue;
+      }
+      if (exts && !exts.has(path.extname(entry.name))) continue;
+      try {
+        max = Math.max(max, fs.statSync(full).mtimeMs);
+      } catch {
+        /* ignore unreadable entries */
+      }
+    }
+  };
+  if (fs.existsSync(dir)) walk(dir, 0);
+  return max;
+}
+
+/** mtime (ms) of a single file, or 0 if missing/unreadable. */
+export function fileMtime(filePath) {
+  try {
+    return fs.statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Is `artifactPath` stale relative to its source dirs/files?
+ *
+ * @param {string} artifactPath the built artifact (or its marker file)
+ * @param {{ sourceDirs?: string[], sourceFiles?: string[], exts?: Set<string>|null }} [opts]
+ * @returns {{ stale: boolean, reason: string, artifactMtime: number,
+ *             newestSourceMtime: number, newestSource: string|null }}
+ */
+export function artifactStaleness(
+  artifactPath,
+  { sourceDirs = [], sourceFiles = [], exts = null } = {},
+) {
+  const artifactMtime = fileMtime(artifactPath);
+  if (!artifactMtime) {
+    return {
+      stale: true,
+      reason: `artifact missing: ${artifactPath}`,
+      artifactMtime: 0,
+      newestSourceMtime: 0,
+      newestSource: null,
+    };
+  }
+  let newestSourceMtime = 0;
+  let newestSource = null;
+  const consider = (mtime, label) => {
+    if (mtime > newestSourceMtime) {
+      newestSourceMtime = mtime;
+      newestSource = label;
+    }
+  };
+  for (const dir of sourceDirs) consider(maxMtimeUnder(dir, { exts }), dir);
+  for (const file of sourceFiles) consider(fileMtime(file), file);
+
+  if (newestSourceMtime > artifactMtime) {
+    return {
+      stale: true,
+      reason: `source newer than artifact (${newestSource})`,
+      artifactMtime,
+      newestSourceMtime,
+      newestSource,
+    };
+  }
+  return {
+    stale: false,
+    reason: "fresh",
+    artifactMtime,
+    newestSourceMtime,
+    newestSource,
+  };
+}

package/scripts/lib/artifact-staleness.test.mts

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import {
+  artifactStaleness,
+  fileMtime,
+  maxMtimeUnder,
+} from "./artifact-staleness.mjs";
+
+let tmp: string;
+
+beforeEach(() => {
+  tmp = fs.mkdtempSync(path.join(os.tmpdir(), "artifact-staleness-"));
+});
+
+afterEach(() => {
+  fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+function touch(file: string, mtimeMs: number) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, "x");
+  fs.utimesSync(file, mtimeMs / 1000, mtimeMs / 1000);
+}
+
+describe("maxMtimeUnder", () => {
+  it("returns the newest file mtime and skips build/dep dirs", () => {
+    touch(path.join(tmp, "src", "a.ts"), 1_000_000);
+    touch(path.join(tmp, "src", "nested", "b.ts"), 3_000_000);
+    touch(path.join(tmp, "node_modules", "junk.js"), 9_000_000);
+    touch(path.join(tmp, "dist", "out.js"), 9_000_000);
+    expect(maxMtimeUnder(path.join(tmp, "src"))).toBe(3_000_000);
+  });
+
+  it("honors an extension filter", () => {
+    touch(path.join(tmp, "src", "a.ts"), 2_000_000);
+    touch(path.join(tmp, "src", "a.png"), 5_000_000);
+    expect(
+      maxMtimeUnder(path.join(tmp, "src"), { exts: new Set([".ts"]) }),
+    ).toBe(2_000_000);
+  });
+
+  it("returns 0 for a missing dir", () => {
+    expect(maxMtimeUnder(path.join(tmp, "nope"))).toBe(0);
+  });
+});
+
+describe("fileMtime", () => {
+  it("returns the mtime of an existing file and 0 for a missing one", () => {
+    touch(path.join(tmp, "f"), 4_000_000);
+    expect(fileMtime(path.join(tmp, "f"))).toBe(4_000_000);
+    expect(fileMtime(path.join(tmp, "missing"))).toBe(0);
+  });
+});
+
+describe("artifactStaleness", () => {
+  it("is stale when the artifact is missing", () => {
+    const result = artifactStaleness(path.join(tmp, "art"), {
+      sourceDirs: [tmp],
+    });
+    expect(result.stale).toBe(true);
+    expect(result.reason).toMatch(/artifact missing/);
+  });
+
+  it("is stale when a source dir is newer than the artifact", () => {
+    touch(path.join(tmp, "artifact"), 2_000_000);
+    touch(path.join(tmp, "src", "code.ts"), 5_000_000);
+    const result = artifactStaleness(path.join(tmp, "artifact"), {
+      sourceDirs: [path.join(tmp, "src")],
+    });
+    expect(result.stale).toBe(true);
+    expect(result.reason).toMatch(/source newer than artifact/);
+    expect(result.newestSource).toBe(path.join(tmp, "src"));
+  });
+
+  it("is stale when a source FILE is newer than the artifact", () => {
+    touch(path.join(tmp, "artifact"), 2_000_000);
+    touch(path.join(tmp, "build-script.mjs"), 6_000_000);
+    const result = artifactStaleness(path.join(tmp, "artifact"), {
+      sourceFiles: [path.join(tmp, "build-script.mjs")],
+    });
+    expect(result.stale).toBe(true);
+  });
+
+  it("is fresh when the artifact is newer than all sources", () => {
+    touch(path.join(tmp, "src", "code.ts"), 2_000_000);
+    touch(path.join(tmp, "build-script.mjs"), 1_000_000);
+    touch(path.join(tmp, "artifact"), 5_000_000);
+    const result = artifactStaleness(path.join(tmp, "artifact"), {
+      sourceDirs: [path.join(tmp, "src")],
+      sourceFiles: [path.join(tmp, "build-script.mjs")],
+    });
+    expect(result.stale).toBe(false);
+    expect(result.reason).toBe("fresh");
+  });
+});

package/scripts/lib/duet-bridge.mjs

@@ -8,7 +8,7 @@
  *   A.scheduler.sink ── DuetSink(aToB) ──→ PcmRingBuffer ──→ B.micSource.push
  *   B.scheduler.sink ── DuetSink(bToA) ──→ PcmRingBuffer ──→ A.micSource.push
  *
- * The TTS emits 24 kHz mono; the VAD + Qwen3-ASR want 16 kHz mono — one
+ * The TTS emits 24 kHz mono; the VAD + local ASR want 16 kHz mono — one
  * linear-interpolation resample in the `DuetSink`, zero file writes.
  *
  * `DuetSink` also reports the **`peer-utterance-end`** instant: when the

package/scripts/lib/ios-plist-url-scheme.mjs

@@ -0,0 +1,80 @@
+function escapeXmlText(value) {
+  return String(value)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+function insertBeforeRootPlistDictClose(content, insertion) {
+  const rootClose = "\n</dict>\n</plist>";
+  const index = content.lastIndexOf(rootClose);
+  if (index >= 0) {
+    return `${content.slice(0, index)}\n${insertion}${content.slice(index + "\n</dict>".length)}`;
+  }
+  const fallbackIndex = content.lastIndexOf("</dict>");
+  if (fallbackIndex < 0) {
+    throw new Error("Info.plist: could not locate top-level </dict>");
+  }
+  return `${content.slice(0, fallbackIndex)}${insertion}${content.slice(fallbackIndex + "</dict>".length)}`;
+}
+
+function findUrlTypesArrayRange(content) {
+  const keyIndex = content.indexOf("<key>CFBundleURLTypes</key>");
+  if (keyIndex < 0) return null;
+  const openMatch = /<array\b[^>]*>/g;
+  openMatch.lastIndex = keyIndex;
+  const firstOpen = openMatch.exec(content);
+  if (!firstOpen) {
+    throw new Error("Info.plist: CFBundleURLTypes has no array value");
+  }
+
+  const tagRe = /<\/?array\b[^>]*>/g;
+  tagRe.lastIndex = firstOpen.index;
+  let depth = 0;
+  for (let match = tagRe.exec(content); match; match = tagRe.exec(content)) {
+    if (match[0].startsWith("</")) {
+      depth -= 1;
+      if (depth === 0) return { start: firstOpen.index, close: match.index };
+      if (depth < 0) break;
+    } else {
+      depth += 1;
+    }
+  }
+
+  throw new Error("Info.plist: CFBundleURLTypes array is not closed");
+}
+
+export function ensurePlistUrlScheme(content, urlScheme) {
+  const trimmedScheme = String(urlScheme).trim();
+  if (!trimmedScheme) {
+    throw new Error("Cannot patch iOS Info.plist without a URL scheme");
+  }
+
+  const escapedScheme = escapeXmlText(trimmedScheme);
+  const entry = `
+		<dict>
+			<key>CFBundleURLName</key>
+			<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+			<key>CFBundleURLSchemes</key>
+			<array>
+				<string>${escapedScheme}</string>
+			</array>
+		</dict>`;
+  const urlTypesArrayRange = findUrlTypesArrayRange(content);
+  if (urlTypesArrayRange === null) {
+    return insertBeforeRootPlistDictClose(
+      content,
+      `\t<key>CFBundleURLTypes</key>\n\t<array>${entry}\n\t</array>\n</dict>`,
+    );
+  }
+  const urlTypesContent = content.slice(
+    urlTypesArrayRange.start,
+    urlTypesArrayRange.close,
+  );
+  if (urlTypesContent.includes(`<string>${escapedScheme}</string>`)) {
+    return content;
+  }
+  return `${content.slice(0, urlTypesArrayRange.close)}${entry}${content.slice(urlTypesArrayRange.close)}`;
+}

package/scripts/lib/mobile-build-decisions.mjs

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { artifactStaleness } from "./artifact-staleness.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const appCoreScriptsDir = path.resolve(__dirname, "..");
+
+/**
+ * Brand-separation invariant (issue #9309): the shared canonical Android tree
+ * is used only for the elizaOS app itself. Whitelabel builds use appDir/android
+ * so identity overlays cannot corrupt another brand's native project.
+ */
+export function androidUsesAppDirFor(appId, env = process.env) {
+  return env.ELIZA_ANDROID_USE_APP_DIR === "1" || appId !== "ai.elizaos.app";
+}
+
+const MTP_BUILD_SCRIPT = path.resolve(
+  appCoreScriptsDir,
+  "build-llama-cpp-mtp.mjs",
+);
+
+// The builder derives its repo root from packages/app-core/scripts, not from
+// run-mobile-build's configurable repoRoot. Keep this identical so the
+// staleness gate checks the same source tree the builder compiles.
+export const mtpBuilderRepoRoot = path.resolve(
+  appCoreScriptsDir,
+  "..",
+  "..",
+  "..",
+);
+
+export const MTP_FORK_SRC_CANDIDATES = [
+  process.env.ELIZA_MTP_LLAMA_CPP_SRC?.trim(),
+  path.join(
+    mtpBuilderRepoRoot,
+    "plugins",
+    "plugin-local-inference",
+    "native",
+    "llama.cpp",
+  ),
+  path.join(
+    mtpBuilderRepoRoot,
+    "packages",
+    "native",
+    "ios-deps",
+    "llama.cpp",
+    "src",
+  ),
+].filter(Boolean);
+
+/**
+ * Decide whether a staged MTP slice can be reused or is stale relative to the
+ * fork it was built from.
+ */
+export function mtpSliceReuse(capabilitiesPath, forkSrc, currentRevision) {
+  if (!fs.existsSync(capabilitiesPath)) {
+    return { reusable: false, reason: "no CAPABILITIES.json" };
+  }
+  let recordedRevision = null;
+  try {
+    recordedRevision = JSON.parse(fs.readFileSync(capabilitiesPath, "utf8"))
+      ?.fork?.revision;
+  } catch {
+    return { reusable: false, reason: "unreadable CAPABILITIES.json" };
+  }
+  if (recordedRevision === "unknown") recordedRevision = null;
+  if (
+    recordedRevision &&
+    currentRevision &&
+    recordedRevision !== currentRevision
+  ) {
+    return {
+      reusable: false,
+      reason: `fork revision changed (${recordedRevision} -> ${currentRevision})`,
+    };
+  }
+  if (forkSrc) {
+    const staleness = artifactStaleness(capabilitiesPath, {
+      sourceDirs: [
+        path.join(forkSrc, "ggml"),
+        path.join(forkSrc, "src"),
+        path.join(forkSrc, "common"),
+      ],
+      sourceFiles: [path.join(forkSrc, "CMakeLists.txt"), MTP_BUILD_SCRIPT],
+    });
+    if (staleness.stale) {
+      return { reusable: false, reason: staleness.reason };
+    }
+  }
+  return { reusable: true, reason: "fresh" };
+}
+
+export function mtpForceRebuildRequested(reuse, env = process.env) {
+  return env.ELIZA_IOS_REBUILD_MTP === "1" || !reuse.reusable;
+}

package/scripts/lib/renderer-build-manifest.d.mts

@@ -0,0 +1,65 @@
+/**
+ * Type declarations for `renderer-build-manifest.mjs` — the deterministic build
+ * stamp for the web/renderer bundle (issue #9309). Imported by the vite
+ * `renderer-build-manifest` plugin and the platform build orchestrators.
+ */
+
+export const RENDERER_BUILD_MANIFEST_FILENAME: "eliza-renderer-build.json";
+export const RENDERER_BUILD_MANIFEST_SCHEMA: "elizaos.renderer.build/v1";
+
+export interface RendererBuildManifest {
+  schema: string;
+  buildId: string;
+  indexHtmlSha256: string;
+  assetCount: number;
+  builtAt: string;
+  commit: string | null;
+  variant: string | null;
+  capacitorTarget: string | null;
+  runtimeMode: string | null;
+}
+
+export interface RendererBuildManifestMeta {
+  builtAt?: string;
+  commit?: string | null;
+  variant?: string | null;
+  capacitorTarget?: string | null;
+  runtimeMode?: string | null;
+}
+
+export function computeRendererFingerprint(distDir: string): {
+  buildId: string;
+  indexHtmlSha256: string;
+  assetCount: number;
+};
+
+export function buildRendererManifest(
+  distDir: string,
+  meta?: RendererBuildManifestMeta,
+): RendererBuildManifest;
+
+export function writeRendererBuildManifest(
+  distDir: string,
+  meta?: RendererBuildManifestMeta,
+): RendererBuildManifest;
+
+export function readRendererBuildManifest(
+  dir: string,
+): RendererBuildManifest | null;
+
+export function assertStagedRendererMatchesBuild(
+  freshDistDir: string,
+  stagedDir: string,
+  opts?: { label?: string },
+): RendererBuildManifest;
+
+export function overlayFreshRendererIntoPublic(
+  freshDistDir: string,
+  targetPublicDir: string,
+  opts?: { label?: string },
+): RendererBuildManifest;
+
+export function assertRendererRebuiltSince(
+  distDir: string,
+  opts: { notBefore: number; expectVariant?: string | null; label?: string },
+): RendererBuildManifest;