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

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

@@ -0,0 +1,14 @@
+import type { LifeOpsConnectorSide, LifeOpsDiscordConnectorStatus, LifeOpsOwnerBrowserAccessSource } from "@elizaos/shared/contracts/lifeops";
+export interface UseDiscordConnectorOptions {
+    side?: LifeOpsConnectorSide;
+}
+export declare function useDiscordConnector(options?: UseDiscordConnectorOptions): {
+    readonly status: LifeOpsDiscordConnectorStatus | null;
+    readonly loading: boolean;
+    readonly actionPending: boolean;
+    readonly error: string | null;
+    readonly connect: (source?: LifeOpsOwnerBrowserAccessSource) => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useDiscordConnector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDiscordConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useDiscordConnector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,oBAAoB,EACpB,6BAA6B,EAC7B,+BAA+B,EAChC,MAAM,mCAAmC,CAAC;AAU3C,MAAM,WAAW,0BAA0B;IACzC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAID,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,0BAA+B;;;;;gCAiFxD,+BAA+B;;;EAwClD"}

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

@@ -0,0 +1,126 @@
+import { client } from "@elizaos/app-core/api";
+import { useCallback, useEffect, useRef, useState } from "react";
+function formatError(cause, fallback) {
+    if (cause instanceof Error && cause.message.trim().length > 0) {
+        return cause.message.trim();
+    }
+    return fallback;
+}
+const LOGIN_POLL_INTERVAL_MS = 3_000;
+export function useDiscordConnector(options = {}) {
+    const side = options.side ?? "owner";
+    const [status, setStatus] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [actionPending, setActionPending] = useState(false);
+    const [error, setError] = useState(null);
+    const pollRef = useRef(null);
+    const clearPoll = useCallback(() => {
+        if (pollRef.current) {
+            clearInterval(pollRef.current);
+            pollRef.current = null;
+        }
+    }, []);
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const nextStatus = await client.getDiscordConnectorStatus(side);
+            setStatus(nextStatus);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "Discord connector status failed to load."));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [side]);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            setLoading(true);
+            try {
+                const nextStatus = await client.getDiscordConnectorStatus(side);
+                if (cancelled)
+                    return;
+                setStatus(nextStatus);
+                setError(null);
+            }
+            catch (cause) {
+                if (cancelled)
+                    return;
+                setError(formatError(cause, "Discord connector status failed to load."));
+            }
+            finally {
+                if (!cancelled)
+                    setLoading(false);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [side]);
+    useEffect(() => () => clearPoll(), [clearPoll]);
+    useEffect(() => {
+        const shouldPoll = status?.reason === "pairing" || status?.reason === "auth_pending";
+        if (shouldPoll && !pollRef.current) {
+            pollRef.current = setInterval(() => {
+                void (async () => {
+                    try {
+                        const next = await client.getDiscordConnectorStatus(side);
+                        setStatus(next);
+                        if (next.reason !== "pairing" && next.reason !== "auth_pending") {
+                            clearPoll();
+                        }
+                        setError(null);
+                    }
+                    catch (cause) {
+                        setError(formatError(cause, "Discord connector status poll failed."));
+                    }
+                })();
+            }, LOGIN_POLL_INTERVAL_MS);
+        }
+        else if (!shouldPoll) {
+            clearPoll();
+        }
+    }, [status?.reason, side, clearPoll]);
+    const connect = useCallback(async (source) => {
+        try {
+            setActionPending(true);
+            setError(null);
+            const nextStatus = await client.startDiscordConnector({ side, source });
+            setStatus(nextStatus);
+        }
+        catch (cause) {
+            setError(formatError(cause, "Discord connector failed to start."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side]);
+    const disconnect = useCallback(async () => {
+        try {
+            setActionPending(true);
+            const nextStatus = await client.disconnectDiscordConnector({
+                side,
+                provider: "discord",
+            });
+            setStatus(nextStatus);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatError(cause, "Discord connector disconnect failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side]);
+    return {
+        status,
+        loading,
+        actionPending,
+        error,
+        connect,
+        disconnect,
+        refresh,
+    };
+}

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

@@ -0,0 +1,29 @@
+import type { LifeOpsConnectorMode, LifeOpsConnectorSide, LifeOpsGoogleConnectorStatus } from "../contracts/index.js";
+export interface UseGoogleLifeOpsConnectorOptions {
+    includeAccounts?: boolean;
+    pollIntervalMs?: number;
+    pollWhileDisconnected?: boolean;
+    side?: LifeOpsConnectorSide;
+}
+export declare function useGoogleLifeOpsConnector(options?: UseGoogleLifeOpsConnectorOptions): {
+    readonly accounts: LifeOpsGoogleConnectorStatus[];
+    readonly activeMode: "local" | "remote" | "cloud_managed";
+    readonly actionPending: boolean;
+    readonly connect: () => Promise<void>;
+    readonly connectAdditional: () => Promise<void>;
+    readonly disconnect: () => Promise<void>;
+    readonly disconnectAccount: (grantId: string) => Promise<void>;
+    readonly error: string | null;
+    readonly loading: boolean;
+    readonly modeOptions: ("local" | "remote" | "cloud_managed")[];
+    readonly pendingAuthUrl: string | null;
+    readonly refresh: ({ silent, mode, }?: {
+        silent?: boolean;
+        mode?: LifeOpsConnectorMode | null;
+    }) => Promise<void>;
+    readonly selectMode: (mode: LifeOpsConnectorMode) => Promise<void>;
+    readonly selectedMode: "local" | "remote" | "cloud_managed" | null;
+    readonly side: "agent" | "owner";
+    readonly status: LifeOpsGoogleConnectorStatus | null;
+};
+//# sourceMappingURL=useGoogleLifeOpsConnector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useGoogleLifeOpsConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useGoogleLifeOpsConnector.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,oBAAoB,EACpB,oBAAoB,EAEpB,4BAA4B,EAC7B,MAAM,uBAAuB,CAAC;AA4K/B,MAAM,WAAW,gCAAgC;IAC/C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,IAAI,CAAC,EAAE,oBAAoB,CAAC;CAC7B;AAED,wBAAgB,yBAAyB,CACvC,OAAO,GAAE,gCAAqC;;;;;;;0CA0X5B,MAAM;;;;;2CAjVnB;QACD,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,IAAI,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAAC;KACpC;gCAuPY,oBAAoB;;;;EAkKpC"}

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

@@ -0,0 +1,481 @@
+import { client } from "@elizaos/app-core/api";
+import { isApiError } from "@elizaos/app-core/api/client-types-core";
+import { APP_RESUME_EVENT } from "@elizaos/app-core/events";
+import { useApp } from "@elizaos/app-core/state";
+import { openExternalUrl } from "@elizaos/app-core/utils";
+import { LIFEOPS_GOOGLE_CAPABILITIES } from "../contracts/index.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { dispatchLifeOpsGoogleConnectorRefresh, LIFEOPS_GOOGLE_CONNECTOR_REFRESH_EVENT, } from "../events/index.js";
+const DEFAULT_GOOGLE_CONNECTOR_POLL_INTERVAL_MS = 15_000;
+const GOOGLE_CONNECTOR_SILENT_REFRESH_DEBOUNCE_MS = 150;
+const GOOGLE_CONNECTOR_SILENT_REFRESH_COOLDOWN_MS = 1_000;
+const DEFAULT_VISIBLE_GOOGLE_MODES = [
+    "cloud_managed",
+    "local",
+];
+const GOOGLE_INBOX_TRACKING_CAPABILITIES = LIFEOPS_GOOGLE_CAPABILITIES.filter((capability) => capability !== "google.gmail.manage");
+const GOOGLE_CONNECTOR_STORAGE_KEY = "elizaos:lifeops:google-connector-refresh";
+const GOOGLE_CONNECTOR_BROADCAST_CHANNEL = "elizaos:lifeops:google-connector";
+const GOOGLE_CONNECTOR_MESSAGE_TYPE = "lifeops-google-connector-refresh";
+let googleConnectorHookInstanceSeed = 0;
+function isLifeOpsRuntimeReady(args) {
+    return (args.startupPhase === "ready" &&
+        args.agentState === "running" &&
+        args.backendState === "connected");
+}
+function isTransientLifeOpsAvailabilityError(cause) {
+    return (isApiError(cause) &&
+        cause.kind === "http" &&
+        cause.status === 503 &&
+        cause.path.startsWith("/api/lifeops/connectors/google/status"));
+}
+function formatConnectorError(cause, fallback) {
+    if (cause instanceof Error && cause.message.trim().length > 0) {
+        return cause.message.trim();
+    }
+    return fallback;
+}
+function uniqueModes(modes) {
+    const ordered = [];
+    const seen = new Set();
+    for (const mode of modes) {
+        if (!mode || seen.has(mode)) {
+            continue;
+        }
+        seen.add(mode);
+        ordered.push(mode);
+    }
+    return ordered;
+}
+function resolveVisibleModes(status) {
+    return uniqueModes([
+        status?.mode,
+        status?.defaultMode,
+        ...(status?.availableModes ?? []),
+        ...DEFAULT_VISIBLE_GOOGLE_MODES,
+    ]);
+}
+function resolveConnectMode(status, selectedMode) {
+    if (status?.reason === "config_missing" &&
+        (selectedMode ?? status.mode) === "local" &&
+        (status.availableModes ?? []).includes("cloud_managed")) {
+        return "cloud_managed";
+    }
+    return selectedMode ?? status?.mode ?? status?.defaultMode ?? "cloud_managed";
+}
+function resolveSuccessRedirectUrl(side) {
+    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/google/success", origin);
+    url.searchParams.set("side", side);
+    url.searchParams.set("mode", "cloud_managed");
+    return url.toString();
+}
+function normalizeRefreshDetail(value) {
+    if (!value || typeof value !== "object") {
+        return null;
+    }
+    const candidate = value;
+    const side = candidate.side === "owner" || candidate.side === "agent"
+        ? candidate.side
+        : undefined;
+    const mode = candidate.mode === "local" ||
+        candidate.mode === "remote" ||
+        candidate.mode === "cloud_managed"
+        ? candidate.mode
+        : undefined;
+    const source = candidate.source === "callback" ||
+        candidate.source === "connect" ||
+        candidate.source === "disconnect" ||
+        candidate.source === "mode_change" ||
+        candidate.source === "refresh" ||
+        candidate.source === "focus" ||
+        candidate.source === "visibility" ||
+        candidate.source === "resume"
+        ? candidate.source
+        : undefined;
+    return {
+        origin: typeof candidate.origin === "string" && candidate.origin.trim().length > 0
+            ? candidate.origin.trim()
+            : undefined,
+        side,
+        mode,
+        source,
+    };
+}
+function parseRefreshEnvelope(rawValue) {
+    try {
+        return JSON.parse(rawValue);
+    }
+    catch {
+        return null;
+    }
+}
+export function useGoogleLifeOpsConnector(options = {}) {
+    const { agentStatus, backendConnection, startupPhase } = useApp();
+    const includeAccounts = options.includeAccounts ?? false;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_GOOGLE_CONNECTOR_POLL_INTERVAL_MS;
+    const pollWhileDisconnected = options.pollWhileDisconnected ?? true;
+    const side = options.side ?? "owner";
+    const instanceIdRef = useRef(`google-connector-hook-${googleConnectorHookInstanceSeed++}`);
+    const pendingSilentRefreshModeRef = useRef(undefined);
+    const selectedModeRef = useRef(null);
+    const silentRefreshTimerRef = useRef(null);
+    const lastSilentRefreshAtRef = useRef(0);
+    const [selectedMode, setSelectedMode] = useState(null);
+    const [status, setStatus] = useState(null);
+    const [accounts, setAccounts] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [actionPending, setActionPending] = useState(false);
+    const [error, setError] = useState(null);
+    // Keep the latest OAuth URL local to the hook so it resets when the UI unmounts.
+    const [pendingAuthUrl, setPendingAuthUrl] = useState(null);
+    const runtimeReady = isLifeOpsRuntimeReady({
+        startupPhase,
+        agentState: agentStatus?.state ?? null,
+        backendState: backendConnection?.state ?? null,
+    });
+    const refresh = useCallback(async ({ silent = false, mode, } = {}) => {
+        if (!runtimeReady) {
+            setError(null);
+            setLoading(false);
+            return;
+        }
+        if (!silent) {
+            setLoading(true);
+        }
+        try {
+            const requestedMode = mode === undefined ? selectedModeRef.current : mode;
+            const [nextStatus, nextAccounts] = await Promise.all([
+                client.getGoogleLifeOpsConnectorStatus(requestedMode ?? undefined, side),
+                includeAccounts
+                    ? client.getGoogleLifeOpsConnectorAccounts(undefined, side)
+                    : Promise.resolve([]),
+            ]);
+            const nextSelectedMode = requestedMode ?? nextStatus.mode;
+            selectedModeRef.current = nextSelectedMode;
+            setSelectedMode(nextSelectedMode);
+            setStatus(nextStatus);
+            setAccounts(nextAccounts);
+            if (nextStatus.connected) {
+                setPendingAuthUrl(null);
+            }
+            setError(null);
+        }
+        catch (cause) {
+            if (isTransientLifeOpsAvailabilityError(cause)) {
+                setError(null);
+                return;
+            }
+            setError(formatConnectorError(cause, "Google connector status failed to refresh."));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [includeAccounts, runtimeReady, side]);
+    const queueSilentRefresh = useCallback((mode) => {
+        if (!runtimeReady) {
+            return;
+        }
+        if (mode !== undefined) {
+            pendingSilentRefreshModeRef.current = mode;
+        }
+        if (silentRefreshTimerRef.current !== null) {
+            return;
+        }
+        const elapsed = Date.now() - lastSilentRefreshAtRef.current;
+        const delay = elapsed >= GOOGLE_CONNECTOR_SILENT_REFRESH_COOLDOWN_MS
+            ? GOOGLE_CONNECTOR_SILENT_REFRESH_DEBOUNCE_MS
+            : GOOGLE_CONNECTOR_SILENT_REFRESH_COOLDOWN_MS - elapsed;
+        silentRefreshTimerRef.current = globalThis.setTimeout(() => {
+            silentRefreshTimerRef.current = null;
+            const nextMode = pendingSilentRefreshModeRef.current;
+            pendingSilentRefreshModeRef.current = undefined;
+            lastSilentRefreshAtRef.current = Date.now();
+            void refresh({
+                silent: true,
+                mode: nextMode,
+            });
+        }, delay);
+    }, [refresh, runtimeReady]);
+    useEffect(() => {
+        return () => {
+            if (silentRefreshTimerRef.current === null) {
+                return;
+            }
+            globalThis.clearTimeout(silentRefreshTimerRef.current);
+            silentRefreshTimerRef.current = null;
+        };
+    }, []);
+    useEffect(() => {
+        if (!runtimeReady) {
+            setLoading(false);
+            return;
+        }
+        void refresh();
+    }, [refresh, runtimeReady]);
+    useEffect(() => {
+        if (!runtimeReady) {
+            return;
+        }
+        if (pollIntervalMs <= 0) {
+            return;
+        }
+        if (!pollWhileDisconnected && status?.connected !== true) {
+            return;
+        }
+        const intervalId = globalThis.setInterval(() => {
+            void refresh({ silent: true });
+        }, pollIntervalMs);
+        return () => {
+            globalThis.clearInterval(intervalId);
+        };
+    }, [
+        pollIntervalMs,
+        pollWhileDisconnected,
+        refresh,
+        runtimeReady,
+        status?.connected,
+    ]);
+    useEffect(() => {
+        if (typeof window === "undefined") {
+            return;
+        }
+        const canUseWindowEvents = typeof window.addEventListener === "function" &&
+            typeof window.removeEventListener === "function";
+        const canUseDocumentEvents = typeof document !== "undefined" &&
+            typeof document.addEventListener === "function" &&
+            typeof document.removeEventListener === "function";
+        const refreshSilently = (detail) => {
+            if (!runtimeReady) {
+                return;
+            }
+            if (detail?.origin === instanceIdRef.current) {
+                return;
+            }
+            if (detail?.side && detail.side !== side) {
+                return;
+            }
+            queueSilentRefresh(detail?.mode);
+        };
+        const handleConnectorRefresh = (event) => {
+            refreshSilently(normalizeRefreshDetail(event.detail));
+        };
+        const handleWindowMessage = (event) => {
+            const message = event.data;
+            if (message?.type !== GOOGLE_CONNECTOR_MESSAGE_TYPE) {
+                return;
+            }
+            refreshSilently(normalizeRefreshDetail(message.detail));
+        };
+        const handleStorage = (event) => {
+            if (event.key !== GOOGLE_CONNECTOR_STORAGE_KEY ||
+                !event.newValue ||
+                event.newValue.trim().length === 0) {
+                return;
+            }
+            const parsed = parseRefreshEnvelope(event.newValue);
+            if (parsed?.type !== GOOGLE_CONNECTOR_MESSAGE_TYPE) {
+                return;
+            }
+            refreshSilently(normalizeRefreshDetail(parsed.detail));
+        };
+        const handleFocus = () => {
+            refreshSilently({ side, source: "focus" });
+        };
+        const handleVisibility = () => {
+            if (document.visibilityState !== "visible") {
+                return;
+            }
+            refreshSilently({ side, source: "visibility" });
+        };
+        const handleResume = () => {
+            refreshSilently({ side, source: "resume" });
+        };
+        const broadcastChannel = typeof BroadcastChannel === "function"
+            ? new BroadcastChannel(GOOGLE_CONNECTOR_BROADCAST_CHANNEL)
+            : null;
+        const handleBroadcastMessage = (event) => {
+            const message = event.data;
+            if (message?.type !== GOOGLE_CONNECTOR_MESSAGE_TYPE) {
+                return;
+            }
+            refreshSilently(normalizeRefreshDetail(message.detail));
+        };
+        if (canUseWindowEvents) {
+            window.addEventListener(LIFEOPS_GOOGLE_CONNECTOR_REFRESH_EVENT, handleConnectorRefresh);
+            window.addEventListener("message", handleWindowMessage);
+            window.addEventListener("storage", handleStorage);
+            window.addEventListener("focus", handleFocus);
+        }
+        if (canUseDocumentEvents) {
+            document.addEventListener("visibilitychange", handleVisibility);
+            document.addEventListener(APP_RESUME_EVENT, handleResume);
+        }
+        broadcastChannel?.addEventListener("message", handleBroadcastMessage);
+        return () => {
+            if (canUseWindowEvents) {
+                window.removeEventListener(LIFEOPS_GOOGLE_CONNECTOR_REFRESH_EVENT, handleConnectorRefresh);
+                window.removeEventListener("message", handleWindowMessage);
+                window.removeEventListener("storage", handleStorage);
+                window.removeEventListener("focus", handleFocus);
+            }
+            if (canUseDocumentEvents) {
+                document.removeEventListener("visibilitychange", handleVisibility);
+                document.removeEventListener(APP_RESUME_EVENT, handleResume);
+            }
+            broadcastChannel?.removeEventListener("message", handleBroadcastMessage);
+            broadcastChannel?.close();
+        };
+    }, [queueSilentRefresh, runtimeReady, side]);
+    const selectMode = useCallback(async (mode) => {
+        try {
+            setActionPending(true);
+            setPendingAuthUrl(null);
+            const nextStatus = (status?.availableModes ?? []).includes(mode)
+                ? await client.selectGoogleLifeOpsConnectorMode({ mode, side })
+                : await client.getGoogleLifeOpsConnectorStatus(mode, side);
+            selectedModeRef.current = mode;
+            setSelectedMode(mode);
+            setStatus(nextStatus);
+            setError(null);
+            dispatchLifeOpsGoogleConnectorRefresh({
+                origin: instanceIdRef.current,
+                side,
+                mode,
+                source: "mode_change",
+            });
+        }
+        catch (cause) {
+            setError(formatConnectorError(cause, "Google connector mode change failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side, status]);
+    const connect = useCallback(async () => {
+        try {
+            setActionPending(true);
+            setPendingAuthUrl(null);
+            const requestedCapabilities = [...GOOGLE_INBOX_TRACKING_CAPABILITIES];
+            const connectMode = resolveConnectMode(status ?? null, selectedModeRef.current);
+            const result = await client.startGoogleLifeOpsConnector({
+                capabilities: requestedCapabilities,
+                redirectUrl: connectMode === "cloud_managed"
+                    ? resolveSuccessRedirectUrl(side)
+                    : undefined,
+                side,
+                mode: connectMode,
+            });
+            await openExternalUrl(result.authUrl);
+            setPendingAuthUrl(result.authUrl);
+            setError(null);
+        }
+        catch (cause) {
+            setPendingAuthUrl(null);
+            setError(formatConnectorError(cause, "Google connector setup failed to start."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side, status]);
+    const disconnect = useCallback(async () => {
+        if (!status) {
+            return;
+        }
+        try {
+            setActionPending(true);
+            setPendingAuthUrl(null);
+            await client.disconnectGoogleLifeOpsConnector({
+                side,
+                mode: selectedModeRef.current ?? status.mode,
+            });
+            selectedModeRef.current = null;
+            await refresh({ mode: null });
+            dispatchLifeOpsGoogleConnectorRefresh({
+                origin: instanceIdRef.current,
+                side,
+                source: "disconnect",
+            });
+        }
+        catch (cause) {
+            setError(formatConnectorError(cause, "Google connector disconnect failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [refresh, side, status]);
+    const disconnectAccount = useCallback(async (grantId) => {
+        try {
+            setActionPending(true);
+            await client.disconnectGoogleLifeOpsConnector({
+                side,
+                mode: selectedModeRef.current ?? status?.mode,
+                grantId,
+            });
+            await refresh({ mode: selectedModeRef.current });
+            dispatchLifeOpsGoogleConnectorRefresh({
+                origin: instanceIdRef.current,
+                side,
+                source: "disconnect",
+            });
+        }
+        catch (cause) {
+            setError(formatConnectorError(cause, "Google account disconnect failed."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [refresh, side, status]);
+    const connectAdditional = useCallback(async () => {
+        try {
+            setActionPending(true);
+            const requestedCapabilities = [...GOOGLE_INBOX_TRACKING_CAPABILITIES];
+            const connectMode = resolveConnectMode(status ?? null, selectedModeRef.current);
+            const result = await client.startGoogleLifeOpsConnector({
+                capabilities: requestedCapabilities,
+                redirectUrl: connectMode === "cloud_managed"
+                    ? resolveSuccessRedirectUrl(side)
+                    : undefined,
+                side,
+                mode: connectMode,
+            });
+            await openExternalUrl(result.authUrl);
+            setError(null);
+        }
+        catch (cause) {
+            setError(formatConnectorError(cause, "Google connector setup failed to start."));
+        }
+        finally {
+            setActionPending(false);
+        }
+    }, [side, status]);
+    const modeOptions = useMemo(() => resolveVisibleModes(status), [status]);
+    const activeMode = selectedMode ?? status?.mode ?? status?.defaultMode ?? "cloud_managed";
+    return {
+        accounts,
+        activeMode,
+        actionPending,
+        connect,
+        connectAdditional,
+        disconnect,
+        disconnectAccount,
+        error,
+        loading,
+        modeOptions,
+        pendingAuthUrl,
+        refresh,
+        selectMode,
+        selectedMode,
+        side,
+        status,
+    };
+}

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

@@ -0,0 +1,10 @@
+import type { LifeOpsIMessageConnectorStatus } from "@elizaos/shared";
+import type { FullDiskAccessProbeResult } from "../lifeops/fda-probe.js";
+export declare function useIMessageConnector(): {
+    readonly status: LifeOpsIMessageConnectorStatus | null;
+    readonly loading: boolean;
+    readonly error: string | null;
+    readonly fullDiskAccess: FullDiskAccessProbeResult | null;
+    readonly refresh: () => Promise<void>;
+};
+//# sourceMappingURL=useIMessageConnector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useIMessageConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useIMessageConnector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AAEtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAezE,wBAAgB,oBAAoB;;;;;;EAgDnC"}