@elizaos/agent 2.0.0-alpha.385 → 2.0.0-alpha.393

package/apps/app-lifeops/src/hooks/useIMessageConnector.js

@@ -0,0 +1,50 @@
+import { client } from "@elizaos/app-core/api";
+import { useCallback, useEffect, useState } from "react";
+function formatError(cause, fallback) {
+    if (cause instanceof Error && cause.message.trim().length > 0) {
+        return cause.message.trim();
+    }
+    return fallback;
+}
+function isMacHostPlatform(platform) {
+    return platform === "darwin";
+}
+export function useIMessageConnector() {
+    const [status, setStatus] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const [fullDiskAccess, setFullDiskAccess] = useState(null);
+    const refreshSupportState = useCallback(async (nextStatus) => {
+        if (!isMacHostPlatform(nextStatus?.hostPlatform)) {
+            setFullDiskAccess(null);
+            return;
+        }
+        const fullDiskAccessResult = await client.getLifeOpsFullDiskAccessStatus();
+        setFullDiskAccess(fullDiskAccessResult);
+    }, []);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const nextStatus = await client.getIMessageConnectorStatus();
+            setStatus(nextStatus);
+            setError(null);
+            await refreshSupportState(nextStatus);
+        }
+        catch (cause) {
+            setError(formatError(cause, "iMessage connector status failed to load."));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [refreshSupportState]);
+    useEffect(() => {
+        void refresh();
+    }, [refresh]);
+    return {
+        status,
+        loading,
+        error,
+        fullDiskAccess,
+        refresh,
+    };
+}

package/apps/app-lifeops/src/hooks/useInbox.d.ts

@@ -0,0 +1,34 @@
+import type { LifeOpsInboxChannel, LifeOpsInboxMessage, LifeOpsInboxThreadGroup } from "@elizaos/shared";
+export type InboxChannel = "all" | LifeOpsInboxChannel;
+export type InboxChatType = "dm" | "group" | "channel";
+export interface UseInboxOptions {
+    maxResults?: number;
+    channel?: InboxChannel;
+    channels?: readonly LifeOpsInboxChannel[];
+    searchQuery?: string;
+    /** When true, request `threadGroups` from the backend. */
+    groupByThread?: boolean;
+    /** Server-side chatType filter (DM / small group / channel). */
+    chatTypeFilter?: ReadonlyArray<InboxChatType>;
+    /** Server-side cap on group participants. */
+    maxParticipants?: number;
+    /** Filter Gmail to a specific Google grant. */
+    gmailAccountId?: string;
+    /** Only return threads that have gone unreplied for >24h with priority >=50. */
+    missedOnly?: boolean;
+    /** Sort thread groups by priority desc with recency tiebreaker. */
+    sortByPriority?: boolean;
+}
+export interface UseInboxResult {
+    messages: LifeOpsInboxMessage[];
+    threadGroups: LifeOpsInboxThreadGroup[];
+    loading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    channel: InboxChannel;
+    setChannel: (ch: InboxChannel) => void;
+    searchQuery: string;
+    setSearchQuery: (q: string) => void;
+}
+export declare function useInbox(opts?: UseInboxOptions): UseInboxResult;
+//# sourceMappingURL=useInbox.d.ts.map

package/apps/app-lifeops/src/hooks/useInbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInbox.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useInbox.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,mBAAmB,EACnB,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAGzB,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,mBAAmB,CAAC;AACvD,MAAM,MAAM,aAAa,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,CAAC;AAEvD,MAAM,WAAW,eAAe;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC1C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,0DAA0D;IAC1D,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gEAAgE;IAChE,cAAc,CAAC,EAAE,aAAa,CAAC,aAAa,CAAC,CAAC;IAC9C,6CAA6C;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,+CAA+C;IAC/C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,mEAAmE;IACnE,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,mBAAmB,EAAE,CAAC;IAChC,YAAY,EAAE,uBAAuB,EAAE,CAAC;IACxC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AA0BD,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,cAAc,CA0FnE"}

package/apps/app-lifeops/src/hooks/useInbox.js

