@elizaos/ui 2.0.0-beta.1 → 2.0.3-beta.2

package/components/apps/internal-tool-apps.js

@@ -0,0 +1,183 @@
+const INTERNAL_TOOL_APPS = [
+    {
+        name: "@elizaos/app-plugin-viewer",
+        displayName: "Plugin Viewer",
+        description: "Inspect installed plugins, connectors, and runtime feature flags.",
+        heroImage: "/app-heroes/plugin-viewer.png",
+        targetTab: "plugins",
+        capabilities: ["plugins", "connectors", "viewer"],
+        order: 1,
+        windowPath: "/apps/plugins",
+    },
+    {
+        name: "@elizaos/app-skills-viewer",
+        displayName: "Skills Viewer",
+        description: "Create, enable, review, and install custom agent skills.",
+        heroImage: "/app-heroes/skills-viewer.png",
+        targetTab: "skills",
+        capabilities: ["skills", "viewer"],
+        order: 2,
+        windowPath: "/apps/skills",
+    },
+    {
+        name: "@elizaos/plugin-training",
+        displayName: "Fine Tuning",
+        description: "Collect training data, inspect trajectories, run Eliza harness evals, benchmark model tiers, and manage fine-tuned models.",
+        heroImage: "/api/apps/hero/training",
+        targetTab: "fine-tuning",
+        capabilities: [
+            "training",
+            "fine-tuning",
+            "trajectories",
+            "datasets",
+            "models",
+            "evals",
+            "benchmarks",
+            "analysis",
+            "data-collection",
+        ],
+        order: 3,
+        windowPath: "/apps/fine-tuning",
+        hasDetailsPage: true,
+    },
+    {
+        name: "@elizaos/app-trajectory-viewer",
+        displayName: "Trajectory Viewer",
+        description: "Inspect LLM call history, prompts, and execution traces.",
+        heroImage: "/app-heroes/trajectory-viewer.png",
+        targetTab: "trajectories",
+        capabilities: ["trajectories", "debug", "viewer"],
+        order: 4,
+        windowPath: "/apps/trajectories",
+    },
+    {
+        name: "@elizaos/app-relationship-viewer",
+        displayName: "Relationship Viewer",
+        description: "Explore cross-channel people, identities, and relationship graphs.",
+        heroImage: "/app-heroes/relationship-viewer.png",
+        targetTab: "relationships",
+        capabilities: ["relationships", "graph", "viewer"],
+        order: 5,
+        windowPath: "/apps/relationships",
+    },
+    {
+        name: "@elizaos/app-memory-viewer",
+        displayName: "Memory Viewer",
+        description: "Browse memory, fact, and extraction activity.",
+        heroImage: "/app-heroes/memory-viewer.png",
+        targetTab: "memories",
+        capabilities: ["memory", "facts", "viewer"],
+        order: 6,
+        windowPath: "/apps/memories",
+    },
+    {
+        name: "@elizaos/plugin-steward-app",
+        displayName: "Steward",
+        description: "Review wallet approvals, transaction history, and signing execution status.",
+        heroImage: "/api/apps/hero/steward",
+        targetTab: "inventory",
+        capabilities: ["wallet", "transactions", "approvals", "trading"],
+        order: 7,
+        windowPath: "/apps/inventory",
+        hasDetailsPage: true,
+    },
+    {
+        name: "@elizaos/app-runtime-debugger",
+        displayName: "Runtime Debugger",
+        description: "Inspect runtime objects, plugin order, providers, and services.",
+        heroImage: "/app-heroes/runtime-debugger.png",
+        targetTab: "runtime",
+        capabilities: ["runtime", "debug", "viewer"],
+        order: 8,
+        windowPath: "/apps/runtime",
+    },
+    {
+        name: "@elizaos/app-database-viewer",
+        displayName: "Database Viewer",
+        description: "Inspect tables, media, vectors, and ad-hoc SQL.",
+        heroImage: "/app-heroes/database-viewer.png",
+        targetTab: "database",
+        capabilities: ["database", "sql", "viewer"],
+        order: 9,
+        windowPath: "/apps/database",
+    },
+    {
+        name: "@elizaos/plugin-elizamaker",
+        displayName: "ElizaMaker",
+        description: "Run drop, mint, whitelist, and verification workflows through the agent surfaces.",
+        heroImage: "/api/apps/hero/elizamaker",
+        targetTab: "chat",
+        capabilities: ["drops", "minting", "whitelist", "verification"],
+        order: 10,
+        windowPath: "/apps/elizamaker",
+        hasDetailsPage: true,
+    },
+    {
+        name: "@elizaos/app-log-viewer",
+        displayName: "Log Viewer",
+        description: "Search runtime and service logs.",
+        heroImage: "/app-heroes/log-viewer.png",
+        targetTab: "logs",
+        capabilities: ["logs", "debug", "viewer"],
+        order: 11,
+        windowPath: "/apps/logs",
+    },
+    {
+        name: "@elizaos/plugin-task-coordinator",
+        displayName: "Automations",
+        description: "Create, inspect, and manage scheduled tasks and workflows.",
+        heroImage: "/api/apps/hero/task-coordinator",
+        targetTab: "tasks",
+        capabilities: ["tasks", "workflows", "automations"],
+        order: 12,
+        windowPath: "/apps/tasks",
+    },
+];
+const INTERNAL_TOOL_APP_BY_NAME = new Map(INTERNAL_TOOL_APPS.map((app) => [app.name, app]));
+export function getInternalToolApps() {
+    return INTERNAL_TOOL_APPS.map((app) => ({
+        name: app.name,
+        displayName: app.displayName,
+        description: app.description,
+        category: "utility",
+        launchType: "local",
+        launchUrl: null,
+        icon: null,
+        heroImage: app.heroImage ?? null,
+        capabilities: app.capabilities,
+        stars: 0,
+        repository: "",
+        latestVersion: null,
+        supports: { v0: false, v1: false, v2: true },
+        npm: {
+            package: app.name,
+            v0Version: null,
+            v1Version: null,
+            v2Version: null,
+        },
+    }));
+}
+export function isInternalToolApp(name) {
+    return INTERNAL_TOOL_APP_BY_NAME.has(name);
+}
+export function getInternalToolAppTargetTab(name) {
+    return INTERNAL_TOOL_APP_BY_NAME.get(name)?.targetTab ?? null;
+}
+export function getInternalToolAppCatalogOrder(name) {
+    return INTERNAL_TOOL_APP_BY_NAME.get(name)?.order ?? Number.MAX_SAFE_INTEGER;
+}
+export function getInternalToolAppWindowPath(name) {
+    return INTERNAL_TOOL_APP_BY_NAME.get(name)?.windowPath ?? null;
+}
+export function getInternalToolAppHasDetailsPage(name) {
+    return INTERNAL_TOOL_APP_BY_NAME.get(name)?.hasDetailsPage === true;
+}
+export function getInternalToolAppDescriptors() {
+    return INTERNAL_TOOL_APPS.map((app) => ({
+        name: app.name,
+        displayName: app.displayName,
+        windowPath: app.windowPath ?? null,
+        hasDetailsPage: app.hasDetailsPage === true,
+        order: app.order,
+    }));
+}

