@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/hooks/useGoogleLifeOpsConnector.js

@@ -0,0 +1,630 @@
+import { APP_RESUME_EVENT } from "@elizaos/shared";
+import { client } from "@elizaos/ui";
+import { isApiError } from "@elizaos/ui/api";
+import { useAppSelector } from "@elizaos/ui/state";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  dispatchLifeOpsGoogleConnectorRefresh,
+  LIFEOPS_GOOGLE_CONNECTOR_REFRESH_EVENT
+} from "../events/index.js";
+import { formatConnectorError } from "./connector-error.js";
+const DEFAULT_GOOGLE_CONNECTOR_POLL_INTERVAL_MS = 15e3;
+const GOOGLE_CONNECTOR_SILENT_REFRESH_DEBOUNCE_MS = 150;
+const GOOGLE_CONNECTOR_SILENT_REFRESH_COOLDOWN_MS = 1e3;
+const DEFAULT_VISIBLE_GOOGLE_MODES = [
+  "local"
+];
+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";
+const GOOGLE_CONNECTOR_ACCOUNT_GRANT_PREFIX = "connector-account:";
+let googleConnectorHookInstanceSeed = 0;
+function googleGrantIdForAccount(accountId) {
+  return `${GOOGLE_CONNECTOR_ACCOUNT_GRANT_PREFIX}${accountId}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function metadata(account) {
+  return isRecord(account.metadata) ? account.metadata : {};
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function booleanValue(value) {
+  return value === true;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map((item) => typeof item === "string" ? item.trim() : "").filter(Boolean) : [];
+}
+function isoString(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return new Date(value).toISOString();
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : value.trim();
+  }
+  return null;
+}
+function mapGoogleCapability(value) {
+  switch (value) {
+    case "google.basic_identity":
+    case "basic_identity":
+      return "google.basic_identity";
+    case "google.calendar.read":
+    case "calendar.read":
+      return "google.calendar.read";
+    case "google.calendar.write":
+    case "calendar.write":
+      return "google.calendar.write";
+    case "google.gmail.triage":
+    case "gmail.read":
+      return "google.gmail.triage";
+    case "google.gmail.send":
+    case "gmail.send":
+      return "google.gmail.send";
+    case "google.gmail.manage":
+    case "gmail.manage":
+      return "google.gmail.manage";
+    case "google.drive.read":
+    case "drive.read":
+      return "google.drive.read";
+    case "google.drive.write":
+    case "drive.write":
+      return "google.drive.write";
+    default:
+      return null;
+  }
+}
+function googleSideForAccount(account) {
+  return account.role === "AGENT" ? "agent" : "owner";
+}
+function googleCapabilitiesForAccount(account) {
+  const meta = metadata(account);
+  const values = [
+    ...stringArray(meta.grantedCapabilities),
+    ...stringArray(meta.capabilities),
+    ...stringArray(meta.googleCapabilities)
+  ];
+  const scopes = stringArray(meta.grantedScopes);
+  if (scopes.some((scope) => scope.includes("calendar"))) {
+    values.push("google.calendar.read");
+  }
+  if (scopes.some((scope) => scope.includes("calendar.events"))) {
+    values.push("google.calendar.write");
+  }
+  if (scopes.some((scope) => scope.includes("gmail.readonly"))) {
+    values.push("google.gmail.triage");
+  }
+  if (scopes.some((scope) => scope.includes("gmail.send"))) {
+    values.push("google.gmail.send");
+  }
+  if (scopes.some(
+    (scope) => scope.includes("gmail.modify") || scope.includes("gmail.settings")
+  )) {
+    values.push("google.gmail.manage");
+  }
+  if (scopes.some((scope) => scope.includes("drive"))) {
+    values.push("google.drive.read");
+  }
+  if (scopes.some(
+    (scope) => scope.includes("drive.file") || scope.endsWith("/auth/drive")
+  )) {
+    values.push("google.drive.write");
+  }
+  const normalized = /* @__PURE__ */ new Set([
+    "google.basic_identity"
+  ]);
+  for (const value of values) {
+    const capability = mapGoogleCapability(value);
+    if (capability) {
+      normalized.add(capability);
+    }
+  }
+  if (normalized.has("google.calendar.write")) {
+    normalized.add("google.calendar.read");
+  }
+  if (normalized.has("google.gmail.send") || normalized.has("google.gmail.manage")) {
+    normalized.add("google.gmail.triage");
+  }
+  if (normalized.has("google.drive.write")) {
+    normalized.add("google.drive.read");
+  }
+  return [...normalized];
+}
+function googleScopesForAccount(account, capabilities = googleCapabilitiesForAccount(account)) {
+  const scopes = stringArray(metadata(account).grantedScopes);
+  if (scopes.length > 0) {
+    return scopes;
+  }
+  const derived = /* @__PURE__ */ new Set([
+    "https://www.googleapis.com/auth/userinfo.email",
+    "https://www.googleapis.com/auth/userinfo.profile"
+  ]);
+  if (capabilities.includes("google.calendar.read")) {
+    derived.add("https://www.googleapis.com/auth/calendar.readonly");
+  }
+  if (capabilities.includes("google.calendar.write")) {
+    derived.add("https://www.googleapis.com/auth/calendar.events");
+  }
+  if (capabilities.includes("google.gmail.triage")) {
+    derived.add("https://www.googleapis.com/auth/gmail.readonly");
+  }
+  if (capabilities.includes("google.gmail.send")) {
+    derived.add("https://www.googleapis.com/auth/gmail.send");
+  }
+  if (capabilities.includes("google.gmail.manage")) {
+    derived.add("https://www.googleapis.com/auth/gmail.modify");
+    derived.add("https://www.googleapis.com/auth/gmail.settings.basic");
+  }
+  if (capabilities.includes("google.drive.read")) {
+    derived.add("https://www.googleapis.com/auth/drive.readonly");
+  }
+  if (capabilities.includes("google.drive.write")) {
+    derived.add("https://www.googleapis.com/auth/drive.file");
+  }
+  return [...derived];
+}
+function googleIdentityForAccount(account) {
+  const meta = metadata(account);
+  const identity = isRecord(meta.identity) ? { ...meta.identity } : {};
+  const externalId = stringValue(account.externalId);
+  const handle = stringValue(account.handle);
+  const label = stringValue(account.label);
+  if (externalId) {
+    identity.sub ??= externalId;
+  }
+  if (handle) {
+    identity.email ??= handle;
+  }
+  if (label) {
+    identity.name ??= label;
+  }
+  if (account.avatarUrl) {
+    identity.picture ??= account.avatarUrl;
+  }
+  for (const key of ["email", "name", "picture", "locale"]) {
+    const value = stringValue(meta[key]);
+    if (value) {
+      identity[key] = value;
+    }
+  }
+  return Object.keys(identity).length > 0 ? identity : null;
+}
+function googleAccountEmail(account) {
+  const identity = googleIdentityForAccount(account);
+  return (stringValue(identity?.email) ?? stringValue(account.handle) ?? null)?.toLowerCase() ?? null;
+}
+function isConnectedGoogleAccount(account) {
+  return account.enabled !== false && account.status === "connected";
+}
+function googleGrantFromAccount(args) {
+  const { account, defaultAccountId } = args;
+  const capabilities = googleCapabilitiesForAccount(account);
+  const meta = metadata(account);
+  const updatedAt = new Date(account.updatedAt ?? Date.now()).toISOString();
+  const createdAt = new Date(account.createdAt ?? Date.now()).toISOString();
+  const preferredByAgent = account.isDefault === true || account.id === defaultAccountId || booleanValue(meta.isDefault);
+  return {
+    id: googleGrantIdForAccount(account.id),
+    agentId: "",
+    provider: "google",
+    connectorAccountId: account.id,
+    side: googleSideForAccount(account),
+    identity: googleIdentityForAccount(account) ?? {},
+    identityEmail: googleAccountEmail(account),
+    grantedScopes: googleScopesForAccount(account, capabilities),
+    capabilities,
+    tokenRef: null,
+    mode: "local",
+    executionTarget: "local",
+    sourceOfTruth: "connector_account",
+    preferredByAgent,
+    cloudConnectionId: null,
+    metadata: {
+      ...meta,
+      connectorAccountId: account.id,
+      connectorAccountProvider: "google"
+    },
+    lastRefreshAt: isoString(account.lastSyncedAt) ?? updatedAt,
+    createdAt,
+    updatedAt
+  };
+}
+function googleStatusFromConnectorAccount(args) {
+  const { account } = args;
+  const grant = googleGrantFromAccount(args);
+  const connected = isConnectedGoogleAccount(account);
+  const meta = metadata(account);
+  const reason = account.status === "needs-reauth" || account.status === "error" ? "needs_reauth" : connected ? "connected" : "disconnected";
+  return {
+    provider: "google",
+    side: grant.side,
+    mode: "local",
+    defaultMode: "local",
+    availableModes: ["local"],
+    executionTarget: "local",
+    sourceOfTruth: "connector_account",
+    configured: true,
+    connected,
+    reason,
+    preferredByAgent: grant.preferredByAgent,
+    cloudConnectionId: null,
+    identity: googleIdentityForAccount(account),
+    grantedCapabilities: [...grant.capabilities],
+    grantedScopes: [...grant.grantedScopes],
+    expiresAt: isoString(meta.expiresAt),
+    hasRefreshToken: booleanValue(meta.hasRefreshToken) || Boolean(stringValue(meta.refreshTokenRef)),
+    grant
+  };
+}
+function disconnectedGoogleStatus(side) {
+  return {
+    provider: "google",
+    side,
+    mode: "local",
+    defaultMode: "local",
+    availableModes: ["local"],
+    executionTarget: "local",
+    sourceOfTruth: "connector_account",
+    configured: false,
+    connected: false,
+    reason: "disconnected",
+    preferredByAgent: false,
+    cloudConnectionId: null,
+    identity: null,
+    grantedCapabilities: [],
+    grantedScopes: [],
+    expiresAt: null,
+    hasRefreshToken: false,
+    grant: null
+  };
+}
+function googleStatusesFromConnectorAccounts(response, side) {
+  return response.accounts.filter(
+    (account) => side ? googleSideForAccount(account) === side : true
+  ).map(
+    (account) => googleStatusFromConnectorAccount({
+      account,
+      defaultAccountId: response.defaultAccountId ?? null
+    })
+  );
+}
+function selectGoogleStatus(statuses, side) {
+  const sideStatuses = statuses.filter((status) => status.side === side);
+  return sideStatuses.find(
+    (status) => status.connected && status.preferredByAgent
+  ) ?? sideStatuses.find((status) => status.connected) ?? sideStatuses[0] ?? disconnectedGoogleStatus(side);
+}
+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/connectors/google/accounts");
+}
+function uniqueModes(modes) {
+  const ordered = [];
+  const seen = /* @__PURE__ */ 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 readRefreshEnvelope(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  return {
+    type: value.type,
+    detail: value.detail
+  };
+}
+function normalizeRefreshDetail(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const side = value.side === "owner" || value.side === "agent" ? value.side : void 0;
+  const mode = value.mode === "local" ? value.mode : void 0;
+  const source = value.source === "callback" || value.source === "connect" || value.source === "disconnect" || value.source === "mode_change" || value.source === "refresh" || value.source === "focus" || value.source === "visibility" || value.source === "resume" ? value.source : void 0;
+  return {
+    origin: typeof value.origin === "string" && value.origin.trim().length > 0 ? value.origin.trim() : void 0,
+    side,
+    mode,
+    source
+  };
+}
+function parseRefreshEnvelope(rawValue) {
+  try {
+    return readRefreshEnvelope(JSON.parse(rawValue));
+  } catch {
+    return null;
+  }
+}
+function useGoogleLifeOpsConnector(options = {}) {
+  const agentStatus = useAppSelector((s) => s.agentStatus);
+  const backendConnection = useAppSelector((s) => s.backendConnection);
+  const startupPhase = useAppSelector((s) => s.startupPhase);
+  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(void 0);
+  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 [error, setError] = useState(null);
+  const runtimeReady = isLifeOpsRuntimeReady({
+    startupPhase,
+    agentState: agentStatus?.state ?? null,
+    backendState: backendConnection.state
+  });
+  const refresh = useCallback(
+    async ({
+      silent = false,
+      mode
+    } = {}) => {
+      if (!runtimeReady) {
+        setError(null);
+        setLoading(false);
+        return;
+      }
+      if (!silent) {
+        setLoading(true);
+      }
+      try {
+        const requestedMode = mode === void 0 ? selectedModeRef.current : mode;
+        const response = await client.listConnectorAccounts("google");
+        const statuses = googleStatusesFromConnectorAccounts(response);
+        const nextStatus = selectGoogleStatus(statuses, side);
+        const nextAccounts = includeAccounts ? googleStatusesFromConnectorAccounts(response, side) : [];
+        const nextSelectedMode = requestedMode ?? nextStatus.mode;
+        selectedModeRef.current = nextSelectedMode;
+        setSelectedMode(nextSelectedMode);
+        setStatus(nextStatus);
+        setAccounts(nextAccounts);
+        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 !== void 0) {
+        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 = void 0;
+        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 = readRefreshEnvelope(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 = readRefreshEnvelope(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 {
+        const response = await client.listConnectorAccounts("google");
+        const nextStatus = selectGoogleStatus(
+          googleStatusesFromConnectorAccounts(response),
+          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.")
+        );
+      }
+    },
+    [side]
+  );
+  const modeOptions = useMemo(() => resolveVisibleModes(status), [status]);
+  const activeMode = selectedMode ?? status?.mode ?? status?.defaultMode ?? "local";
+  return {
+    accounts,
+    activeMode,
+    error,
+    loading,
+    modeOptions,
+    refresh,
+    selectMode,
+    selectedMode,
+    side,
+    status
+  };
+}
+export {
+  useGoogleLifeOpsConnector
+};
+//# sourceMappingURL=useGoogleLifeOpsConnector.js.map