@@ -0,0 +1,98 @@
+import { client, useApp } from "@elizaos/app-core";
+import { useCallback, useEffect, useMemo, useState } from "react";
+const DEFAULT_MAX_RESULTS = 40;
+function matchesQuery(message, q) {
+    return ((message.subject ?? "").toLowerCase().includes(q) ||
+        message.sender.displayName.toLowerCase().includes(q) ||
+        message.snippet.toLowerCase().includes(q) ||
+        message.channel.toLowerCase().includes(q));
+}
+function threadGroupMatchesQuery(group, q) {
+    if (matchesQuery(group.latestMessage, q)) {
+        return true;
+    }
+    return (group.messages ?? []).some((message) => matchesQuery(message, q));
+}
+export function useInbox(opts = {}) {
+    const { t } = useApp();
+    const [feed, setFeed] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [channel, setChannel] = useState(opts.channel ?? "all");
+    const [searchQuery, setSearchQuery] = useState(opts.searchQuery ?? "");
+    useEffect(() => {
+        setChannel(opts.channel ?? "all");
+    }, [opts.channel]);
+    const chatTypeFilterKey = opts.chatTypeFilter
+        ? opts.chatTypeFilter.join(",")
+        : "";
+    const fetch = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        try {
+            const selectedChannels = channel === "all"
+                ? opts.channels
+                    ? [...opts.channels]
+                    : undefined
+                : [channel];
+            const result = await client.getLifeOpsInbox({
+                limit: opts.maxResults ?? DEFAULT_MAX_RESULTS,
+                channels: selectedChannels,
+                groupByThread: opts.groupByThread,
+                chatTypeFilter: opts.chatTypeFilter
+                    ? [...opts.chatTypeFilter]
+                    : undefined,
+                maxParticipants: opts.maxParticipants,
+                gmailAccountId: opts.gmailAccountId,
+                missedOnly: opts.missedOnly,
+                sortByPriority: opts.sortByPriority,
+            });
+            setFeed(result);
+        }
+        catch (cause) {
+            setError(cause instanceof Error && cause.message.trim().length > 0
+                ? cause.message.trim()
+                : t("lifeopsInbox.loadFailed", {
+                    defaultValue: "Inbox failed to load.",
+                }));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [
+        channel,
+        opts.channels,
+        opts.maxResults,
+        opts.groupByThread,
+        chatTypeFilterKey,
+        opts.maxParticipants,
+        opts.gmailAccountId,
+        opts.missedOnly,
+        opts.sortByPriority,
+        t,
+    ]);
+    useEffect(() => {
+        void fetch();
+    }, [fetch]);
+    const messages = useMemo(() => {
+        const base = feed?.messages ?? [];
+        const q = searchQuery.trim().toLowerCase();
+        return q ? base.filter((m) => matchesQuery(m, q)) : base;
+    }, [feed, searchQuery]);
+    const threadGroups = useMemo(() => {
+        const base = feed?.threadGroups ?? [];
+        const q = searchQuery.trim().toLowerCase();
+        return q ? base.filter((g) => threadGroupMatchesQuery(g, q)) : base;
+    }, [feed, searchQuery]);
+    return {
+        messages,
+        threadGroups,
+        loading,
+        error,
+        refresh: fetch,
+        channel,
+        setChannel,
+        searchQuery,
+        setSearchQuery,
+    };
+}

package/apps/app-lifeops/src/hooks/useLifeOpsActivitySignals.d.ts

@@ -0,0 +1,2 @@
+export declare function useLifeOpsActivitySignals(enabled?: boolean): void;
+//# sourceMappingURL=useLifeOpsActivitySignals.d.ts.map

package/apps/app-lifeops/src/hooks/useLifeOpsActivitySignals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsActivitySignals.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsActivitySignals.ts"],"names":[],"mappings":"AAiJA,wBAAgB,yBAAyB,CAAC,OAAO,UAAO,GAAG,IAAI,CAuU9D"}

package/apps/app-lifeops/src/hooks/useLifeOpsActivitySignals.js