package/components/apps/load-apps-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-apps-catalog.d.ts","sourceRoot":"","sources":["../../../../../../src/components/apps/load-apps-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,eAAe,EAAE,MAAM,WAAW,CAAC;AAQzD;;;;GAIG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAgClE;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAOzD"}

package/components/apps/load-apps-catalog.js

@@ -0,0 +1,51 @@
+import { client } from "../../api/index.js";
+import { writeAppsCache } from "./apps-cache.js";
+import { getInternalToolApps } from "./internal-tool-apps.js";
+import { getAvailableOverlayApps, overlayAppToRegistryInfo, } from "./overlay-app-registry.js";
+/**
+ * Fetch the merged apps catalog used by AppsView. Internal-tool entries are
+ * authoritative — server / overlay duplicates are dropped via first-occurrence
+ * dedup on `name`.
+ */
+export async function loadAppsCatalog() {
+    const serverAppsResult = await client
+        .listApps()
+        .then((apps) => ({ status: "fulfilled", value: apps }))
+        .catch((reason) => ({ status: "rejected", reason }));
+    const serverApps = serverAppsResult.status === "fulfilled" ? serverAppsResult.value : [];
+    // non-transient server list failure is silent; catalog + overlay entries fill the gap
+    let catalogApps;
+    try {
+        catalogApps = [
+            ...getInternalToolApps(),
+            ...(await client.listCatalogApps()),
+        ];
+    }
+    catch {
+        catalogApps = getInternalToolApps();
+    }
+    const overlayDescriptors = getAvailableOverlayApps()
+        .filter((oa) => !serverApps.some((a) => a.name === oa.name))
+        .filter((oa) => !catalogApps.some((a) => a.name === oa.name))
+        .map(overlayAppToRegistryInfo);
+    const seen = new Set();
+    return [...catalogApps, ...overlayDescriptors, ...serverApps].filter((app) => {
+        if (seen.has(app.name))
+            return false;
+        seen.add(app.name);
+        return true;
+    });
+}
+/**
+ * Fire-and-forget prefetch used at hydration so the Apps tab opens warm.
+ * Errors are swallowed — the UI's own loadApps will retry on mount.
+ */
+export async function prefetchAppsCatalog() {
+    try {
+        const apps = await loadAppsCatalog();
+        writeAppsCache(apps);
+    }
+    catch {
+        // prefetch failure is silent; AppsView loads on mount
+    }
+}

