@elizaos/app-core 2.0.0-alpha.37

package/dist/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+//# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/api/index.js

@@ -0,0 +1 @@
+export * from "./client";

package/dist/autonomy/index.d.ts

@@ -0,0 +1,48 @@
+import type { StreamEventEnvelope } from "../api/client";
+export type AutonomyRunHealthStatus = "ok" | "gap_detected" | "recovered" | "partial";
+export interface AutonomyRunHealth {
+    runId: string;
+    status: AutonomyRunHealthStatus;
+    lastSeq: number | null;
+    missingSeqs: number[];
+    gapCount: number;
+    lastGapAt?: number;
+    recoveredAt?: number;
+    partialAt?: number;
+}
+export type AutonomyRunHealthMap = Record<string, AutonomyRunHealth>;
+export interface AutonomyEventStore {
+    eventsById: Record<string, StreamEventEnvelope>;
+    eventOrder: string[];
+    runIndex: Record<string, Record<number, string>>;
+    watermark: string | null;
+}
+export interface MergeAutonomyEventsOptions {
+    existingEvents?: StreamEventEnvelope[];
+    store?: AutonomyEventStore;
+    incomingEvents: StreamEventEnvelope[];
+    runHealthByRunId: AutonomyRunHealthMap;
+    maxEvents?: number;
+    replay?: boolean;
+}
+export interface MergeAutonomyEventsResult {
+    store: AutonomyEventStore;
+    events: StreamEventEnvelope[];
+    latestEventId: string | null;
+    runHealthByRunId: AutonomyRunHealthMap;
+    insertedCount: number;
+    duplicateCount: number;
+    runsWithNewGaps: string[];
+    runsRecovered: string[];
+    hasUnresolvedGaps: boolean;
+}
+export interface AutonomyGapReplayRequest {
+    runId: string;
+    fromSeq: number;
+    missingSeqs: number[];
+}
+export declare function buildAutonomyGapReplayRequests(runHealthByRunId: AutonomyRunHealthMap, store: AutonomyEventStore): AutonomyGapReplayRequest[];
+export declare function hasPendingAutonomyGaps(runHealthByRunId: AutonomyRunHealthMap): boolean;
+export declare function markPendingAutonomyGapsPartial(runHealthByRunId: AutonomyRunHealthMap, ts?: number): AutonomyRunHealthMap;
+export declare function mergeAutonomyEvents({ existingEvents, store, incomingEvents, runHealthByRunId, maxEvents, replay, }: MergeAutonomyEventsOptions): MergeAutonomyEventsResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/autonomy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/autonomy/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD,MAAM,MAAM,uBAAuB,GAC/B,IAAI,GACJ,cAAc,GACd,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,uBAAuB,CAAC;IAChC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAErE,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAChD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACvC,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,cAAc,EAAE,mBAAmB,EAAE,CAAC;IACtC,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAqPD,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,oBAAoB,EACtC,KAAK,EAAE,kBAAkB,GACxB,wBAAwB,EAAE,CAkB5B;AAED,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAIT;AAED,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,SAAa,GACd,oBAAoB,CAQtB;AAED,wBAAgB,mBAAmB,CAAC,EAClC,cAAc,EACd,KAAK,EACL,cAAc,EACd,gBAAgB,EAChB,SAA8B,EAC9B,MAAc,GACf,EAAE,0BAA0B,GAAG,yBAAyB,CA+HxD"}

package/dist/autonomy/index.js

