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

package/dist/actions/connector.js

@@ -0,0 +1,1354 @@
+import { extractActionParamsViaLlm } from "@elizaos/agent";
+import { hasLifeOpsAccess, INTERNAL_URL } from "../lifeops/access.js";
+import { getConnectorRegistry } from "../lifeops/connectors/index.js";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+import { darwinUnavailableActionResult, isDarwin } from "../platform/host.js";
+const ACTION_NAME = "CONNECTOR";
+const VERBOSE_DISPATCHER_KINDS = [
+  "google",
+  "x",
+  "telegram",
+  "signal",
+  "discord",
+  "imessage",
+  "whatsapp",
+  "health",
+  "browser_bridge"
+];
+const VALID_SUBACTIONS = [
+  "connect",
+  "disconnect",
+  "verify",
+  "status",
+  "list"
+];
+const MESSAGE_CONNECTOR_SOURCE_BY_LIFEOPS_CONNECTOR = {
+  x: "x",
+  telegram: "telegram",
+  signal: "signal",
+  discord: "discord",
+  imessage: "imessage",
+  whatsapp: "whatsapp"
+};
+function normalizeConnectorKind(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase().replace(/[- ]/g, "_");
+  return normalized.length > 0 ? normalized : null;
+}
+function listKnownConnectorKinds(runtime) {
+  const registry = getConnectorRegistry(runtime);
+  const fromRegistry = registry ? registry.list().map((contribution) => contribution.kind) : [];
+  const verboseKinds = isDarwin() ? VERBOSE_DISPATCHER_KINDS : VERBOSE_DISPATCHER_KINDS.filter((kind) => kind !== "imessage");
+  return [.../* @__PURE__ */ new Set([...verboseKinds, ...fromRegistry])];
+}
+function isValidConnectorKind(runtime, kind) {
+  return listKnownConnectorKinds(runtime).includes(kind);
+}
+function normalizeSubaction(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  return VALID_SUBACTIONS.includes(normalized) ? normalized : null;
+}
+function normalizeSide(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "owner" || normalized === "agent" ? normalized : void 0;
+}
+function mergeParams(message, options) {
+  const params = {
+    ...options?.parameters ?? {}
+  };
+  if (message.content && typeof message.content === "object") {
+    for (const [key, value] of Object.entries(
+      message.content
+    )) {
+      if (params[key] === void 0) {
+        params[key] = value;
+      }
+    }
+  }
+  return params;
+}
+function unsupportedOperation(connector, subaction, detail) {
+  const text = `[${ACTION_NAME}] ${connector}/${subaction} is not supported by the current LifeOps connector contract.` + (detail ? ` ${detail}` : "");
+  return {
+    success: false,
+    text,
+    data: {
+      actionName: ACTION_NAME,
+      connector,
+      subaction,
+      error: "UNSUPPORTED_OPERATION"
+    }
+  };
+}
+function getRuntimeMessageConnector(runtime, connector) {
+  const source = MESSAGE_CONNECTOR_SOURCE_BY_LIFEOPS_CONNECTOR[connector];
+  if (!source) {
+    return null;
+  }
+  const runtimeWithConnectors = runtime;
+  if (typeof runtimeWithConnectors.getMessageConnectors !== "function") {
+    return null;
+  }
+  const normalized = source.trim().toLowerCase();
+  return runtimeWithConnectors.getMessageConnectors().find(
+    (registration) => registration.source.trim().toLowerCase() === normalized && (registration.capabilities.length === 0 || registration.capabilities.includes("send_message"))
+  ) ?? null;
+}
+function registryStatusResult(runtime, connector, subaction) {
+  const registration = getRuntimeMessageConnector(runtime, connector);
+  if (!registration) {
+    return null;
+  }
+  return {
+    success: true,
+    text: `${registration.label} is registered in the core message connector registry. Detailed chat/user context is exposed by platform providers.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector,
+      subaction,
+      statusSource: "core_message_connector_registry",
+      status: {
+        provider: connector,
+        source: registration.source,
+        label: registration.label,
+        connected: true,
+        registered: true,
+        capabilities: registration.capabilities,
+        supportedTargetKinds: registration.supportedTargetKinds,
+        contexts: registration.contexts,
+        description: registration.description,
+        metadata: registration.metadata
+      }
+    }
+  };
+}
+async function sendVerificationThroughRegistry(args) {
+  const target = args.target?.trim();
+  if (!target) {
+    return null;
+  }
+  const registration = getRuntimeMessageConnector(args.runtime, args.connector);
+  if (!registration) {
+    return null;
+  }
+  try {
+    await args.runtime.sendMessageToTarget(
+      {
+        source: registration.source,
+        channelId: target
+      },
+      {
+        text: args.text,
+        source: registration.source,
+        metadata: {
+          actionName: ACTION_NAME,
+          verification: true
+        }
+      }
+    );
+    return {
+      ok: true,
+      routedBy: "core_message_connector_registry",
+      source: registration.source,
+      target
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      routedBy: "core_message_connector_registry",
+      source: registration.source,
+      target,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function dispatchListAll(context) {
+  const { runtime, service } = context;
+  const registryOrReadStatus = async (connector, readStatus) => {
+    const registryStatus = registryStatusResult(runtime, connector, "list")?.data;
+    return registryStatus?.status ?? await readStatus();
+  };
+  const [
+    google,
+    x,
+    telegram,
+    signal,
+    discord,
+    imessage,
+    whatsapp,
+    health,
+    browserSettings,
+    browserCompanions
+  ] = await Promise.all([
+    service.getGoogleConnectorStatus(INTERNAL_URL),
+    registryOrReadStatus("x", () => service.getXConnectorStatus()),
+    registryOrReadStatus(
+      "telegram",
+      () => service.getTelegramConnectorStatus()
+    ),
+    registryOrReadStatus("signal", () => service.getSignalConnectorStatus()),
+    registryOrReadStatus("discord", () => service.getDiscordConnectorStatus()),
+    registryOrReadStatus(
+      "imessage",
+      () => service.getIMessageConnectorStatus()
+    ),
+    registryOrReadStatus(
+      "whatsapp",
+      () => service.getWhatsAppConnectorStatus()
+    ),
+    service.getHealthDataConnectorStatuses(INTERNAL_URL),
+    service.getBrowserSettings(),
+    service.listBrowserCompanions()
+  ]);
+  const known = listKnownConnectorKinds(runtime);
+  return {
+    success: true,
+    text: `Listed status for ${known.length} LifeOps connectors.`,
+    data: {
+      actionName: ACTION_NAME,
+      connectorKinds: known,
+      connectors: {
+        google,
+        x,
+        telegram,
+        signal,
+        discord,
+        imessage,
+        whatsapp,
+        health,
+        browser_bridge: {
+          settings: browserSettings,
+          companions: browserCompanions
+        }
+      }
+    }
+  };
+}
+async function dispatchGoogle({ service }, subaction, params) {
+  const side = normalizeSide(params.side) ?? "owner";
+  switch (subaction) {
+    case "connect": {
+      const response = await service.startGoogleConnector(
+        {
+          side,
+          mode: params.mode,
+          capabilities: params.capabilities,
+          redirectUrl: params.redirectUrl
+        },
+        INTERNAL_URL
+      );
+      return {
+        success: true,
+        text: response.authUrl ? `Open this URL to finish Google connect: ${response.authUrl}` : `Google connector started for side=${side}, mode=${response.mode}.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "google",
+          subaction,
+          response
+        }
+      };
+    }
+    case "disconnect": {
+      const status = await service.disconnectGoogleConnector(
+        { side, mode: params.mode },
+        INTERNAL_URL
+      );
+      return {
+        success: true,
+        text: `Google connector disconnected (side=${side}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "google",
+          subaction,
+          status
+        }
+      };
+    }
+    case "status":
+    case "list": {
+      const status = await service.getGoogleConnectorStatus(
+        INTERNAL_URL,
+        params.mode,
+        side
+      );
+      return {
+        success: true,
+        text: `Google connector status retrieved (side=${side}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "google",
+          subaction,
+          status
+        }
+      };
+    }
+    case "verify":
+      return await dispatchGoogleVerify(service, side, params);
+  }
+}
+async function dispatchGoogleVerify(service, side, params) {
+  const status = await service.getGoogleConnectorStatus(
+    INTERNAL_URL,
+    params.mode,
+    side
+  );
+  const capabilities = new Set(status.grantedCapabilities);
+  let gmailRead;
+  if (status.connected && capabilities.has("google.gmail.triage")) {
+    const triage = await service.getGmailTriage(INTERNAL_URL, {
+      mode: params.mode,
+      side,
+      maxResults: params.recentLimit ?? 10,
+      forceSync: true
+    });
+    gmailRead = {
+      ok: true,
+      count: triage.messages.length,
+      summary: triage.summary,
+      messages: triage.messages
+    };
+  } else {
+    gmailRead = {
+      ok: false,
+      skipped: true,
+      reason: status.connected ? "google.gmail.triage capability not granted" : status.reason
+    };
+  }
+  let calendarRead;
+  if (status.connected && capabilities.has("google.calendar.read")) {
+    const now = Date.now();
+    const feed = await service.getCalendarFeed(INTERNAL_URL, {
+      mode: params.mode,
+      side,
+      timeMin: new Date(now - 60 * 60 * 1e3).toISOString(),
+      timeMax: new Date(now + 7 * 24 * 60 * 60 * 1e3).toISOString()
+    });
+    calendarRead = {
+      ok: true,
+      count: feed.events.length,
+      events: feed.events
+    };
+  } else {
+    calendarRead = {
+      ok: false,
+      skipped: true,
+      reason: status.connected ? "google.calendar.read capability not granted" : status.reason
+    };
+  }
+  const read = { gmail: gmailRead, calendar: calendarRead };
+  const send = params.sendTarget ? await service.sendGmailMessage(INTERNAL_URL, {
+    mode: params.mode,
+    side,
+    to: [params.sendTarget],
+    subject: "LifeOps Google connector verification",
+    bodyText: params.sendMessage ?? "LifeOps Google connector verification ping.",
+    confirmSend: true
+  }) : null;
+  return {
+    success: status.connected && (!params.sendTarget || send?.ok === true),
+    text: `Google verify: status=${status.connected ? "connected" : "disconnected"}, gmail=${read.gmail.ok ? "ok" : "skipped"}, calendar=${read.calendar.ok ? "ok" : "skipped"}, send=${send ? "ok" : "skipped"}.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector: "google",
+      subaction: "verify",
+      status,
+      read,
+      send
+    }
+  };
+}
+async function dispatchX({ runtime, service }, subaction, params) {
+  const side = normalizeSide(params.side) ?? "owner";
+  switch (subaction) {
+    case "connect": {
+      const status = await service.getXConnectorStatus(params.mode, side);
+      return {
+        success: status.connected,
+        text: status.connected ? `X is connected through @elizaos/plugin-x (side=${side}).` : `X setup is managed by @elizaos/plugin-x (side=${side}). Configure the X connector plugin, then check status again.`,
+        data: { actionName: ACTION_NAME, connector: "x", subaction, status }
+      };
+    }
+    case "disconnect": {
+      const status = await service.getXConnectorStatus(params.mode, side);
+      return {
+        success: false,
+        text: `X disconnect is managed by @elizaos/plugin-x (side=${side}). Use the X connector plugin setup controls, then check status again.`,
+        data: { actionName: ACTION_NAME, connector: "x", subaction, status }
+      };
+    }
+    case "status":
+    case "list": {
+      const registryStatus = registryStatusResult(runtime, "x", subaction);
+      if (registryStatus) {
+        return registryStatus;
+      }
+      const status = await service.getXConnectorStatus(params.mode, side);
+      return {
+        success: true,
+        text: `X connector status retrieved (side=${side}).`,
+        data: { actionName: ACTION_NAME, connector: "x", subaction, status }
+      };
+    }
+    case "verify":
+      return await dispatchXVerify(runtime, service, side, params);
+  }
+}
+async function dispatchXVerify(runtime, service, side, params) {
+  const status = await service.getXConnectorStatus(params.mode, side);
+  const limit = params.recentLimit ?? 10;
+  const query = params.query?.trim();
+  const search = query && status.feedRead ? {
+    ok: true,
+    query,
+    items: await service.searchXPosts(query, { limit })
+  } : query ? {
+    ok: false,
+    query,
+    skipped: true,
+    reason: "x.read capability not granted"
+  } : null;
+  const inbound = status.dmInbound ? await service.readXInboundDms({ limit }) : [];
+  const sendText = params.sendMessage ?? "LifeOps X connector verification ping.";
+  const send = await sendVerificationThroughRegistry({
+    runtime,
+    connector: "x",
+    target: params.sendTarget,
+    text: sendText
+  }) ?? (params.sendTarget ? await service.sendXDirectMessage({
+    participantId: params.sendTarget,
+    text: sendText,
+    mode: params.mode,
+    side,
+    confirmSend: true
+  }) : null);
+  let searchSummary = "skipped";
+  const searchItems = search && "items" in search && Array.isArray(search.items) ? search.items : null;
+  if (query && searchItems) {
+    const hitCount = searchItems.length;
+    searchSummary = `${hitCount} hit${hitCount === 1 ? "" : "s"}`;
+  }
+  return {
+    success: status.connected && (!params.sendTarget || send?.ok === true),
+    text: `X verify: status=${status.connected ? "connected" : "disconnected"}, read=${inbound.length} inbound DM${inbound.length === 1 ? "" : "s"}, search=${searchSummary}, send=${send ? "ok" : "skipped"}.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector: "x",
+      subaction: "verify",
+      status,
+      read: { ok: status.dmInbound, count: inbound.length, messages: inbound },
+      search,
+      send
+    }
+  };
+}
+async function dispatchHealth({ service }, subaction, params) {
+  const side = normalizeSide(params.side) ?? "owner";
+  switch (subaction) {
+    case "status":
+    case "list": {
+      const [bridge, connectors] = await Promise.all([
+        service.getHealthConnectorStatus(),
+        service.getHealthDataConnectorStatuses(INTERNAL_URL, params.mode, side)
+      ]);
+      const connectedProviderCount = connectors.filter(
+        (connector) => connector.connected
+      ).length;
+      return {
+        success: true,
+        text: `Health connector status retrieved (${connectedProviderCount} connected provider${connectedProviderCount === 1 ? "" : "s"}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "health",
+          subaction,
+          bridge,
+          connectors
+        }
+      };
+    }
+    case "connect":
+      return unsupportedOperation(
+        "health",
+        subaction,
+        "Use LifeOps Settings to choose Strava, Fitbit, Withings, or Oura before starting OAuth."
+      );
+    case "disconnect":
+      return unsupportedOperation(
+        "health",
+        subaction,
+        "Disconnect a specific Strava, Fitbit, Withings, or Oura provider from LifeOps Settings."
+      );
+    case "verify": {
+      const [bridge, connectors] = await Promise.all([
+        service.getHealthConnectorStatus(),
+        service.getHealthDataConnectorStatuses(INTERNAL_URL, params.mode, side)
+      ]);
+      const connectedProviderCount = connectors.filter(
+        (item) => item.connected
+      ).length;
+      return {
+        success: bridge.available || connectedProviderCount > 0,
+        text: `Health verify: bridge=${bridge.available ? "available" : "unavailable"}, connectedProviders=${connectedProviderCount}.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "health",
+          subaction,
+          bridge,
+          connectors
+        }
+      };
+    }
+  }
+}
+async function dispatchTelegram({ runtime, service }, subaction, params) {
+  const side = normalizeSide(params.side) ?? "owner";
+  switch (subaction) {
+    case "connect": {
+      const status = await service.getTelegramConnectorStatus(side);
+      return {
+        success: status.connected,
+        text: status.connected ? `Telegram is connected through @elizaos/plugin-telegram (side=${side}).` : `Telegram connection is managed by @elizaos/plugin-telegram (side=${side}). Configure the Telegram connector plugin, then check status again.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "telegram",
+          subaction,
+          status
+        }
+      };
+    }
+    case "disconnect": {
+      const status = await service.getTelegramConnectorStatus(side);
+      return {
+        success: false,
+        text: `Telegram disconnect is managed by @elizaos/plugin-telegram (side=${side}). Use the Telegram connector plugin setup controls, then check status again.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "telegram",
+          subaction,
+          status
+        }
+      };
+    }
+    case "verify": {
+      const registrySend = await sendVerificationThroughRegistry({
+        runtime,
+        connector: "telegram",
+        target: params.sendTarget,
+        text: params.sendMessage ?? "LifeOps Telegram connector verification ping."
+      });
+      const response = await service.verifyTelegramConnector({
+        side,
+        recentLimit: params.recentLimit,
+        sendTarget: registrySend ? void 0 : params.sendTarget,
+        sendMessage: registrySend ? void 0 : params.sendMessage
+      });
+      const send = registrySend ?? response.send;
+      return {
+        success: response.read.ok && send.ok,
+        text: `Telegram verify: read=${response.read.ok ? "ok" : "fail"}, send=${send.ok ? "ok" : "fail"}.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "telegram",
+          subaction,
+          response: { ...response, send }
+        }
+      };
+    }
+    case "status":
+    case "list": {
+      const registryStatus = registryStatusResult(
+        runtime,
+        "telegram",
+        subaction
+      );
+      if (registryStatus) {
+        return registryStatus;
+      }
+      const status = await service.getTelegramConnectorStatus(side);
+      return {
+        success: true,
+        text: `Telegram connector status retrieved (side=${side}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "telegram",
+          subaction,
+          status
+        }
+      };
+    }
+  }
+}
+async function dispatchSignal({ runtime, service }, subaction, params) {
+  const side = normalizeSide(params.side) ?? "owner";
+  switch (subaction) {
+    case "connect": {
+      const status = await service.getSignalConnectorStatus(side);
+      return {
+        success: status.connected,
+        text: status.connected ? `Signal is connected through @elizaos/plugin-signal (side=${side}).` : `Signal pairing is managed by @elizaos/plugin-signal (side=${side}). Configure the Signal connector plugin, then check status again.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "signal",
+          subaction,
+          status
+        }
+      };
+    }
+    case "disconnect": {
+      const status = await service.getSignalConnectorStatus(side);
+      return {
+        success: false,
+        text: `Signal disconnect is managed by @elizaos/plugin-signal (side=${side}). Use the Signal connector plugin setup controls, then check status again.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "signal",
+          subaction,
+          status
+        }
+      };
+    }
+    case "status":
+    case "list": {
+      const registryStatus = registryStatusResult(runtime, "signal", subaction);
+      if (registryStatus) {
+        return registryStatus;
+      }
+      const status = await service.getSignalConnectorStatus(side);
+      return {
+        success: true,
+        text: `Signal connector status retrieved (side=${side}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "signal",
+          subaction,
+          status
+        }
+      };
+    }
+    case "verify":
+      return await dispatchSignalVerify(runtime, service, side, params);
+  }
+}
+async function dispatchSignalVerify(runtime, service, side, params) {
+  const limit = params.recentLimit ?? 10;
+  const status = await service.getSignalConnectorStatus(side);
+  let messages = [];
+  let readError = null;
+  if (status.inbound) {
+    try {
+      messages = await service.readSignalInbound(limit, side);
+    } catch (error) {
+      readError = error instanceof Error ? error.message : String(error);
+    }
+  } else {
+    readError = "Signal plugin inbound read is unavailable.";
+  }
+  const sendText = params.sendMessage ?? "LifeOps Signal connector verification ping.";
+  let send = null;
+  let sendError = null;
+  if (params.sendTarget) {
+    try {
+      send = await sendVerificationThroughRegistry({
+        runtime,
+        connector: "signal",
+        target: params.sendTarget,
+        text: sendText
+      }) ?? await service.sendSignalMessage({
+        side,
+        recipient: params.sendTarget,
+        text: sendText
+      });
+    } catch (error) {
+      sendError = error instanceof Error ? error.message : String(error);
+    }
+  }
+  const readOk = readError === null;
+  const sendOk = !params.sendTarget || send?.ok === true;
+  return {
+    success: status.connected && readOk && sendOk,
+    text: `Signal verify: status=${status.connected ? "connected" : "disconnected"}, read=${readOk ? `${messages.length} message${messages.length === 1 ? "" : "s"}` : "failed"}, send=${params.sendTarget ? sendOk ? "ok" : "failed" : "skipped"}.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector: "signal",
+      subaction: "verify",
+      status,
+      read: { ok: readOk, error: readError, count: messages.length, messages },
+      send: send ? { ...send, error: sendError } : { ok: !params.sendTarget, error: sendError }
+    }
+  };
+}
+async function dispatchDiscord({ runtime, service }, subaction, params) {
+  const side = normalizeSide(params.side) ?? "owner";
+  switch (subaction) {
+    case "connect": {
+      const status = await service.getDiscordConnectorStatus(side);
+      return {
+        success: status.connected,
+        text: status.connected ? `Discord is connected through @elizaos/plugin-discord (side=${side}).` : `Discord setup is managed by @elizaos/plugin-discord (side=${side}). Configure the Discord connector plugin, then check status again.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "discord",
+          subaction,
+          status
+        }
+      };
+    }
+    case "disconnect": {
+      const status = await service.getDiscordConnectorStatus(side);
+      return {
+        success: false,
+        text: `Discord disconnect is managed by @elizaos/plugin-discord (side=${side}). Use the Discord connector plugin setup controls, then check status again.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "discord",
+          subaction,
+          status
+        }
+      };
+    }
+    case "status":
+    case "list": {
+      const registryStatus = registryStatusResult(
+        runtime,
+        "discord",
+        subaction
+      );
+      if (registryStatus) {
+        return registryStatus;
+      }
+      const status = await service.getDiscordConnectorStatus(side);
+      return {
+        success: true,
+        text: `Discord connector status retrieved (side=${side}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "discord",
+          subaction,
+          status
+        }
+      };
+    }
+    case "verify":
+      return await dispatchDiscordVerify(runtime, service, side, params);
+  }
+}
+async function dispatchDiscordVerify(runtime, service, side, params) {
+  const status = await service.getDiscordConnectorStatus(side);
+  const query = params.query?.trim();
+  const hits = query ? await service.searchDiscordMessages({
+    side,
+    query,
+    channelId: params.sendTarget
+  }) : [];
+  const sendText = params.sendMessage ?? "LifeOps Discord connector verification ping.";
+  const send = await sendVerificationThroughRegistry({
+    runtime,
+    connector: "discord",
+    target: params.sendTarget,
+    text: sendText
+  }) ?? (params.sendTarget ? await service.sendDiscordMessage({
+    channelId: params.sendTarget,
+    text: sendText
+  }) : null);
+  return {
+    success: status.connected && (!params.sendTarget || send?.ok === true),
+    text: `Discord verify: status=${status.connected ? "connected" : "disconnected"}, search=${query ? `${hits.length} hit${hits.length === 1 ? "" : "s"}` : "skipped"}, send=${send ? "ok" : "skipped"}.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector: "discord",
+      subaction: "verify",
+      status,
+      search: query ? { ok: true, query, count: hits.length, hits } : null,
+      send
+    }
+  };
+}
+async function dispatchIMessage({ runtime, service }, subaction, params) {
+  if (!isDarwin()) {
+    return darwinUnavailableActionResult({
+      actionName: ACTION_NAME,
+      connector: "imessage",
+      subaction,
+      feature: "iMessage"
+    });
+  }
+  switch (subaction) {
+    case "status":
+    case "list": {
+      const registryStatus = registryStatusResult(
+        runtime,
+        "imessage",
+        subaction
+      );
+      if (registryStatus) {
+        return registryStatus;
+      }
+      const status = await service.getIMessageConnectorStatus();
+      return {
+        success: true,
+        text: `iMessage connector status retrieved.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "imessage",
+          subaction,
+          status
+        }
+      };
+    }
+    case "connect":
+      return unsupportedOperation(
+        "imessage",
+        subaction,
+        "iMessage uses the native macOS bridge; nothing to connect via the agent action layer. Inspect status to see bridge readiness."
+      );
+    case "disconnect":
+      return unsupportedOperation(
+        "imessage",
+        subaction,
+        "iMessage disconnect is not exposed by LifeOpsService."
+      );
+    case "verify":
+      return await dispatchIMessageVerify(runtime, service, params);
+  }
+}
+async function dispatchIMessageVerify(runtime, service, params) {
+  const limit = params.recentLimit ?? 10;
+  const [status, messages] = await Promise.all([
+    service.getIMessageConnectorStatus(),
+    service.readIMessages({ limit })
+  ]);
+  const sendText = params.sendMessage ?? "LifeOps iMessage connector verification ping.";
+  const send = await sendVerificationThroughRegistry({
+    runtime,
+    connector: "imessage",
+    target: params.sendTarget,
+    text: sendText
+  }) ?? (params.sendTarget ? await service.sendIMessage({
+    to: params.sendTarget,
+    text: sendText
+  }) : null);
+  return {
+    success: status.connected && (!params.sendTarget || send?.ok === true),
+    text: `iMessage verify: status=${status.connected ? "connected" : "disconnected"}, read=${messages.length} message${messages.length === 1 ? "" : "s"}, send=${send ? "ok" : "skipped"}.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector: "imessage",
+      subaction: "verify",
+      status,
+      read: { ok: true, count: messages.length, messages },
+      send
+    }
+  };
+}
+async function dispatchWhatsApp({ runtime, service }, subaction, params) {
+  switch (subaction) {
+    case "status":
+    case "list": {
+      const registryStatus = registryStatusResult(
+        runtime,
+        "whatsapp",
+        subaction
+      );
+      if (registryStatus) {
+        return registryStatus;
+      }
+      const status = await service.getWhatsAppConnectorStatus();
+      return {
+        success: true,
+        text: `WhatsApp connector status retrieved.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "whatsapp",
+          subaction,
+          status
+        }
+      };
+    }
+    case "connect":
+      return unsupportedOperation(
+        "whatsapp",
+        subaction,
+        "WhatsApp connection is managed by @elizaos/plugin-whatsapp. Configure the WhatsApp connector plugin; LifeOps no longer owns local WhatsApp API credentials."
+      );
+    case "disconnect":
+      return unsupportedOperation(
+        "whatsapp",
+        subaction,
+        "WhatsApp disconnect is not exposed by LifeOpsService."
+      );
+    case "verify":
+      return await dispatchWhatsAppVerify(runtime, service, params);
+  }
+}
+async function dispatchWhatsAppVerify(runtime, service, params) {
+  const limit = params.recentLimit ?? 10;
+  const status = await service.getWhatsAppConnectorStatus();
+  const recent = await service.pullWhatsAppRecent(limit);
+  const sendText = params.sendMessage ?? "LifeOps WhatsApp connector verification ping.";
+  const send = await sendVerificationThroughRegistry({
+    runtime,
+    connector: "whatsapp",
+    target: params.sendTarget,
+    text: sendText
+  }) ?? (params.sendTarget ? await service.sendWhatsAppMessage({
+    to: params.sendTarget,
+    text: sendText
+  }) : null);
+  return {
+    success: status.connected && (!params.sendTarget || send?.ok === true),
+    text: `WhatsApp verify: status=${status.connected ? "connected" : "disconnected"}, read=${recent.count} message${recent.count === 1 ? "" : "s"}, send=${send ? "ok" : "skipped"}.`,
+    data: {
+      actionName: ACTION_NAME,
+      connector: "whatsapp",
+      subaction: "verify",
+      status,
+      read: { ok: true, count: recent.count, messages: recent.messages },
+      send
+    }
+  };
+}
+async function dispatchBrowserBridge({ service }, subaction, _params) {
+  switch (subaction) {
+    case "connect": {
+      const [settings, companions] = await Promise.all([
+        service.getBrowserSettings(),
+        service.listBrowserCompanions()
+      ]);
+      return {
+        success: companions.length > 0,
+        text: companions.length > 0 ? `Browser bridge is configured through @elizaos/plugin-browser (${companions.length} companion${companions.length === 1 ? "" : "s"}).` : "Browser bridge setup is managed by @elizaos/plugin-browser. Configure the browser companion plugin, then check status again.",
+        data: {
+          actionName: ACTION_NAME,
+          connector: "browser_bridge",
+          subaction,
+          settings,
+          companions
+        }
+      };
+    }
+    case "status": {
+      const [settings, companions] = await Promise.all([
+        service.getBrowserSettings(),
+        service.listBrowserCompanions()
+      ]);
+      return {
+        success: true,
+        text: `Browser bridge status retrieved (${companions.length} companion${companions.length === 1 ? "" : "s"}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "browser_bridge",
+          subaction,
+          settings,
+          companions
+        }
+      };
+    }
+    case "list": {
+      const companions = await service.listBrowserCompanions();
+      return {
+        success: true,
+        text: `${companions.length} browser companion${companions.length === 1 ? "" : "s"} listed.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "browser_bridge",
+          subaction,
+          companions
+        }
+      };
+    }
+    case "disconnect":
+      return unsupportedOperation(
+        "browser_bridge",
+        subaction,
+        "Browser companion disconnect is not exposed by LifeOpsService."
+      );
+    case "verify": {
+      const [settings, companions] = await Promise.all([
+        service.getBrowserSettings(),
+        service.listBrowserCompanions()
+      ]);
+      const connected = companions.some(
+        (companion) => companion.connectionState === "connected"
+      );
+      return {
+        success: connected,
+        text: `Browser bridge verify: ${connected ? "connected" : "disconnected"} (${companions.length} companion${companions.length === 1 ? "" : "s"}).`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: "browser_bridge",
+          subaction,
+          settings,
+          companions,
+          verification: {
+            connected
+          }
+        }
+      };
+    }
+  }
+}
+const VERBOSE_DISPATCHERS = {
+  google: dispatchGoogle,
+  x: dispatchX,
+  telegram: dispatchTelegram,
+  signal: dispatchSignal,
+  discord: dispatchDiscord,
+  imessage: dispatchIMessage,
+  whatsapp: dispatchWhatsApp,
+  health: dispatchHealth,
+  browser_bridge: dispatchBrowserBridge
+};
+async function dispatchGenericRegistry(context, subaction, params, connectorKind) {
+  const registry = getConnectorRegistry(context.runtime);
+  const contribution = registry?.get(connectorKind);
+  if (!contribution) {
+    return {
+      success: false,
+      text: `[${ACTION_NAME}] no connector contribution registered for "${connectorKind}".`,
+      data: {
+        actionName: ACTION_NAME,
+        connector: connectorKind,
+        error: "CONNECTOR_NOT_REGISTERED"
+      }
+    };
+  }
+  switch (subaction) {
+    case "connect": {
+      await contribution.start();
+      return {
+        success: true,
+        text: `${contribution.describe.label} start invoked.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: connectorKind,
+          subaction
+        }
+      };
+    }
+    case "disconnect": {
+      await contribution.disconnect();
+      return {
+        success: true,
+        text: `${contribution.describe.label} disconnected.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: connectorKind,
+          subaction
+        }
+      };
+    }
+    case "verify": {
+      const verified = await contribution.verify();
+      const sendResult = params.sendTarget ? await contribution.send?.({
+        target: params.sendTarget,
+        message: params.sendMessage ?? `LifeOps ${contribution.describe.label} verification ping.`
+      }) : null;
+      return {
+        success: verified && (!params.sendTarget || sendResult?.ok === true),
+        text: `${contribution.describe.label} verify: connected=${verified}, send=${sendResult ? sendResult.ok ? "ok" : "fail" : "skipped"}.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: connectorKind,
+          subaction,
+          verified,
+          send: sendResult
+        }
+      };
+    }
+    case "status":
+    case "list": {
+      const status = await contribution.status();
+      return {
+        success: true,
+        text: `${contribution.describe.label} status: ${status.state}.`,
+        data: {
+          actionName: ACTION_NAME,
+          connector: connectorKind,
+          subaction,
+          status,
+          capabilities: contribution.capabilities,
+          modes: contribution.modes,
+          requiresApproval: contribution.requiresApproval ?? false
+        }
+      };
+    }
+  }
+}
+const connectorAction = {
+  name: ACTION_NAME,
+  similes: [
+    "CONNECT_GOOGLE",
+    "CONNECT_TELEGRAM",
+    "CONNECT_DISCORD",
+    "DISCONNECT_SERVICE",
+    "CHECK_CONNECTION",
+    "SERVICE_STATUS",
+    // PRD action-catalog alias. NotificationIntent endpoint resolution maps
+    // to CONNECTOR.list + CONNECTOR.status (the registered endpoints).
+    // See packages/docs/action-prd-map.md.
+    "NOTIFICATION_RESOLVE_ENDPOINTS"
+  ],
+  tags: [
+    "domain:meta",
+    "capability:read",
+    "capability:write",
+    "capability:update",
+    "capability:delete",
+    "surface:remote-api",
+    "surface:internal"
+  ],
+  description: `Installed connector account state: connect, disconnect, verify, status, list. Actions: ${VALID_SUBACTIONS.join(", ")}. External accounts: Google, Telegram, Discord, Slack, etc. Connector kinds from runtime ConnectorRegistry; verify active upstream API probe. Plugin install/uninstall/configure -> use PLUGIN.`,
+  descriptionCompressed: "CONNECTOR accounts: connect|disconnect|verify|status|list; plugin install/config -> PLUGIN",
+  contexts: [
+    "connectors",
+    "settings",
+    "calendar",
+    "email",
+    "messaging",
+    "contacts",
+    "health",
+    "browser"
+  ],
+  roleGate: { minRole: "OWNER" },
+  suppressPostActionContinuation: true,
+  validate: async () => true,
+  handler: async (runtime, message, state, options) => {
+    if (!await hasLifeOpsAccess(runtime, message)) {
+      return {
+        success: false,
+        text: "Connector account actions are restricted to the owner.",
+        data: { actionName: ACTION_NAME, error: "PERMISSION_DENIED" }
+      };
+    }
+    const merged = mergeParams(message, options);
+    if (merged.action === void 0 && merged.subaction !== void 0) {
+      merged.action = merged.subaction;
+    }
+    const params = await extractActionParamsViaLlm({
+      runtime,
+      message,
+      state,
+      actionName: ACTION_NAME,
+      actionDescription: connectorAction.description,
+      paramSchema: connectorAction.parameters ?? [],
+      existingParams: merged,
+      requiredFields: ["action"]
+    });
+    const subaction = normalizeSubaction(params.action ?? params.subaction);
+    if (!subaction) {
+      return {
+        success: false,
+        text: `[${ACTION_NAME}] missing action; choose one of ${VALID_SUBACTIONS.join(" | ")}.`,
+        data: {
+          actionName: ACTION_NAME,
+          error: "MISSING_ACTION",
+          validSubactions: [...VALID_SUBACTIONS]
+        }
+      };
+    }
+    const service = new LifeOpsService(runtime);
+    const dispatchContext = { runtime, service };
+    const connector = normalizeConnectorKind(params.connector);
+    if (subaction === "list" && !connector) {
+      try {
+        return await dispatchListAll(dispatchContext);
+      } catch (error) {
+        if (error instanceof LifeOpsServiceError) {
+          return {
+            success: false,
+            text: error.message,
+            data: { actionName: ACTION_NAME, status: error.status }
+          };
+        }
+        throw error;
+      }
+    }
+    const known = listKnownConnectorKinds(runtime);
+    if (!connector) {
+      return {
+        success: false,
+        text: `[${ACTION_NAME}] missing connector; choose one of ${known.join(" | ")}.`,
+        data: {
+          actionName: ACTION_NAME,
+          error: "MISSING_CONNECTOR",
+          validConnectors: known
+        }
+      };
+    }
+    if (!isValidConnectorKind(runtime, connector)) {
+      return {
+        success: false,
+        text: `[${ACTION_NAME}] unknown connector "${connector}"; choose one of ${known.join(" | ")}.`,
+        data: {
+          actionName: ACTION_NAME,
+          error: "UNKNOWN_CONNECTOR",
+          connector,
+          validConnectors: known
+        }
+      };
+    }
+    try {
+      const verboseDispatcher = VERBOSE_DISPATCHERS[connector];
+      if (verboseDispatcher) {
+        return await verboseDispatcher(dispatchContext, subaction, params);
+      }
+      return await dispatchGenericRegistry(
+        dispatchContext,
+        subaction,
+        params,
+        connector
+      );
+    } catch (error) {
+      if (error instanceof LifeOpsServiceError) {
+        return {
+          success: false,
+          text: error.message,
+          data: {
+            actionName: ACTION_NAME,
+            connector,
+            subaction,
+            status: error.status
+          }
+        };
+      }
+      throw error;
+    }
+  },
+  parameters: [
+    {
+      name: "connector",
+      description: "ConnectorRegistry kind: google, x, telegram, signal, discord, imessage, whatsapp, twilio, calendly, duffel, health, browser_bridge. Optional action=list.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "action",
+      description: "connect auth/pairing; disconnect revoke+clear grant; verify active read/send probe; status/list read-only diagnostics. Omit ok: handler LLM-extracts.",
+      required: false,
+      schema: { type: "string", enum: [...VALID_SUBACTIONS] }
+    },
+    {
+      name: "side",
+      description: "owner | agent. Defaults to owner.",
+      required: false,
+      schema: { type: "string", enum: ["owner", "agent"] }
+    },
+    {
+      name: "mode",
+      description: "local | cloud_managed | remote. Default connector-specific.",
+      required: false,
+      schema: {
+        type: "string",
+        enum: ["local", "cloud_managed", "remote"]
+      }
+    },
+    {
+      name: "recentLimit",
+      description: "verify only: recent messages/dialogs read limit.",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "query",
+      description: "Discord verify only: search text for browser-message reads.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "sendTarget",
+      description: "verify only: destination chat/recipient/channel for self-test send.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "sendMessage",
+      description: "verify only: self-test send body.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "browser",
+      description: "browser_bridge connect only: chrome | safari.",
+      required: false,
+      schema: {
+        type: "string",
+        enum: ["chrome", "safari"]
+      }
+    },
+    {
+      name: "profileId",
+      description: "browser_bridge connect only: profile id.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "profileLabel",
+      description: "browser_bridge connect only: profile label.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "redirectUrl",
+      description: "google/x connect only: OAuth redirect URL override.",
+      required: false,
+      schema: { type: "string" }
+    }
+  ],
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Show me the status of all my LifeOps connectors." }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll list status across Google, X, Telegram, Signal, Discord, iMessage, WhatsApp, and Browser Bridge."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Connect my Google account." }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll start the plugin-google account OAuth flow and return the auth URL."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Disconnect Telegram." }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll disconnect the Telegram grant and clear local session state."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Verify Telegram by sending a self-test to my saved messages."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll probe the Telegram connector with a read + send check and report the results."
+        }
+      }
+    ]
+  ]
+};
+export {
+  connectorAction
+};
+//# sourceMappingURL=connector.js.map