package/components/apps/overlay-app-api.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Overlay App API — contract for full-screen overlay applications.
+ *
+ * Any app that renders as a full-screen overlay (like the VRM companion)
+ * implements this interface. The host shell renders the active overlay's
+ * Component and manages lifecycle hooks.
+ */
+import type { ComponentType, ReactElement } from "react";
+/** Context passed to every full-screen overlay app by the host shell. */
+export interface OverlayAppContext {
+    /** Navigate back to the apps tab and close this overlay. */
+    exitToApps: () => void;
+    /** Current UI theme. */
+    uiTheme: "light" | "dark";
+    /** i18n translation function. */
+    t: (key: string, opts?: Record<string, unknown>) => string;
+}
+/**
+ * Full-screen overlay app definition.
+ *
+ * Implement this to create an app that renders as a full-screen overlay
+ * on top of the main shell. The component owns its own resources and
+ * lifecycle — load assets on mount, dispose on unmount.
+ */
+export interface OverlayApp {
+    /** Unique app identifier (npm-style, e.g. "@elizaos/plugin-companion"). */
+    readonly name: string;
+    /** Display name shown in the apps catalog. */
+    readonly displayName: string;
+    /** Short description for the catalog card. */
+    readonly description: string;
+    /** Category for catalog filtering. */
+    readonly category: string;
+    /** Optional icon URL. */
+    readonly icon: string | null;
+    /** Optional hero image shown in app cards and chat widgets. */
+    readonly heroImage?: string | null;
+    /**
+     * When true, the app should only appear in the catalog on ElizaOS Android.
+     * Apps that wrap Android-only Capacitor native plugins (WiFi, Contacts,
+     * Phone) set this so they are hidden on stock Android, iOS, desktop, and
+     * web. Stock Android APKs do not expose these privileged OS-control surfaces.
+     *
+     * The platform check is performed by `getAvailableOverlayApps()` in
+     * `overlay-app-registry.ts`; the registry itself accepts any platform's
+     * registrations so server-side rendering and tests don't have to mock
+     * Capacitor.
+     */
+    readonly androidOnly?: boolean;
+    /**
+     * React component rendered as the full-screen overlay.
+     * Receives context with exit callback, theme, and i18n.
+     * Must handle its own resource lifecycle (load on mount, dispose on unmount).
+     *
+     * Provide EITHER `Component` (eager) OR `loader` (lazy). Prefer `loader` so
+     * the app's component tree is only fetched when the window mounts; this
+     * keeps the heavy per-app code out of the main entry chunk.
+     */
+    readonly Component?: (props: OverlayAppContext) => ReactElement;
+    /**
+     * Dynamic-import loader for the overlay component. When present, the host
+     * shell wraps the resolved component in `React.lazy()` + `<Suspense>` so the
+     * app's bundle is split out of the registration module.
+     */
+    readonly loader?: () => Promise<{
+        default: ComponentType<OverlayAppContext>;
+        cleanup?: () => void | Promise<void>;
+    }>;
+    /**
+     * Called immediately before the component mounts.
+     * Use for resource prefetching (e.g. VRM assets).
+     */
+    onLaunch?(): void | Promise<void>;
+    /**
+     * Called after the component unmounts.
+     * Use for final resource cleanup beyond what component unmount handles.
+     */
+    onStop?(): void | Promise<void>;
+}
+//# sourceMappingURL=overlay-app-api.d.ts.map