@@ -0,0 +1,330 @@
+const DEFAULT_MAX_EVENTS = 1200;
+function cloneRunHealthMap(runHealthByRunId) {
+    return Object.fromEntries(Object.entries(runHealthByRunId).map(([runId, health]) => [
+        runId,
+        {
+            ...health,
+            missingSeqs: [...health.missingSeqs],
+        },
+    ]));
+}
+function createEmptyStore() {
+    return {
+        eventsById: {},
+        eventOrder: [],
+        runIndex: {},
+        watermark: null,
+    };
+}
+function cloneAutonomyStore(store) {
+    return {
+        eventsById: { ...store.eventsById },
+        eventOrder: [...store.eventOrder],
+        runIndex: Object.fromEntries(Object.entries(store.runIndex).map(([runId, bySeq]) => [
+            runId,
+            { ...bySeq },
+        ])),
+        watermark: store.watermark,
+    };
+}
+function fallbackDedupKey(event) {
+    if (typeof event.runId !== "string" || event.runId.length === 0)
+        return null;
+    if (typeof event.stream !== "string" || event.stream.length === 0)
+        return null;
+    if (typeof event.seq !== "number" || !Number.isFinite(event.seq))
+        return null;
+    return `${event.runId}:${event.seq}:${event.stream}`;
+}
+function hasRunIdAndSeq(event) {
+    return (typeof event.runId === "string" &&
+        event.runId.length > 0 &&
+        typeof event.seq === "number" &&
+        Number.isFinite(event.seq));
+}
+function ensureRunHealth(runHealthByRunId, runId) {
+    let health = runHealthByRunId[runId];
+    if (!health) {
+        health = {
+            runId,
+            status: "ok",
+            lastSeq: null,
+            missingSeqs: [],
+            gapCount: 0,
+        };
+        runHealthByRunId[runId] = health;
+    }
+    return health;
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((a, b) => a - b);
+}
+function parseEventOrdinal(eventId) {
+    const match = /^evt-(\d+)$/.exec(eventId);
+    if (!match)
+        return null;
+    const value = Number.parseInt(match[1] ?? "", 10);
+    return Number.isFinite(value) ? value : null;
+}
+function nextWatermark(current, candidate) {
+    if (!current)
+        return candidate;
+    if (current === candidate)
+        return current;
+    const currentOrdinal = parseEventOrdinal(current);
+    const candidateOrdinal = parseEventOrdinal(candidate);
+    if (currentOrdinal !== null && candidateOrdinal !== null) {
+        return candidateOrdinal > currentOrdinal ? candidate : current;
+    }
+    return candidate;
+}
+function recomputeWatermark(store) {
+    let watermark = null;
+    for (const eventId of store.eventOrder) {
+        if (!store.eventsById[eventId])
+            continue;
+        watermark = nextWatermark(watermark, eventId);
+    }
+    store.watermark = watermark;
+}
+function indexRunEvent(store, event) {
+    if (!hasRunIdAndSeq(event))
+        return;
+    const runId = event.runId;
+    const seq = Math.trunc(event.seq);
+    const bySeq = store.runIndex[runId] ?? {};
+    bySeq[seq] = event.eventId;
+    store.runIndex[runId] = bySeq;
+}
+function addEventToStore(store, event) {
+    store.eventsById[event.eventId] = event;
+    store.eventOrder.push(event.eventId);
+    indexRunEvent(store, event);
+    store.watermark = nextWatermark(store.watermark, event.eventId);
+}
+function removeEventFromStore(store, eventId) {
+    const event = store.eventsById[eventId];
+    if (!event)
+        return;
+    delete store.eventsById[eventId];
+    if (hasRunIdAndSeq(event)) {
+        const runId = event.runId;
+        const seq = Math.trunc(event.seq);
+        const bySeq = store.runIndex[runId];
+        if (bySeq && bySeq[seq] === eventId) {
+            delete bySeq[seq];
+            if (Object.keys(bySeq).length === 0) {
+                delete store.runIndex[runId];
+            }
+        }
+    }
+}
+function trimStore(store, maxEvents) {
+    if (store.eventOrder.length <= maxEvents) {
+        recomputeWatermark(store);
+        return;
+    }
+    const removeCount = store.eventOrder.length - maxEvents;
+    const removedIds = store.eventOrder.splice(0, removeCount);
+    for (const eventId of removedIds) {
+        removeEventFromStore(store, eventId);
+    }
+    recomputeWatermark(store);
+}
+function hydrateRunHealthFromStore(runHealthByRunId, store) {
+    for (const [runId, bySeq] of Object.entries(store.runIndex)) {
+        const health = ensureRunHealth(runHealthByRunId, runId);
+        const observedSeqs = uniqueSorted(Object.keys(bySeq)
+            .map((seq) => Number(seq))
+            .filter((seq) => Number.isFinite(seq)));
+        const observedSet = new Set(observedSeqs);
+        const missingFromObserved = [];
+        for (let idx = 1; idx < observedSeqs.length; idx += 1) {
+            const previous = observedSeqs[idx - 1];
+            const current = observedSeqs[idx];
+            if (current <= previous + 1)
+                continue;
+            for (let missing = previous + 1; missing < current; missing += 1) {
+                missingFromObserved.push(missing);
+            }
+        }
+        if (observedSeqs.length > 0) {
+            const observedLastSeq = observedSeqs[observedSeqs.length - 1] ?? null;
+            if (observedLastSeq !== null &&
+                (health.lastSeq === null || observedLastSeq > health.lastSeq)) {
+                health.lastSeq = observedLastSeq;
+            }
+        }
+        const mergedMissing = uniqueSorted([
+            ...health.missingSeqs,
+            ...missingFromObserved,
+        ]).filter((missing) => !observedSet.has(missing));
+        health.missingSeqs = mergedMissing;
+        if (health.missingSeqs.length > 0) {
+            if (health.status === "ok" || health.status === "recovered") {
+                health.status = "gap_detected";
+            }
+            if (missingFromObserved.length > 0) {
+                health.gapCount = Math.max(health.gapCount, 1);
+            }
+        }
+    }
+}
+function buildStoreFromEvents(existingEvents, maxEvents) {
+    const store = createEmptyStore();
+    const seenEventIds = new Set();
+    const seenFallbackKeys = new Set();
+    for (const event of existingEvents) {
+        const key = fallbackDedupKey(event);
+        const duplicate = seenEventIds.has(event.eventId) ||
+            (key ? seenFallbackKeys.has(key) : false);
+        if (duplicate)
+            continue;
+        seenEventIds.add(event.eventId);
+        if (key)
+            seenFallbackKeys.add(key);
+        addEventToStore(store, event);
+    }
+    trimStore(store, maxEvents);
+    return store;
+}
+export function buildAutonomyGapReplayRequests(runHealthByRunId, store) {
+    const requests = [];
+    for (const health of Object.values(runHealthByRunId)) {
+        if (health.missingSeqs.length === 0)
+            continue;
+        const indexedSeqs = store.runIndex[health.runId] ?? {};
+        const unresolved = health.missingSeqs.filter((seq) => indexedSeqs[seq] === undefined);
+        if (unresolved.length === 0)
+            continue;
+        requests.push({
+            runId: health.runId,
+            fromSeq: Math.min(...unresolved),
+            missingSeqs: unresolved,
+        });
+    }
+    return requests.sort((left, right) => left.fromSeq - right.fromSeq);
+}
+export function hasPendingAutonomyGaps(runHealthByRunId) {
+    return Object.values(runHealthByRunId).some((health) => health.missingSeqs.length > 0);
+}
+export function markPendingAutonomyGapsPartial(runHealthByRunId, ts = Date.now()) {
+    const next = cloneRunHealthMap(runHealthByRunId);
+    for (const health of Object.values(next)) {
+        if (health.missingSeqs.length === 0)
+            continue;
+        health.status = "partial";
+        health.partialAt = ts;
+    }
+    return next;
+}
+export function mergeAutonomyEvents({ existingEvents, store, incomingEvents, runHealthByRunId, maxEvents = DEFAULT_MAX_EVENTS, replay = false, }) {
+    const initialStore = store
+        ? cloneAutonomyStore(store)
+        : buildStoreFromEvents(existingEvents ?? [], maxEvents);
+    const nextStore = initialStore;
+    const nextRunHealthByRunId = cloneRunHealthMap(runHealthByRunId);
+    hydrateRunHealthFromStore(nextRunHealthByRunId, nextStore);
+    if (incomingEvents.length === 0 && !replay) {
+        const events = nextStore.eventOrder
+            .map((eventId) => nextStore.eventsById[eventId])
+            .filter((event) => Boolean(event));
+        return {
+            store: nextStore,
+            events,
+            latestEventId: nextStore.watermark,
+            runHealthByRunId: nextRunHealthByRunId,
+            insertedCount: 0,
+            duplicateCount: 0,
+            runsWithNewGaps: [],
+            runsRecovered: [],
+            hasUnresolvedGaps: hasPendingAutonomyGaps(nextRunHealthByRunId),
+        };
+    }
+    const seenEventIds = new Set();
+    const seenFallbackKeys = new Set();
+    for (const eventId of nextStore.eventOrder) {
+        const event = nextStore.eventsById[eventId];
+        if (!event)
+            continue;
+        seenEventIds.add(eventId);
+        const key = fallbackDedupKey(event);
+        if (key)
+            seenFallbackKeys.add(key);
+    }
+    let duplicateCount = 0;
+    let insertedCount = 0;
+    const runsWithNewGaps = new Set();
+    const runsRecovered = new Set();
+    for (const event of incomingEvents) {
+        const key = fallbackDedupKey(event);
+        const duplicate = seenEventIds.has(event.eventId) ||
+            (key ? seenFallbackKeys.has(key) : false);
+        if (duplicate) {
+            duplicateCount += 1;
+            continue;
+        }
+        seenEventIds.add(event.eventId);
+        if (key)
+            seenFallbackKeys.add(key);
+        addEventToStore(nextStore, event);
+        insertedCount += 1;
+        if (!hasRunIdAndSeq(event)) {
+            continue;
+        }
+        const health = ensureRunHealth(nextRunHealthByRunId, event.runId);
+        const seq = Math.trunc(event.seq);
+        const previousLastSeq = health.lastSeq;
+        if (previousLastSeq !== null && seq > previousLastSeq + 1) {
+            const missingSeqs = [];
+            for (let current = previousLastSeq + 1; current < seq; current += 1) {
+                missingSeqs.push(current);
+            }
+            health.missingSeqs = uniqueSorted([
+                ...health.missingSeqs,
+                ...missingSeqs,
+            ]);
+            health.status = "gap_detected";
+            health.gapCount += 1;
+            health.lastGapAt = event.ts;
+            runsWithNewGaps.add(event.runId);
+        }
+        if (health.missingSeqs.length > 0) {
+            health.missingSeqs = health.missingSeqs.filter((missing) => missing !== seq);
+        }
+        if (health.lastSeq === null || seq > health.lastSeq) {
+            health.lastSeq = seq;
+        }
+        if (health.missingSeqs.length === 0 &&
+            (health.status === "gap_detected" || health.status === "partial")) {
+            health.status = "recovered";
+            health.recoveredAt = event.ts;
+            runsRecovered.add(event.runId);
+        }
+    }
+    if (replay) {
+        const replayTs = Date.now();
+        for (const health of Object.values(nextRunHealthByRunId)) {
+            if (health.missingSeqs.length === 0)
+                continue;
+            health.status = "partial";
+            health.partialAt = replayTs;
+        }
+    }
+    trimStore(nextStore, maxEvents);
+    const boundedEvents = nextStore.eventOrder
+        .map((eventId) => nextStore.eventsById[eventId])
+        .filter((event) => Boolean(event));
+    const latestEventId = nextStore.watermark;
+    return {
+        store: nextStore,
+        events: boundedEvents,
+        latestEventId,
+        runHealthByRunId: nextRunHealthByRunId,
+        insertedCount,
+        duplicateCount,
+        runsWithNewGaps: [...runsWithNewGaps],
+        runsRecovered: [...runsRecovered],
+        hasUnresolvedGaps: hasPendingAutonomyGaps(nextRunHealthByRunId),
+    };
+}

