@elizaos/ui 2.0.0-alpha.385 → 2.0.0-alpha.392

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsCapabilitiesStatus.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsCapabilitiesStatus.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAUjE,wBAAgB,4BAA4B;;;;;EAmD3C"}

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

@@ -0,0 +1,60 @@
+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;
+}
+export function useLifeOpsCapabilitiesStatus() {
+    const [status, setStatus] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            setStatus(await client.getLifeOpsCapabilitiesStatus());
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "LifeOps capabilities failed to load."));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            setLoading(true);
+            try {
+                const response = await client.getLifeOpsCapabilitiesStatus();
+                if (cancelled) {
+                    return;
+                }
+                setStatus(response);
+                setError(null);
+            }
+            catch (cause) {
+                if (cancelled) {
+                    return;
+                }
+                setError(formatError(cause, "LifeOps capabilities failed to load."));
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    return {
+        status,
+        loading,
+        error,
+        refresh,
+    };
+}

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

@@ -0,0 +1,18 @@
+import type { LifeOpsScheduleSummary } from "../lifeops/schedule-insight.js";
+export interface UseLifeOpsScheduleInspectionOptions {
+    timezone?: string;
+    refreshIntervalMs?: number;
+}
+/**
+ * Loads the lightweight schedule summary (cached merged state + last 7 days
+ * of persisted sleep episodes) at a steady cadence. Reads from cached
+ * tables only — the scheduler tick is the sole writer. Safe to call on
+ * every panel mount without triggering probes.
+ */
+export declare function useLifeOpsScheduleInspection(options?: UseLifeOpsScheduleInspectionOptions): {
+    readonly inspection: LifeOpsScheduleSummary | null;
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useLifeOpsScheduleInspection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsScheduleInspection.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsScheduleInspection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAS7E,MAAM,WAAW,mCAAmC;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,GAAE,mCAAwC;;;;;EA2DlD"}

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

@@ -0,0 +1,66 @@
+import { client } from "@elizaos/app-core";
+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;
+}
+/**
+ * Loads the lightweight schedule summary (cached merged state + last 7 days
+ * of persisted sleep episodes) at a steady cadence. Reads from cached
+ * tables only — the scheduler tick is the sole writer. Safe to call on
+ * every panel mount without triggering probes.
+ */
+export function useLifeOpsScheduleInspection(options = {}) {
+    const [inspection, setInspection] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const load = useCallback(async (isCancelled) => {
+        setLoading(true);
+        try {
+            const timezone = options.timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone;
+            const response = await client.getLifeOpsScheduleSummary(timezone);
+            if (isCancelled?.())
+                return;
+            setInspection(response);
+            setError(null);
+        }
+        catch (cause) {
+            if (isCancelled?.())
+                return;
+            setError(formatError(cause, "LifeOps schedule summary failed to load."));
+        }
+        finally {
+            if (!isCancelled?.())
+                setLoading(false);
+        }
+    }, [options.timezone]);
+    const refresh = useCallback(async () => {
+        await load();
+    }, [load]);
+    useEffect(() => {
+        let cancelled = false;
+        void load(() => cancelled);
+        return () => {
+            cancelled = true;
+        };
+    }, [load]);
+    useEffect(() => {
+        const intervalMs = options.refreshIntervalMs ?? 120_000;
+        if (!Number.isFinite(intervalMs) || intervalMs <= 0)
+            return;
+        const intervalId = window.setInterval(() => {
+            void load();
+        }, intervalMs);
+        return () => {
+            window.clearInterval(intervalId);
+        };
+    }, [load, options.refreshIntervalMs]);
+    return {
+        inspection,
+        loading,
+        error,
+        refresh,
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { LifeOpsScheduleMergedState } from "../lifeops/schedule-sync-contracts.js";
+export interface UseLifeOpsScheduleStateOptions {
+    timezone?: string | null;
+    scope?: "local" | "cloud" | "effective";
+    refreshIntervalMs?: number;
+    refreshOnWindowFocus?: boolean;
+}
+export declare function useLifeOpsScheduleState(options?: UseLifeOpsScheduleStateOptions): {
+    readonly state: LifeOpsScheduleMergedState | null;
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useLifeOpsScheduleState.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsScheduleState.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsScheduleState.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AASxF,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;IACxC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,8BAAmC;;;;;EA+E7C"}

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

@@ -0,0 +1,79 @@
+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;
+}
+export function useLifeOpsScheduleState(options = {}) {
+    const [state, setState] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const load = useCallback(async (forceRefresh, isCancelled) => {
+        setLoading(true);
+        try {
+            const response = await client.getLifeOpsScheduleMergedState({
+                timezone: options.timezone ?? undefined,
+                scope: options.scope,
+                refresh: forceRefresh,
+            });
+            if (isCancelled?.()) {
+                return;
+            }
+            setState(response.mergedState);
+            setError(null);
+        }
+        catch (cause) {
+            if (isCancelled?.()) {
+                return;
+            }
+            setError(formatError(cause, "LifeOps schedule state failed to load."));
+        }
+        finally {
+            if (!isCancelled?.()) {
+                setLoading(false);
+            }
+        }
+    }, [options.scope, options.timezone]);
+    const refresh = useCallback(async () => {
+        await load(true);
+    }, [load]);
+    useEffect(() => {
+        let cancelled = false;
+        void load(false, () => cancelled);
+        return () => {
+            cancelled = true;
+        };
+    }, [load]);
+    useEffect(() => {
+        const intervalMs = options.refreshIntervalMs ?? 60_000;
+        if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+            return;
+        }
+        const intervalId = window.setInterval(() => {
+            void load(false);
+        }, intervalMs);
+        return () => {
+            window.clearInterval(intervalId);
+        };
+    }, [load, options.refreshIntervalMs]);
+    useEffect(() => {
+        if (options.refreshOnWindowFocus === false) {
+            return;
+        }
+        const handleFocus = () => {
+            void load(false);
+        };
+        window.addEventListener("focus", handleFocus);
+        return () => {
+            window.removeEventListener("focus", handleFocus);
+        };
+    }, [load, options.refreshOnWindowFocus]);
+    return {
+        state,
+        loading,
+        error,
+        refresh,
+    };
+}

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

@@ -0,0 +1,18 @@
+import { type LifeOpsRouteSection } from "../lifeops-route.js";
+export type LifeOpsSection = LifeOpsRouteSection;
+export declare const LIFEOPS_SECTIONS: LifeOpsSection[];
+export interface UseLifeOpsSectionReturn {
+    section: LifeOpsSection;
+    eventId: string | null;
+    messageId: string | null;
+    /** Navigate to a section, clearing any detail-view selection. */
+    navigate: (next: LifeOpsSection) => void;
+    /** Open a specific calendar event as a detail view. */
+    openEvent: (eventId: string) => void;
+    /** Open a specific inbox message as a detail view. */
+    openMessage: (messageId: string) => void;
+    /** Close any open detail view, staying on the same section. */
+    closeDetail: () => void;
+}
+export declare function useLifeOpsSection(initial?: string | null): UseLifeOpsSectionReturn;
+//# sourceMappingURL=useLifeOpsSection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsSection.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsSection.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,mBAAmB,EAEzB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAEjD,eAAO,MAAM,gBAAgB,EAAE,cAAc,EAAgC,CAAC;AAiD9E,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,iEAAiE;IACjE,QAAQ,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAC;IACzC,uDAAuD;IACvD,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,sDAAsD;IACtD,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,+DAA+D;IAC/D,WAAW,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,GACtB,uBAAuB,CA6CzB"}

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

@@ -0,0 +1,78 @@
+import { useCallback, useEffect, useState } from "react";
+import { buildLifeOpsHash, LIFEOPS_ROUTE_SECTIONS, parseLifeOpsRoute, } from "../lifeops-route.js";
+export const LIFEOPS_SECTIONS = [...LIFEOPS_ROUTE_SECTIONS];
+function isLifeOpsSection(value) {
+    return (typeof value === "string" && LIFEOPS_SECTIONS.includes(value));
+}
+function readFromHash(initial) {
+    const fallbackSection = isLifeOpsSection(initial)
+        ? initial
+        : "overview";
+    if (typeof window === "undefined") {
+        return { section: fallbackSection, eventId: null, messageId: null };
+    }
+    const route = parseLifeOpsRoute(window.location.hash);
+    // A lingering `lifeops.event` or `lifeops.message` in the hash implies the
+    // corresponding section even if the `section` key was cleared or absent.
+    let section = route.section;
+    if (!section && route.eventId)
+        section = "calendar";
+    if (!section && route.messageId)
+        section = "messages";
+    return {
+        section: section ?? fallbackSection,
+        eventId: route.eventId,
+        messageId: route.messageId,
+    };
+}
+function writeHash(next) {
+    if (typeof window === "undefined")
+        return;
+    try {
+        const nextHash = buildLifeOpsHash(window.location.hash, next);
+        const url = `${window.location.pathname}${window.location.search}${nextHash}`;
+        window.history.replaceState(null, "", url || window.location.href);
+    }
+    catch {
+        // Best-effort — URL manipulation failures shouldn't break navigation.
+    }
+}
+export function useLifeOpsSection(initial) {
+    const [state, setState] = useState(() => readFromHash(initial));
+    // Keep the hook in sync with back/forward navigation (including other
+    // widgets that write the hash, like the chat-sidebar widget rows).
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        function onHashChange() {
+            setState(readFromHash());
+        }
+        window.addEventListener("hashchange", onHashChange);
+        return () => window.removeEventListener("hashchange", onHashChange);
+    }, []);
+    const navigate = useCallback((next) => {
+        setState({ section: next, eventId: null, messageId: null });
+        writeHash({ section: next, eventId: null, messageId: null });
+    }, []);
+    const openEvent = useCallback((eventId) => {
+        setState({ section: "calendar", eventId, messageId: null });
+        writeHash({ section: "calendar", eventId, messageId: null });
+    }, []);
+    const openMessage = useCallback((messageId) => {
+        setState({ section: "messages", eventId: null, messageId });
+        writeHash({ section: "messages", eventId: null, messageId });
+    }, []);
+    const closeDetail = useCallback(() => {
+        setState((prev) => ({ ...prev, eventId: null, messageId: null }));
+        writeHash({ eventId: null, messageId: null });
+    }, []);
+    return {
+        section: state.section,
+        eventId: state.eventId,
+        messageId: state.messageId,
+        navigate,
+        openEvent,
+        openMessage,
+        closeDetail,
+    };
+}

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