package/components/apps/overlay-app-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-app-api.d.ts","sourceRoot":"","sources":["../../../../../../src/components/apps/overlay-app-api.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,OAAO,CAAC;AAEzD,yEAAyE;AACzE,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,wBAAwB;IACxB,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,iCAAiC;IACjC,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC;CAC5D;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8CAA8C;IAC9C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,sCAAsC;IACtC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,yBAAyB;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;;OAQG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,YAAY,CAAC;IAChE;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,OAAO,CAAC;QAC9B,OAAO,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;QAC1C,OAAO,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACtC,CAAC,CAAC;IACH;;;OAGG;IACH,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC;;;OAGG;IACH,MAAM,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC"}

package/components/apps/overlay-app-registry.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Overlay App Registry — simple registry for full-screen overlay apps.
+ *
+ * Apps register here at module scope. The host shell and apps catalog
+ * query the registry to discover and launch overlay apps.
+ */
+import type { RegistryAppInfo } from "../../api";
+import type { OverlayApp } from "./overlay-app-api";
+/** Register an overlay app. Call at module scope. */
+export declare function registerOverlayApp(app: OverlayApp): void;
+/** Look up a registered overlay app by name. */
+export declare function getOverlayApp(name: string): OverlayApp | undefined;
+/** Get all registered overlay apps. */
+export declare function getAllOverlayApps(): OverlayApp[];
+/**
+ * Get overlay apps that are available on the current platform. Filters
+ * out `androidOnly: true` apps unless this is an AOSP Eliza-derived Android
+ * build (ElizaOS or any white-label fork). Used by the apps
+ * catalog UI so stock Android, iOS, desktop, and web users don't see
+ * privileged OS-control tiles that launch into permanent error states.
+ *
+ * AOSP detection: the framework's `MainActivity.applyElizaOSUserAgentSuffix`
+ * appends an `ElizaOS/<tag>` token to the WebView UA when `ro.elizaos.product`
+ * is set by the product makefile. Every Eliza-derived AOSP image carries this
+ * marker; white-label brands layer additional brand-specific
+ * markers on top via `app.config.ts > android.userAgentMarkers`. Stock Android
+ * APKs leave the UA untouched.
+ *
+ * Platform detection: when `Capacitor.getPlatform()` is available it is
+ * preferred; otherwise the user-agent is inspected. Tests can pass an
+ * explicit context.
+ */
+export interface OverlayAppAvailabilityContext {
+    platform?: string;
+    /**
+     * True when this is an AOSP Eliza-derived Android build (any fork). When
+     * unspecified, derived from `userAgent` by checking for the framework
+     * `ElizaOS/<tag>` marker.
+     */
+    aospAndroid?: boolean;
+    userAgent?: string;
+}
+export declare function getAvailableOverlayApps(context?: string | OverlayAppAvailabilityContext): OverlayApp[];
+/**
+ * True when running on an AOSP Eliza-derived Android build (ElizaOS or any
+ * white-label fork). Tests may pass an explicit context. Shared with
+ * `catalog-loader.ts` so it can apply the same gate to installed/static apps,
+ * not just overlay apps that happen to be registered already.
+ */
+export declare function isAospAndroid(context?: OverlayAppAvailabilityContext): boolean;
+/** Check if an app name belongs to a registered overlay app. */
+export declare function isOverlayApp(name: string): boolean;
+/** Convert an OverlayApp to a RegistryAppInfo for the apps catalog. */
+export declare function overlayAppToRegistryInfo(app: OverlayApp): RegistryAppInfo;
+//# sourceMappingURL=overlay-app-registry.d.ts.map