@@ -0,0 +1,383 @@
+import { Capacitor } from "@capacitor/core";
+import { APP_PAUSE_EVENT, APP_RESUME_EVENT, client, isApiError, isElectrobunRuntime, loadDesktopWorkspaceSnapshot, } from "@elizaos/app-core";
+import { MobileSignals, } from "@elizaos/capacitor-mobile-signals";
+import { useEffect, useRef } from "react";
+import { dispatchLifeOpsActivitySignalsStatus } from "../events/index.js";
+const APP_SIGNAL_DEDUP_WINDOW_MS = 5_000;
+const RUNTIME_READY_POLL_MS = 5_000;
+const PAGE_HEARTBEAT_MS = 60_000;
+const DESKTOP_POWER_POLL_MS = 60_000;
+// Health sleep data drives wake detection; five-minute polling keeps morning
+// anchors timely without running while mobile monitoring is stopped.
+const MOBILE_HEALTH_POLL_MS = 5 * 60_000;
+function getWindowCapacitor() {
+    if (typeof window === "undefined") {
+        return undefined;
+    }
+    return window.Capacitor;
+}
+function resolveCapacitorPlatform() {
+    const importedPlatform = Capacitor.getPlatform();
+    if (importedPlatform !== "web") {
+        return importedPlatform;
+    }
+    return getWindowCapacitor()?.getPlatform?.() ?? importedPlatform;
+}
+function isNativeCapacitorRuntime() {
+    return (Capacitor.isNativePlatform() ||
+        getWindowCapacitor()?.isNativePlatform?.() === true ||
+        ["ios", "android"].includes(resolveCapacitorPlatform()));
+}
+function resolveActivityPlatform() {
+    if (isElectrobunRuntime()) {
+        return "desktop_app";
+    }
+    if (isNativeCapacitorRuntime()) {
+        return "mobile_app";
+    }
+    return "web_app";
+}
+function errorMessage(error) {
+    return error instanceof Error && error.message.trim().length > 0
+        ? error.message.trim()
+        : String(error);
+}
+function fingerprintSignal(signal) {
+    return JSON.stringify([
+        signal.source,
+        signal.platform ?? "",
+        signal.state,
+        signal.idleState ?? "",
+        signal.idleTimeSeconds ?? "",
+        signal.onBattery ?? "",
+        signal.metadata ?? {},
+    ]);
+}
+function mapMobileSignal(signal) {
+    return {
+        source: signal.source,
+        platform: signal.platform,
+        state: signal.state,
+        observedAt: new Date(signal.observedAt).toISOString(),
+        idleState: signal.idleState,
+        idleTimeSeconds: signal.idleTimeSeconds ?? undefined,
+        onBattery: signal.onBattery ?? undefined,
+        health: signal.source === "mobile_health"
+            ? {
+                source: signal.healthSource,
+                permissions: signal.permissions,
+                sleep: {
+                    available: signal.sleep.available,
+                    isSleeping: signal.sleep.isSleeping,
+                    asleepAt: signal.sleep.asleepAt !== null
+                        ? new Date(signal.sleep.asleepAt).toISOString()
+                        : null,
+                    awakeAt: signal.sleep.awakeAt !== null
+                        ? new Date(signal.sleep.awakeAt).toISOString()
+                        : null,
+                    durationMinutes: signal.sleep.durationMinutes,
+                    stage: signal.sleep.stage,
+                },
+                biometrics: {
+                    sampleAt: signal.biometrics.sampleAt !== null
+                        ? new Date(signal.biometrics.sampleAt).toISOString()
+                        : null,
+                    heartRateBpm: signal.biometrics.heartRateBpm,
+                    restingHeartRateBpm: signal.biometrics.restingHeartRateBpm,
+                    heartRateVariabilityMs: signal.biometrics.heartRateVariabilityMs,
+                    respiratoryRate: signal.biometrics.respiratoryRate,
+                    bloodOxygenPercent: signal.biometrics.bloodOxygenPercent,
+                },
+                warnings: signal.warnings,
+            }
+            : undefined,
+        metadata: signal.metadata,
+    };
+}
+export function useLifeOpsActivitySignals(enabled = true) {
+    const platformRef = useRef(resolveActivityPlatform());
+    const lastSentRef = useRef(new Map());
+    const runtimeReadyRef = useRef(false);
+    useEffect(() => {
+        if (!enabled) {
+            return;
+        }
+        let mounted = true;
+        const isRuntimeUnavailableError = (error) => isApiError(error) &&
+            error.kind === "http" &&
+            error.status === 503 &&
+            error.path === "/api/lifeops/activity-signals";
+        const reportCaptureError = (error) => {
+            if (isRuntimeUnavailableError(error)) {
+                runtimeReadyRef.current = false;
+                return;
+            }
+            if (isApiError(error) &&
+                (error.kind === "network" ||
+                    error.kind === "timeout" ||
+                    (error.status === 503 &&
+                        error.path === "/api/lifeops/activity-signals"))) {
+                return;
+            }
+            dispatchLifeOpsActivitySignalsStatus({
+                status: "capture_error",
+                message: errorMessage(error),
+            });
+        };
+        const refreshRuntimeReady = async () => {
+            try {
+                const status = await client.getStatus();
+                const ready = status.state === "running";
+                runtimeReadyRef.current = ready;
+                return ready;
+            }
+            catch {
+                runtimeReadyRef.current = false;
+                return false;
+            }
+        };
+        const sendSignal = async (signal) => {
+            if (!mounted || !runtimeReadyRef.current) {
+                return null;
+            }
+            const normalized = {
+                ...signal,
+                platform: signal.platform ?? platformRef.current,
+            };
+            const fingerprint = fingerprintSignal(normalized);
+            const dedupeKey = `${normalized.source}:${normalized.platform ?? ""}`;
+            const previous = lastSentRef.current.get(dedupeKey);
+            const nowMs = Date.now();
+            if (previous &&
+                previous.fingerprint === fingerprint &&
+                nowMs - previous.sentAtMs < APP_SIGNAL_DEDUP_WINDOW_MS) {
+                return null;
+            }
+            lastSentRef.current.set(dedupeKey, { fingerprint, sentAtMs: nowMs });
+            try {
+                const { signal: persisted } = await client.captureLifeOpsActivitySignal(normalized);
+                return persisted;
+            }
+            catch (error) {
+                lastSentRef.current.delete(dedupeKey);
+                if (isRuntimeUnavailableError(error)) {
+                    runtimeReadyRef.current = false;
+                    return null;
+                }
+                throw error;
+            }
+        };
+        const sendSnapshotResult = async (result) => {
+            if (result.snapshot) {
+                await sendSignal(mapMobileSignal(result.snapshot));
+            }
+            if (result.healthSnapshot) {
+                await sendSignal(mapMobileSignal(result.healthSnapshot));
+            }
+        };
+        const fireAndForget = (signal) => {
+            void sendSignal(signal).catch(reportCaptureError);
+        };
+        const emitPageState = (reason) => {
+            const isVisible = document.visibilityState === "visible";
+            const hasFocus = typeof document.hasFocus === "function" ? document.hasFocus() : true;
+            fireAndForget({
+                source: "page_visibility",
+                state: isVisible && hasFocus ? "active" : "background",
+                metadata: {
+                    reason,
+                    visibilityState: document.visibilityState,
+                    hasFocus,
+                },
+            });
+        };
+        const emitLifecycleState = (state) => {
+            fireAndForget({
+                source: "app_lifecycle",
+                state,
+                metadata: { reason: state === "active" ? "resume" : "pause" },
+            });
+        };
+        const emitDesktopSnapshot = async (reason) => {
+            try {
+                if (!isElectrobunRuntime()) {
+                    return;
+                }
+                const snapshot = await loadDesktopWorkspaceSnapshot();
+                if (!snapshot.supported || !snapshot.power) {
+                    return;
+                }
+                const state = snapshot.power.idleState === "locked"
+                    ? "locked"
+                    : snapshot.power.idleState === "idle"
+                        ? "idle"
+                        : snapshot.window.focused &&
+                            document.visibilityState === "visible"
+                            ? "active"
+                            : "background";
+                await sendSignal({
+                    source: "desktop_power",
+                    state,
+                    idleState: snapshot.power.idleState,
+                    idleTimeSeconds: Math.max(0, Math.trunc(snapshot.power.idleTime)),
+                    onBattery: snapshot.power.onBattery,
+                    metadata: {
+                        reason,
+                        windowFocused: snapshot.window.focused,
+                        windowVisible: snapshot.window.visible,
+                        documentVisibility: document.visibilityState,
+                    },
+                });
+            }
+            catch (error) {
+                reportCaptureError(error);
+            }
+        };
+        const handleVisibilityChange = () => {
+            emitPageState("visibilitychange");
+        };
+        const handleFocus = () => {
+            emitPageState("focus");
+            void emitDesktopSnapshot("focus");
+        };
+        const handleBlur = () => {
+            emitPageState("blur");
+            void emitDesktopSnapshot("blur");
+        };
+        const handleResume = () => {
+            emitLifecycleState("active");
+            emitPageState("resume");
+            void refreshMobileHealthSnapshot("resume");
+            void emitDesktopSnapshot("resume");
+        };
+        const handlePause = () => {
+            emitLifecycleState("background");
+            emitPageState("pause");
+            void refreshMobileHealthSnapshot("pause");
+            void emitDesktopSnapshot("pause");
+        };
+        const mobileSignals = isNativeCapacitorRuntime() && !isElectrobunRuntime()
+            ? MobileSignals
+            : null;
+        let mobileSignalsHandle = null;
+        let mobileSignalsStarted = false;
+        let mobileHealthPoller = null;
+        const refreshMobileHealthSnapshot = async (reason) => {
+            if (!mobileSignals || typeof mobileSignals.getSnapshot !== "function") {
+                return;
+            }
+            const snapshot = await mobileSignals.getSnapshot();
+            if (snapshot.supported) {
+                await sendSnapshotResult(snapshot);
+            }
+            else {
+                dispatchLifeOpsActivitySignalsStatus({
+                    status: "snapshot_unavailable",
+                    reason,
+                });
+            }
+        };
+        const startMobileSignals = async () => {
+            if (mobileSignalsHandle || mobileSignalsStarted) {
+                return;
+            }
+            if (!mobileSignals ||
+                typeof mobileSignals.addListener !== "function" ||
+                typeof mobileSignals.checkPermissions !== "function" ||
+                typeof mobileSignals.requestPermissions !== "function" ||
+                typeof mobileSignals.startMonitoring !== "function" ||
+                typeof mobileSignals.stopMonitoring !== "function") {
+                return;
+            }
+            const permissions = await mobileSignals.checkPermissions();
+            if (permissions.status !== "granted" && permissions.canRequest) {
+                await mobileSignals.requestPermissions();
+            }
+            mobileSignalsHandle = await mobileSignals.addListener("signal", (signal) => {
+                void sendSignal(mapMobileSignal(signal)).catch(reportCaptureError);
+            });
+            const initial = await mobileSignals.startMonitoring({
+                emitInitial: true,
+            });
+            mobileSignalsStarted = initial.enabled;
+            await sendSnapshotResult(initial);
+            await refreshMobileHealthSnapshot("start");
+            if (typeof mobileSignals.scheduleBackgroundRefresh === "function") {
+                try {
+                    const result = await mobileSignals.scheduleBackgroundRefresh();
+                    if (!result.scheduled && result.reason) {
+                        dispatchLifeOpsActivitySignalsStatus({
+                            status: "background_refresh_unavailable",
+                            reason: result.reason,
+                        });
+                    }
+                }
+                catch (error) {
+                    reportCaptureError(error);
+                }
+            }
+            mobileHealthPoller = window.setInterval(() => {
+                void refreshMobileHealthSnapshot("poll").catch(reportCaptureError);
+            }, MOBILE_HEALTH_POLL_MS);
+        };
+        const emitCurrentState = (reason) => {
+            emitLifecycleState("active");
+            emitPageState(reason);
+            void emitDesktopSnapshot(reason);
+            void refreshMobileHealthSnapshot(reason).catch(reportCaptureError);
+        };
+        void refreshRuntimeReady()
+            .then((ready) => {
+            if (ready) {
+                emitCurrentState("mount");
+                void startMobileSignals().catch(reportCaptureError);
+            }
+        })
+            .catch(reportCaptureError);
+        document.addEventListener("visibilitychange", handleVisibilityChange);
+        document.addEventListener(APP_RESUME_EVENT, handleResume);
+        document.addEventListener(APP_PAUSE_EVENT, handlePause);
+        window.addEventListener("focus", handleFocus);
+        window.addEventListener("blur", handleBlur);
+        const runtimePoller = window.setInterval(() => {
+            const wasReady = runtimeReadyRef.current;
+            void refreshRuntimeReady()
+                .then((ready) => {
+                if (!mounted || !ready || wasReady) {
+                    return;
+                }
+                emitCurrentState("runtime-ready");
+                void startMobileSignals().catch(reportCaptureError);
+            })
+                .catch(reportCaptureError);
+        }, RUNTIME_READY_POLL_MS);
+        const pageHeartbeat = window.setInterval(() => {
+            if (document.visibilityState === "visible") {
+                emitPageState("heartbeat");
+            }
+        }, PAGE_HEARTBEAT_MS);
+        const desktopPoller = window.setInterval(() => {
+            void emitDesktopSnapshot("poll");
+        }, DESKTOP_POWER_POLL_MS);
+        return () => {
+            mounted = false;
+            document.removeEventListener("visibilitychange", handleVisibilityChange);
+            document.removeEventListener(APP_RESUME_EVENT, handleResume);
+            document.removeEventListener(APP_PAUSE_EVENT, handlePause);
+            window.removeEventListener("focus", handleFocus);
+            window.removeEventListener("blur", handleBlur);
+            if (mobileSignalsHandle) {
+                void mobileSignalsHandle.remove();
+            }
+            if (mobileSignalsStarted) {
+                void mobileSignals?.stopMonitoring().catch(reportCaptureError);
+            }
+            if (mobileHealthPoller !== null) {
+                window.clearInterval(mobileHealthPoller);
+            }
+            window.clearInterval(runtimePoller);
+            window.clearInterval(pageHeartbeat);
+            window.clearInterval(desktopPoller);
+        };
+    }, [enabled]);
+}