@@ -0,0 +1,14 @@
+import type { LifeOpsConnectorMode, LifeOpsConnectorSide, LifeOpsXConnectorStatus, LifeOpsXPostResponse } from "@elizaos/shared";
+export declare function useLifeOpsXConnector(side?: LifeOpsConnectorSide): {
+    readonly status: LifeOpsXConnectorStatus | null;
+    readonly loading: boolean;
+    readonly actionPending: boolean;
+    readonly error: string | null;
+    readonly lastPost: LifeOpsXPostResponse | null;
+    readonly pendingAuthUrl: string | null;
+    readonly refresh: () => Promise<void>;
+    readonly connect: (mode?: LifeOpsConnectorMode) => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly post: (text: string, mode?: LifeOpsConnectorMode) => Promise<void>;
+};
+//# sourceMappingURL=useLifeOpsXConnector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLifeOpsXConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useLifeOpsXConnector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AAUzB,wBAAgB,oBAAoB,CAAC,IAAI,GAAE,oBAA8B;;;;;;;;8BA8EvD,oBAAoB;;0BAmCrB,MAAM,SAAS,oBAAoB;EAsDnD"}

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

@@ -0,0 +1,160 @@
+import { client } from "@elizaos/app-core/api";
+import { openExternalUrl } from "@elizaos/app-core/utils";
+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;
+}
+export function useLifeOpsXConnector(side = "owner") {
+    const [status, setStatus] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [actionPending, setActionPending] = useState(false);
+    const [error, setError] = useState(null);
+    const [lastPost, setLastPost] = useState(null);
+    const [pendingAuthUrl, setPendingAuthUrl] = useState(null);
+    const resolveSuccessRedirectUrl = useCallback(() => {
+        const baseUrl = typeof client.getBaseUrl === "function" ? client.getBaseUrl().trim() : "";
+        const origin = baseUrl ||
+            (typeof window !== "undefined" &&
+                typeof window.location?.origin === "string" &&
+                window.location.origin.trim().length > 0
+                ? window.location.origin.trim()
+                : "");
+        if (!origin)
+            return undefined;
+        const url = new URL("/api/lifeops/connectors/x/success", origin);
+        url.searchParams.set("side", side);
+        url.searchParams.set("mode", "cloud_managed");
+        return url.toString();
+    }, [side]);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const nextStatus = await client.getXLifeOpsConnectorStatus(undefined, side);
+            setStatus(nextStatus);
+            if (nextStatus.connected) {
+                setPendingAuthUrl(null);
+            }
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "X connector status failed to load."));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [side]);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            setLoading(true);
+            try {
+                const nextStatus = await client.getXLifeOpsConnectorStatus(undefined, side);
+                if (cancelled) {
+                    return;
+                }
+                setStatus(nextStatus);
+                if (nextStatus.connected) {
+                    setPendingAuthUrl(null);
+                }
+                setError(null);
+            }
+            catch (cause) {
+                if (cancelled) {
+                    return;
+                }
+                setError(formatError(cause, "X connector status failed to load."));
+            }
+            finally {
+                if (!cancelled) {
+                    setLoading(false);
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [side]);
+    const connect = useCallback(async (mode) => {
+        try {
+            setActionPending(true);
+            setPendingAuthUrl(null);
+            const connectMode = mode ?? status?.mode ?? status?.defaultMode ?? "cloud_managed";
+            const result = await client.startXLifeOpsConnector({
+                mode: connectMode,
+                redirectUrl: connectMode === "cloud_managed"
+                    ? resolveSuccessRedirectUrl()
+                    : undefined,
+                side,
+            });
+            if (result.authUrl) {
+                await openExternalUrl(result.authUrl);
+                setPendingAuthUrl(result.authUrl);
+            }
+            else {
+                const nextStatus = await client.getXLifeOpsConnectorStatus(result.mode, side);
+                setStatus(nextStatus);
+            }
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "X connector connect failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [resolveSuccessRedirectUrl, side, status]);
+    const post = useCallback(async (text, mode) => {
+        try {
+            setActionPending(true);
+            setLastPost(null);
+            const result = await client.createXLifeOpsPost({
+                side,
+                mode: mode ?? status?.mode,
+                text,
+                confirmPost: true,
+            });
+            setLastPost(result);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "X post failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side, status?.mode]);
+    const disconnect = useCallback(async () => {
+        try {
+            setActionPending(true);
+            await client.disconnectXLifeOpsConnector({
+                side,
+                mode: status?.mode,
+            });
+            setPendingAuthUrl(null);
+            const nextStatus = await client.getXLifeOpsConnectorStatus(status?.mode, side);
+            setStatus(nextStatus);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "X connector disconnect failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side, status?.mode]);
+    return {
+        status,
+        loading,
+        actionPending,
+        error,
+        lastPost,
+        pendingAuthUrl,
+        refresh,
+        connect,
+        disconnect,
+        post,
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { LifeOpsConnectorSide, LifeOpsSignalConnectorStatus, LifeOpsSignalPairingStatus } from "@elizaos/shared";
+export interface UseSignalConnectorOptions {
+    side?: LifeOpsConnectorSide;
+}
+export declare function useSignalConnector(options?: UseSignalConnectorOptions): {
+    readonly status: LifeOpsSignalConnectorStatus | null;
+    readonly loading: boolean;
+    readonly actionPending: boolean;
+    readonly error: string | null;
+    readonly pairingStatus: LifeOpsSignalPairingStatus | null;
+    readonly startPairing: () => Promise<string | null>;
+    readonly stopPairing: () => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useSignalConnector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSignalConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useSignalConnector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,iBAAiB,CAAC;AA+BzB,MAAM,WAAW,yBAAyB;IACxC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAED,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B;;;;;;;;;;EA2LzE"}