package/components/apps/overlay-app-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-app-registry.d.ts","sourceRoot":"","sources":["../../../../../../src/components/apps/overlay-app-registry.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAkCpD,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,IAAI,CAExD;AAED,gDAAgD;AAChD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAElE;AAED,uCAAuC;AACvC,wBAAgB,iBAAiB,IAAI,UAAU,EAAE,CAEhD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,uBAAuB,CACrC,OAAO,GACH,MAAM,GACN,6BAAkE,GACrE,UAAU,EAAE,CAUd;AAyCD;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,GAAE,6BAAkC,GAC1C,OAAO,CAKT;AAED,gEAAgE;AAChE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED,uEAAuE;AACvE,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,UAAU,GAAG,eAAe,CAsBzE"}

package/components/apps/overlay-app-registry.js

@@ -0,0 +1,119 @@
+/**
+ * Overlay App Registry — simple registry for full-screen overlay apps.
+ *
+ * Apps register here at module scope. The host shell and apps catalog
+ * query the registry to discover and launch overlay apps.
+ */
+import { userAgentHasElizaOSMarker } from "../../platform/aosp-user-agent.js";
+const OVERLAY_APP_REGISTRY_KEY = "__elizaosOverlayAppRegistry__";
+// Anchor the registry on the real browser `window` when present, falling back
+// to `globalThis`. The app build can hand a duplicated or shimmed `globalThis`
+// to different chunks (Node-builtin shims + the `global: globalThis` define),
+// so the copy a plugin uses to REGISTER an app and the copy the shell uses to
+// READ it can otherwise see different `globalThis` objects — stranding the
+// registration on a Map the reader never looks at. `window` is the single
+// object every browser chunk shares. Resolve the host (and the Map) on every
+// access — never freeze a Map reference at module scope — so all copies of this
+// module converge on one shared registry regardless of evaluation order.
+function getOverlayRegistryHost() {
+    return (typeof window !== "undefined"
+        ? window
+        : globalThis);
+}
+function getOverlayRegistry() {
+    const host = getOverlayRegistryHost();
+    const existing = host[OVERLAY_APP_REGISTRY_KEY];
+    if (existing) {
+        return existing;
+    }
+    const next = new Map();
+    host[OVERLAY_APP_REGISTRY_KEY] = next;
+    return next;
+}
+/** Register an overlay app. Call at module scope. */
+export function registerOverlayApp(app) {
+    getOverlayRegistry().set(app.name, app);
+}
+/** Look up a registered overlay app by name. */
+export function getOverlayApp(name) {
+    return getOverlayRegistry().get(name);
+}
+/** Get all registered overlay apps. */
+export function getAllOverlayApps() {
+    return Array.from(getOverlayRegistry().values());
+}
+export function getAvailableOverlayApps(context = detectOverlayAvailabilityContext()) {
+    const availability = typeof context === "string"
+        ? { platform: context, aospAndroid: false }
+        : normalizeOverlayAvailabilityContext(context);
+    const canShowAndroidOnly = availability.platform === "android" && availability.aospAndroid === true;
+    return getAllOverlayApps().filter((app) => canShowAndroidOnly || app.androidOnly !== true);
+}
+function normalizeOverlayAvailabilityContext(context) {
+    const userAgent = context.userAgent ??
+        (typeof navigator !== "undefined" ? navigator.userAgent : "");
+    const platform = context.platform ?? detectPlatformForCatalog(userAgent);
+    return {
+        platform,
+        aospAndroid: context.aospAndroid ??
+            (platform === "android" && userAgentHasElizaOSMarker(userAgent)),
+        userAgent,
+    };
+}
+function detectOverlayAvailabilityContext() {
+    const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+    const platform = detectPlatformForCatalog(userAgent);
+    return {
+        platform,
+        aospAndroid: platform === "android" && userAgentHasElizaOSMarker(userAgent),
+        userAgent,
+    };
+}
+function detectPlatformForCatalog(userAgent) {
+    const cap = globalThis.Capacitor;
+    const fromCap = cap?.getPlatform?.();
+    if (fromCap)
+        return fromCap;
+    if (/Android/i.test(userAgent)) {
+        return "android";
+    }
+    return "web";
+}
+/**
+ * True when running on an AOSP Eliza-derived Android build (ElizaOS or any
+ * white-label fork). Tests may pass an explicit context. Shared with
+ * `catalog-loader.ts` so it can apply the same gate to installed/static apps,
+ * not just overlay apps that happen to be registered already.
+ */
+export function isAospAndroid(context = {}) {
+    const availability = normalizeOverlayAvailabilityContext(context);
+    return (availability.platform === "android" && availability.aospAndroid === true);
+}
+/** Check if an app name belongs to a registered overlay app. */
+export function isOverlayApp(name) {
+    return getOverlayRegistry().has(name);
+}
+/** Convert an OverlayApp to a RegistryAppInfo for the apps catalog. */
+export function overlayAppToRegistryInfo(app) {
+    return {
+        name: app.name,
+        displayName: app.displayName,
+        description: app.description,
+        category: app.category,
+        launchType: "overlay",
+        launchUrl: null,
+        icon: app.icon,
+        heroImage: app.heroImage ?? null,
+        capabilities: [],
+        stars: 0,
+        repository: "",
+        latestVersion: null,
+        supports: { v0: false, v1: false, v2: true },
+        npm: {
+            package: app.name,
+            v0Version: null,
+            v1Version: null,
+            v2Version: null,
+        },
+    };
+}