package/dist/bridge/capacitor-bridge.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Capacitor Bridge
+ *
+ * This module provides a bridge between the Milady web UI and native
+ * Capacitor plugins. It exposes a global API that the UI can use to
+ * access native capabilities like camera, microphone, file system, etc.
+ *
+ * The bridge is designed to be progressively enhanced - features are
+ * only available when running on platforms that support them.
+ */
+import { isFeatureAvailable, type MiladyPlugins, type PluginCapabilities } from "./plugin-bridge";
+/**
+ * Capability flags indicating what features are available
+ */
+export interface CapacitorCapabilities {
+    /** Whether we're running in a native container */
+    native: boolean;
+    /** Platform identifier */
+    platform: "ios" | "android" | "electron" | "web";
+    /** Haptic feedback support */
+    haptics: boolean;
+    /** Camera capture support */
+    camera: boolean;
+    /** Microphone/audio capture support */
+    microphone: boolean;
+    /** Screen recording support */
+    screenCapture: boolean;
+    /** File system access */
+    fileSystem: boolean;
+    /** Push notifications */
+    notifications: boolean;
+    /** Geolocation */
+    geolocation: boolean;
+    /** Background execution */
+    background: boolean;
+    /** Voice wake/always-on listening */
+    voiceWake: boolean;
+}
+/**
+ * Get the current platform capabilities
+ */
+export declare function getCapabilities(): CapacitorCapabilities;
+/**
+ * Haptic feedback wrapper
+ */
+export declare const haptics: {
+    /**
+     * Trigger a light impact haptic (for UI interactions)
+     */
+    light(): Promise<void>;
+    /**
+     * Trigger a medium impact haptic (for confirmations)
+     */
+    medium(): Promise<void>;
+    /**
+     * Trigger a heavy impact haptic (for important actions)
+     */
+    heavy(): Promise<void>;
+    /**
+     * Trigger a success notification haptic
+     */
+    success(): Promise<void>;
+    /**
+     * Trigger a warning notification haptic
+     */
+    warning(): Promise<void>;
+    /**
+     * Trigger an error notification haptic
+     */
+    error(): Promise<void>;
+    /**
+     * Start a selection change haptic (for pickers)
+     */
+    selectionStart(): Promise<void>;
+    /**
+     * Trigger selection changed haptic
+     */
+    selectionChanged(): Promise<void>;
+    /**
+     * End selection change haptic
+     */
+    selectionEnd(): Promise<void>;
+};
+/**
+ * Plugin registry for custom Milady plugins
+ *
+ * Custom plugins (Gateway, Swabble, Canvas, etc.) will register themselves here
+ * when they're loaded. This allows the UI to check for plugin availability
+ * and access them in a type-safe way.
+ */
+type PluginInstance = Record<string, unknown>;
+/**
+ * Register a custom plugin
+ */
+export declare function registerPlugin(name: string, plugin: PluginInstance): void;
+/**
+ * Get a registered plugin
+ */
+export declare function getPlugin<T extends PluginInstance>(name: string): T | undefined;
+/**
+ * Check if a plugin is registered
+ */
+export declare function hasPlugin(name: string): boolean;
+/**
+ * The global Milady bridge object exposed to the UI
+ */
+export interface MiladyBridge {
+    /** Platform capabilities */
+    capabilities: CapacitorCapabilities;
+    /** Plugin-specific capabilities */
+    pluginCapabilities: PluginCapabilities;
+    /** Haptic feedback */
+    haptics: typeof haptics;
+    /** Get a registered plugin */
+    getPlugin: typeof getPlugin;
+    /** Check if a plugin exists */
+    hasPlugin: typeof hasPlugin;
+    /** Register a new plugin */
+    registerPlugin: typeof registerPlugin;
+    /** Get all Milady plugins with fallback support */
+    plugins: MiladyPlugins;
+    /** Check if a specific feature is available */
+    isFeatureAvailable: typeof isFeatureAvailable;
+    /** Platform info */
+    platform: {
+        name: string;
+        isNative: boolean;
+        isIOS: boolean;
+        isAndroid: boolean;
+        isElectron: boolean;
+        isWeb: boolean;
+        isMacOS: boolean;
+    };
+}
+declare global {
+    interface Window {
+        Milady: MiladyBridge;
+    }
+}
+/**
+ * Initialize the Capacitor bridge
+ *
+ * This exposes the bridge object on window.Milady for use by the UI.
+ */
+export declare function initializeCapacitorBridge(): void;
+/**
+ * Wait for the bridge to be ready
+ *
+ * Returns immediately if already initialized, otherwise waits for the event.
+ */
+export declare function waitForBridge(): Promise<MiladyBridge>;
+export {};
+//# sourceMappingURL=capacitor-bridge.d.ts.map

package/dist/bridge/capacitor-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacitor-bridge.d.ts","sourceRoot":"","sources":["../../src/bridge/capacitor-bridge.ts"],"names":[],"mappings":"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"}