package/apps/app-lifeops/src/hooks/useLifeOpsAppState.d.ts

@@ -0,0 +1,9 @@
+export declare function useLifeOpsAppState(): {
+    enabled: boolean;
+    loading: boolean;
+    saving: boolean;
+    error: string;
+    refresh: () => Promise<import("../api/client-lifeops").LifeOpsAppStateDto>;
+    updateEnabled: (nextEnabled: boolean) => Promise<import("../api/client-lifeops").LifeOpsAppStateDto>;
+};
+//# sourceMappingURL=useLifeOpsAppState.d.ts.map

package/apps/app-lifeops/src/hooks/useLifeOpsAppState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsAppState.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsAppState.ts"],"names":[],"mappings":"AASA,wBAAgB,kBAAkB;;;;;;iCAkDsB,OAAO;EAyB9D"}

package/apps/app-lifeops/src/hooks/useLifeOpsAppState.js

@@ -0,0 +1,83 @@
+import { useCallback, useEffect, useState } from "react";
+import { client } from "@elizaos/app-core";
+function errorMessage(cause) {
+    return cause instanceof Error && cause.message.trim().length > 0
+        ? cause.message.trim()
+        : "LifeOps app state failed to load.";
+}
+export function useLifeOpsAppState() {
+    const [enabled, setEnabled] = useState(false);
+    const [loading, setLoading] = useState(true);
+    const [saving, setSaving] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const state = await client.getLifeOpsAppState();
+            setEnabled(state.enabled === true);
+            setError(null);
+            return state;
+        }
+        catch (cause) {
+            setError(errorMessage(cause));
+            throw cause;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            setLoading(true);
+            try {
+                const state = await client.getLifeOpsAppState();
+                if (cancelled) {
+                    return;
+                }
+                setEnabled(state.enabled === true);
+                setError(null);
+            }
+            catch (cause) {
+                if (cancelled) {
+                    return;
+                }
+                setError(errorMessage(cause));
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    const updateEnabled = useCallback(async (nextEnabled) => {
+        setSaving(true);
+        try {
+            const state = await client.updateLifeOpsAppState({
+                enabled: nextEnabled,
+            });
+            setEnabled(state.enabled === true);
+            setError(null);
+            return state;
+        }
+        catch (cause) {
+            setError(errorMessage(cause));
+            throw cause;
+        }
+        finally {
+            setSaving(false);
+        }
+    }, []);
+    return {
+        enabled,
+        loading,
+        saving,
+        error,
+        refresh,
+        updateEnabled,
+    };
+}

package/apps/app-lifeops/src/hooks/useLifeOpsCapabilitiesStatus.d.ts

@@ -0,0 +1,8 @@
+import type { LifeOpsCapabilitiesStatus } from "@elizaos/shared";
+export declare function useLifeOpsCapabilitiesStatus(): {
+    readonly status: LifeOpsCapabilitiesStatus;
+    readonly loading: boolean;
+    readonly error: string;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useLifeOpsCapabilitiesStatus.d.ts.map