package/components/apps/provenance.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Shared provenance detection for apps and plugins.
+ *
+ * Apps (`RegistryAppInfo`) and plugins (`PluginInfo`) both expose the same
+ * `thirdParty` / `builtIn` / `firstParty` / `origin` / `support` fields, and the
+ * four UI surfaces that display provenance badges all derive the same four
+ * booleans from those fields. Those callsites differ in label casing, badge
+ * shape, and "app" vs "package" copy — but the underlying detection and the
+ * tooltip text are identical, and live here as the single source of truth.
+ *
+ * Callers continue to format their own labels/badges (Title vs lowercase,
+ * `className` vs `tone`) — only the detection and the tooltip are shared.
+ */
+export interface ProvenanceSource {
+    thirdParty?: boolean;
+    builtIn?: boolean;
+    firstParty?: boolean;
+    origin?: string;
+    support?: string;
+}
+export interface ProvenanceFlags {
+    isThirdParty: boolean;
+    isBuiltIn: boolean;
+    isFirstParty: boolean;
+    isCommunity: boolean;
+}
+export declare function getProvenanceFlags(source: ProvenanceSource): ProvenanceFlags;
+/**
+ * Tooltip text shown on provenance badges.
+ *
+ * `noun` differentiates the copy used by the apps catalog ("app") from the
+ * copy used by the plugin/connector surfaces ("package"). Both surfaces have
+ * always shown subtly different wording — preserved here intentionally.
+ */
+export declare function getProvenanceTitle(flags: ProvenanceFlags, noun: "app" | "package"): string | undefined;
+//# sourceMappingURL=provenance.d.ts.map

package/components/apps/provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provenance.d.ts","sourceRoot":"","sources":["../../../../../../src/components/apps/provenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe,CAS5E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,KAAK,GAAG,SAAS,GACtB,MAAM,GAAG,SAAS,CAYpB"}

package/components/apps/provenance.js

@@ -0,0 +1,40 @@
+/**
+ * Shared provenance detection for apps and plugins.
+ *
+ * Apps (`RegistryAppInfo`) and plugins (`PluginInfo`) both expose the same
+ * `thirdParty` / `builtIn` / `firstParty` / `origin` / `support` fields, and the
+ * four UI surfaces that display provenance badges all derive the same four
+ * booleans from those fields. Those callsites differ in label casing, badge
+ * shape, and "app" vs "package" copy — but the underlying detection and the
+ * tooltip text are identical, and live here as the single source of truth.
+ *
+ * Callers continue to format their own labels/badges (Title vs lowercase,
+ * `className` vs `tone`) — only the detection and the tooltip are shared.
+ */
+export function getProvenanceFlags(source) {
+    const isThirdParty = source.thirdParty === true || source.origin === "third-party";
+    const isBuiltIn = source.builtIn === true || source.origin === "builtin";
+    const isFirstParty = source.firstParty === true || source.support === "first-party";
+    const isCommunity = source.support === "community" || (isThirdParty && !isFirstParty);
+    return { isThirdParty, isBuiltIn, isFirstParty, isCommunity };
+}
+/**
+ * Tooltip text shown on provenance badges.
+ *
+ * `noun` differentiates the copy used by the apps catalog ("app") from the
+ * copy used by the plugin/connector surfaces ("package"). Both surfaces have
+ * always shown subtly different wording — preserved here intentionally.
+ */
+export function getProvenanceTitle(flags, noun) {
+    if (flags.isThirdParty) {
+        return noun === "app"
+            ? "Community app registered through the plugin registry"
+            : "Community package registered through the plugin registry";
+    }
+    if (flags.isBuiltIn || flags.isFirstParty) {
+        return noun === "app"
+            ? "First-party app generated from the elizaOS plugin registry"
+            : "First-party package generated from the elizaOS plugin registry";
+    }
+    return undefined;
+}

package/components/apps/surfaces/GameOperatorShell.d.ts

@@ -0,0 +1,39 @@
+export type GameOperatorEventTone = "user" | "success" | "info" | "warning" | "error";
+export interface GameOperatorEvent {
+    id: string;
+    label: string;
+    message: string;
+    tone?: GameOperatorEventTone;
+    timestamp?: string | number | null;
+}
+export interface GameOperatorAction {
+    id: string;
+    label: string;
+    command: string;
+    testId?: string;
+    active?: boolean;
+    disabled?: boolean;
+}
+export interface GameOperatorDetail {
+    label: string;
+    value: string;
+}
+export interface GameOperatorShellProps {
+    surfaceTestId: string;
+    title: string;
+    statusLabel: string;
+    statusTone?: "live" | "attention" | "idle";
+    objective: string | null;
+    detailItems?: GameOperatorDetail[];
+    primaryActions: GameOperatorAction[];
+    suggestedActions?: GameOperatorAction[];
+    events: GameOperatorEvent[];
+    emptyEventsLabel: string;
+    canSend: boolean;
+    sending: boolean;
+    noticeTestId?: string;
+    variant?: "detail" | "live" | "running";
+    onCommand: (command: string) => void;
+}
+export declare function GameOperatorShell({ surfaceTestId, title, statusLabel, statusTone, objective, detailItems, primaryActions, suggestedActions, events, emptyEventsLabel, canSend, sending, noticeTestId, variant, onCommand, }: GameOperatorShellProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=GameOperatorShell.d.ts.map

package/components/apps/surfaces/GameOperatorShell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GameOperatorShell.d.ts","sourceRoot":"","sources":["../../../../../../../src/components/apps/surfaces/GameOperatorShell.tsx"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAC7B,MAAM,GACN,SAAS,GACT,MAAM,GACN,SAAS,GACT,OAAO,CAAC;AAEZ,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,qBAAqB,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;IAC3C,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACnC,cAAc,EAAE,kBAAkB,EAAE,CAAC;IACrC,gBAAgB,CAAC,EAAE,kBAAkB,EAAE,CAAC;IACxC,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;IACxC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAyBD,wBAAgB,iBAAiB,CAAC,EAChC,aAAa,EACb,KAAK,EACL,WAAW,EACX,UAAmB,EACnB,SAAS,EACT,WAAgB,EAChB,cAAc,EACd,gBAAqB,EACrB,MAAM,EACN,gBAAgB,EAChB,OAAO,EACP,OAAO,EACP,YAAY,EACZ,OAAkB,EAClB,SAAS,GACV,EAAE,sBAAsB,2CA0HxB"}