@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.2

package/components/connectors/ConnectorModeSelector.js

@@ -0,0 +1,257 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { useApp } from "../../state/index.js";
+import { CONNECTOR_PLUGIN_MANAGED_MODE_ID, connectorAccountManagementPanelPluginId, getConnectorPluginManagedAccountOption, normalizeConnectorCatalogId, } from "./connector-account-options.js";
+function withPluginManagedMode(connectorId, modes) {
+    const option = getConnectorPluginManagedAccountOption(connectorId);
+    if (!option)
+        return modes;
+    return [
+        {
+            id: CONNECTOR_PLUGIN_MANAGED_MODE_ID,
+            label: option.label,
+            description: option.description,
+            managementMode: CONNECTOR_PLUGIN_MANAGED_MODE_ID,
+        },
+        ...modes.filter((mode) => mode.id !== CONNECTOR_PLUGIN_MANAGED_MODE_ID),
+    ];
+}
+/**
+ * Returns available modes for each connector based on deployment context.
+ */
+export function getConnectorModes(connectorId, options) {
+    const cloud = options?.elizaCloudConnected ?? false;
+    const normalizedConnectorId = normalizeConnectorCatalogId(connectorId);
+    switch (normalizedConnectorId) {
+        case "discord":
+            return withPluginManagedMode(connectorId, [
+                ...(cloud
+                    ? [
+                        {
+                            id: "managed",
+                            label: "OAuth Gateway",
+                            description: "Invite the shared Eliza Cloud Discord gateway, nickname it to your agent, and route messages down to this app.",
+                            managementMode: "cloud-managed",
+                        },
+                    ]
+                    : []),
+                {
+                    id: "local",
+                    label: "Desktop App",
+                    description: "Connect via local Discord desktop app (IPC)",
+                    managementMode: "local-setup",
+                },
+                {
+                    id: "bot",
+                    label: "Bot Token",
+                    description: "Use your own Discord bot with a token from the Developer Portal",
+                    managementMode: "local-config",
+                },
+            ]);
+        case "telegram":
+            return withPluginManagedMode(connectorId, [
+                ...(cloud
+                    ? [
+                        {
+                            id: "cloud-bot",
+                            label: "Cloud Gateway",
+                            description: "Telegram bot communication still starts with a BotFather token; Eliza Cloud can host the webhook and route it to this app.",
+                            managementMode: "cloud-managed",
+                        },
+                    ]
+                    : []),
+                {
+                    id: "bot",
+                    label: "Bot Token",
+                    description: "Create a bot via @BotFather and paste the token",
+                    managementMode: "local-config",
+                },
+                {
+                    id: "account",
+                    label: "Personal Account",
+                    description: "Use your own Telegram account (requires app credentials from my.telegram.org)",
+                    managementMode: "local-setup",
+                },
+            ]);
+        case "slack":
+            return withPluginManagedMode(connectorId, [
+                ...(cloud
+                    ? [
+                        {
+                            id: "oauth",
+                            label: "OAuth",
+                            description: "Connect Slack through Eliza Cloud OAuth for workspace-scoped bidirectional access.",
+                            managementMode: "cloud-managed",
+                        },
+                    ]
+                    : []),
+                {
+                    id: "socket",
+                    label: "Socket Mode Tokens",
+                    description: "Use your own Slack app token and bot token for the local connector runtime.",
+                    managementMode: "local-config",
+                },
+            ]);
+        case "x":
+        case "twitter":
+            return withPluginManagedMode(connectorId, [
+                ...(cloud
+                    ? [
+                        {
+                            id: "oauth",
+                            label: "OAuth",
+                            description: "Connect X/Twitter through Eliza Cloud OAuth so the agent can post, read mentions, and handle DMs through cloud-held tokens.",
+                            managementMode: "cloud-managed",
+                        },
+                    ]
+                    : []),
+                {
+                    id: "local-oauth",
+                    label: "Local OAuth2",
+                    description: "Use @elizaos/plugin-x with TWITTER_AUTH_MODE=oauth, a client ID, and a loopback redirect URI.",
+                    managementMode: "local-config",
+                },
+                {
+                    id: "developer",
+                    label: "Developer Tokens",
+                    description: "Use OAuth 1.0a API keys and access tokens from the X Developer Portal.",
+                    managementMode: "local-config",
+                },
+            ]);
+        case "signal":
+            return withPluginManagedMode(connectorId, [
+                {
+                    id: "qr",
+                    label: "QR Pair",
+                    description: "Link as a device to your Signal account via QR code",
+                    managementMode: "local-setup",
+                },
+            ]);
+        case "whatsapp":
+            return withPluginManagedMode(connectorId, [
+                {
+                    id: "qr",
+                    label: "QR Pair",
+                    description: "Scan a QR code from your WhatsApp mobile app",
+                    managementMode: "local-setup",
+                },
+                {
+                    id: "business",
+                    label: "Business Cloud API",
+                    description: "Use WhatsApp Business API with access token and phone number ID",
+                    managementMode: "local-config",
+                },
+            ]);
+        case "imessage":
+            return [
+                {
+                    id: "direct",
+                    label: "Direct (chat.db)",
+                    description: "Read iMessage database directly on this Mac. Requires Full Disk Access.",
+                    managementMode: "local-setup",
+                },
+                {
+                    id: "bluebubbles",
+                    label: "BlueBubbles",
+                    description: "Bridge via BlueBubbles server app. Works locally or over network.",
+                    managementMode: "local-config",
+                },
+                ...(cloud
+                    ? [
+                        {
+                            id: "blooio",
+                            label: "Blooio (Cloud)",
+                            description: "Cloud-based iMessage/SMS gateway. No Mac needed on the server.",
+                            managementMode: "cloud-managed",
+                        },
+                    ]
+                    : []),
+            ];
+        default:
+            return withPluginManagedMode(connectorId, []);
+    }
+}
+/**
+ * Maps connector mode to the plugin ID that ConnectorSetupPanel renders.
+ */
+export function modeToSetupPluginId(connectorId, modeId) {
+    if (modeId === CONNECTOR_PLUGIN_MANAGED_MODE_ID) {
+        return connectorAccountManagementPanelPluginId(connectorId);
+    }
+    const map = {
+        discord: { local: "discordlocal", bot: "discord", managed: "discord" },
+        telegram: {
+            "cloud-bot": "telegram",
+            bot: "telegram",
+            account: "telegramaccount",
+        },
+        slack: { oauth: "slack", socket: "slack" },
+        twitter: {
+            oauth: "twitter",
+            "local-oauth": "twitter",
+            developer: "twitter",
+        },
+        x: {
+            oauth: "x",
+            "local-oauth": "x",
+            developer: "x",
+        },
+        signal: { qr: "signal" },
+        whatsapp: { qr: "whatsapp", business: "whatsapp" },
+        imessage: {
+            direct: "imessage",
+            bluebubbles: "bluebubbles",
+            blooio: "blooio",
+        },
+    };
+    return map[normalizeConnectorCatalogId(connectorId)]?.[modeId] ?? null;
+}
+export function getDefaultConnectorModeId(connectorId, modes) {
+    if (modes.some((mode) => mode.id === CONNECTOR_PLUGIN_MANAGED_MODE_ID)) {
+        return CONNECTOR_PLUGIN_MANAGED_MODE_ID;
+    }
+    const preferredDefaults = {
+        discord: ["bot"],
+        slack: ["oauth", "socket"],
+        telegram: ["bot"],
+        x: ["oauth", "local-oauth"],
+        twitter: ["oauth", "local-oauth"],
+    };
+    for (const preferred of preferredDefaults[normalizeConnectorCatalogId(connectorId)] ?? []) {
+        if (modes.some((mode) => mode.id === preferred)) {
+            return preferred;
+        }
+    }
+    return modes[0]?.id ?? "";
+}
+export function ConnectorModeSelector({ connectorId, selectedMode, onModeChange, elizaCloudConnected, }) {
+    const { t } = useApp();
+    const modes = getConnectorModes(connectorId, { elizaCloudConnected });
+    if (modes.length <= 1)
+        return null;
+    return (_jsxs("div", { className: "mb-4", children: [_jsx("div", { className: "mb-2 text-xs font-semibold text-muted", children: t("pluginsview.ConnectionMode", {
+                    defaultValue: "Connection mode",
+                }) }), _jsx("div", { className: "flex flex-wrap gap-2", children: modes.map((mode) => (_jsx("button", { type: "button", "data-testid": `connector-mode-${connectorId}-${mode.id}`, onClick: () => onModeChange(mode.id), className: `rounded-xl border px-3 py-1.5 text-xs-tight font-medium transition-all ${selectedMode === mode.id
+                        ? "border-accent bg-accent/10 text-accent"
+                        : "border-border/40 bg-card/40 text-muted hover:border-accent/40 hover:text-txt"}`, title: mode.description, children: mode.label }, mode.id))) }), modes.find((m) => m.id === selectedMode)?.description && (_jsx("div", { className: "mt-1.5 text-2xs text-muted", children: modes.find((m) => m.id === selectedMode)?.description }))] }));
+}
+/**
+ * Hook to manage connector mode state. Reads initial mode from config
+ * or defaults to the first available mode.
+ */
+export function useConnectorMode(connectorId, options) {
+    const modes = getConnectorModes(connectorId, options);
+    const defaultMode = getDefaultConnectorModeId(connectorId, modes);
+    const [selectedMode, setSelectedMode] = useState(defaultMode);
+    useEffect(() => {
+        if (!modes.some((mode) => mode.id === selectedMode)) {
+            setSelectedMode(defaultMode);
+        }
+    }, [defaultMode, modes, selectedMode]);
+    return {
+        modes,
+        selectedMode,
+        setSelectedMode,
+        setupPluginId: modeToSetupPluginId(connectorId, selectedMode),
+    };
+}

package/components/connectors/ConnectorSetupPanel.d.ts

@@ -0,0 +1,12 @@
+import type React from "react";
+/**
+ * Register a custom connector setup panel component for a given connector ID.
+ * The connectorId is normalized (lowercased, non-alphanumeric stripped) before
+ * storage, so callers can pass raw plugin IDs.
+ */
+export declare function registerConnectorSetupPanel(connectorId: string, component: React.ComponentType): void;
+export declare function hasConnectorSetupPanel(pluginId: string): boolean;
+export declare function ConnectorSetupPanel({ pluginId }: {
+    pluginId: string;
+}): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=ConnectorSetupPanel.d.ts.map

package/components/connectors/ConnectorSetupPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectorSetupPanel.d.ts","sourceRoot":"","sources":["../../../../../../src/components/connectors/ConnectorSetupPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA+B/B;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,KAAK,CAAC,aAAa,GAC7B,IAAI,CAEN;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAgChE;AA0BD,wBAAgB,mBAAmB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,kDAyDrE"}

package/components/connectors/ConnectorSetupPanel.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getBootConfig } from "../../config/boot-config.js";
+import { BlueBubblesStatusPanel } from "./BlueBubblesStatusPanel.js";
+import { ConnectorAccountList } from "./ConnectorAccountList.js";
+import { ConnectorAccountSetupScope } from "./ConnectorAccountSetupScope.js";
+import { getConnectorPluginManagedAccountCreateInput, getConnectorPluginManagedAccountOption, parseConnectorAccountManagementPanelPluginId, } from "./connector-account-options.js";
+import { DiscordLocalConnectorPanel } from "./DiscordLocalConnectorPanel.js";
+import { IMessageStatusPanel } from "./IMessageStatusPanel.js";
+import { SignalQrOverlay } from "./SignalQrOverlay.js";
+import { TelegramAccountConnectorPanel } from "./TelegramAccountConnectorPanel.js";
+import { TelegramBotSetupPanel } from "./TelegramBotSetupPanel.js";
+import { WhatsAppQrOverlay } from "./WhatsAppQrOverlay.js";
+function normalizePluginId(pluginId) {
+    return pluginId
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, "");
+}
+// ---------------------------------------------------------------------------
+// Connector setup panel registry — allows plugins to register their own
+// setup panels at runtime without modifying the hardcoded switch statement.
+// ---------------------------------------------------------------------------
+const connectorSetupRegistry = new Map();
+/**
+ * Register a custom connector setup panel component for a given connector ID.
+ * The connectorId is normalized (lowercased, non-alphanumeric stripped) before
+ * storage, so callers can pass raw plugin IDs.
+ */
+export function registerConnectorSetupPanel(connectorId, component) {
+    connectorSetupRegistry.set(normalizePluginId(connectorId), component);
+}
+export function hasConnectorSetupPanel(pluginId) {
+    const normalized = normalizePluginId(pluginId);
+    if (parseConnectorAccountManagementPanelPluginId(pluginId)) {
+        return true;
+    }
+    // Check registry first
+    if (connectorSetupRegistry.has(normalized)) {
+        return true;
+    }
+    if (normalized.includes("lifeopsbrowser") ||
+        normalized.includes("browserbridg")) {
+        return Boolean(getBootConfig().lifeOpsBrowserSetupPanel);
+    }
+    if (normalized.includes("telegramaccount")) {
+        return true;
+    }
+    if (normalized.includes("plugintelegram")) {
+        return true;
+    }
+    switch (normalized) {
+        case "whatsapp":
+        case "signal":
+        case "discordlocal":
+        case "bluebubbles":
+        case "imessage":
+        case "telegram":
+            return true;
+        default:
+            return false;
+    }
+}
+function ConnectorAccountManagementPanel({ provider, connectorId, }) {
+    const option = getConnectorPluginManagedAccountOption(connectorId) ??
+        getConnectorPluginManagedAccountOption(provider);
+    const createInput = option?.supportsOAuth
+        ? undefined
+        : () => getConnectorPluginManagedAccountCreateInput(connectorId);
+    return (_jsx(ConnectorAccountList, { provider: provider, connectorId: connectorId, title: option?.title ?? "Plugin-managed accounts", onAddAccount: createInput }));
+}
+export function ConnectorSetupPanel({ pluginId }) {
+    const normalized = normalizePluginId(pluginId);
+    const accountManagementPanel = parseConnectorAccountManagementPanelPluginId(pluginId);
+    if (accountManagementPanel) {
+        return _jsx(ConnectorAccountManagementPanel, { ...accountManagementPanel });
+    }
+    // Check registry first — plugin-registered panels take precedence
+    const RegisteredPanel = connectorSetupRegistry.get(normalized);
+    if (RegisteredPanel) {
+        return _jsx(RegisteredPanel, {});
+    }
+    // Fall back to hardcoded components
+    if (normalized.includes("lifeopsbrowser") ||
+        normalized.includes("browserbridg")) {
+        const BrowserBridgeSetupPanel = getBootConfig().lifeOpsBrowserSetupPanel;
+        return BrowserBridgeSetupPanel ? _jsx(BrowserBridgeSetupPanel, {}) : null;
+    }
+    if (normalized.includes("telegramaccount")) {
+        return _jsx(TelegramAccountConnectorPanel, {});
+    }
+    if (normalized.includes("plugintelegram")) {
+        return _jsx(TelegramBotSetupPanel, {});
+    }
+    switch (normalized) {
+        case "whatsapp":
+            return (_jsx(ConnectorAccountSetupScope, { provider: "whatsapp", connectorId: pluginId, children: (accountId) => (_jsx(WhatsAppQrOverlay, { accountId: accountId ?? undefined })) }));
+        case "signal":
+            return (_jsx(ConnectorAccountSetupScope, { provider: "signal", connectorId: pluginId, children: (accountId) => (_jsx(SignalQrOverlay, { accountId: accountId ?? undefined })) }));
+        case "discordlocal":
+            return _jsx(DiscordLocalConnectorPanel, {});
+        case "bluebubbles":
+            return _jsx(BlueBubblesStatusPanel, {});
+        case "imessage":
+            return _jsx(IMessageStatusPanel, {});
+        case "telegram":
+            return _jsx(TelegramBotSetupPanel, {});
+        default:
+            return null;
+    }
+}

package/components/connectors/DiscordLocalConnectorPanel.d.ts

@@ -0,0 +1,2 @@
+export declare function DiscordLocalConnectorPanel(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=DiscordLocalConnectorPanel.d.ts.map

package/components/connectors/DiscordLocalConnectorPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DiscordLocalConnectorPanel.d.ts","sourceRoot":"","sources":["../../../../../../src/components/connectors/DiscordLocalConnectorPanel.tsx"],"names":[],"mappings":"AAyDA,wBAAgB,0BAA0B,4CAuYzC"}

package/components/connectors/DiscordLocalConnectorPanel.js

@@ -0,0 +1,249 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, PagePanel } from "@elizaos/ui";
+import { useCallback, useEffect, useState } from "react";
+import { client } from "../../api/index.js";
+import { useApp } from "../../state/index.js";
+const DISCORD_TEXT_CHANNEL_TYPES = new Set([0, 5, 10, 11, 12, 15, 16]);
+function isTextLikeChannel(channel) {
+    if (typeof channel.type !== "number") {
+        return true;
+    }
+    return DISCORD_TEXT_CHANNEL_TYPES.has(channel.type);
+}
+function channelLabel(channel) {
+    if (typeof channel.name === "string" && channel.name.trim().length > 0) {
+        return `#${channel.name.trim()}`;
+    }
+    if (Array.isArray(channel.recipients) && channel.recipients.length > 0) {
+        return channel.recipients
+            .map((recipient) => recipient.global_name?.trim() ||
+            recipient.username?.trim() ||
+            recipient.id)
+            .join(", ");
+    }
+    return channel.id;
+}
+function currentUserLabel(status) {
+    const currentUser = status?.currentUser;
+    if (!currentUser) {
+        return null;
+    }
+    return (currentUser.global_name?.trim() || currentUser.username?.trim() || null);
+}
+function selectedChannelIdsFromStatus(status) {
+    return status.subscribedChannelIds.length > 0
+        ? status.subscribedChannelIds
+        : status.configuredChannelIds;
+}
+export function DiscordLocalConnectorPanel() {
+    const { t } = useApp();
+    const [status, setStatus] = useState(null);
+    const [guilds, setGuilds] = useState([]);
+    const [channels, setChannels] = useState([]);
+    const [selectedGuildId, setSelectedGuildId] = useState("");
+    const [selectedChannelIds, setSelectedChannelIds] = useState([]);
+    const [loadingStatus, setLoadingStatus] = useState(true);
+    const [loadingGuilds, setLoadingGuilds] = useState(false);
+    const [loadingChannels, setLoadingChannels] = useState(false);
+    const [authorizing, setAuthorizing] = useState(false);
+    const [saving, setSaving] = useState(false);
+    const [disconnecting, setDisconnecting] = useState(false);
+    const [error, setError] = useState(null);
+    const [saveMessage, setSaveMessage] = useState(null);
+    const applyStatus = useCallback((nextStatus) => {
+        setStatus(nextStatus);
+        setSelectedChannelIds(selectedChannelIdsFromStatus(nextStatus));
+    }, []);
+    const refreshStatus = useCallback(async () => {
+        setLoadingStatus(true);
+        setError(null);
+        try {
+            applyStatus(await client.getDiscordLocalStatus());
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+        }
+        finally {
+            setLoadingStatus(false);
+        }
+    }, [applyStatus]);
+    const loadGuilds = useCallback(async () => {
+        setLoadingGuilds(true);
+        setError(null);
+        try {
+            const response = await client.listDiscordLocalGuilds();
+            setGuilds(response.guilds);
+            setSelectedGuildId((current) => {
+                if (current && response.guilds.some((guild) => guild.id === current)) {
+                    return current;
+                }
+                return response.guilds[0]?.id ?? "";
+            });
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+            setGuilds([]);
+            setSelectedGuildId("");
+        }
+        finally {
+            setLoadingGuilds(false);
+        }
+    }, []);
+    const loadChannels = useCallback(async (guildId) => {
+        if (!guildId) {
+            setChannels([]);
+            return;
+        }
+        setLoadingChannels(true);
+        setError(null);
+        try {
+            const response = await client.listDiscordLocalChannels(guildId);
+            setChannels(response.channels.filter(isTextLikeChannel));
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+            setChannels([]);
+        }
+        finally {
+            setLoadingChannels(false);
+        }
+    }, []);
+    useEffect(() => {
+        void refreshStatus();
+        return client.onWsEvent("ws-reconnected", () => {
+            void refreshStatus();
+        });
+    }, [refreshStatus]);
+    useEffect(() => {
+        if (!status?.authenticated) {
+            setGuilds([]);
+            setChannels([]);
+            setSelectedGuildId("");
+            return;
+        }
+        void loadGuilds();
+    }, [loadGuilds, status?.authenticated]);
+    useEffect(() => {
+        if (!status?.authenticated || !selectedGuildId) {
+            setChannels([]);
+            return;
+        }
+        void loadChannels(selectedGuildId);
+    }, [loadChannels, selectedGuildId, status?.authenticated]);
+    const toggleChannel = useCallback((channelId) => {
+        setSelectedChannelIds((current) => current.includes(channelId)
+            ? current.filter((entry) => entry !== channelId)
+            : [...current, channelId]);
+        setSaveMessage(null);
+    }, []);
+    const handleAuthorize = useCallback(async () => {
+        setAuthorizing(true);
+        setError(null);
+        setSaveMessage(null);
+        try {
+            applyStatus(await client.authorizeDiscordLocal());
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+        }
+        finally {
+            setAuthorizing(false);
+        }
+    }, [applyStatus]);
+    const handleDisconnect = useCallback(async () => {
+        setDisconnecting(true);
+        setError(null);
+        setSaveMessage(null);
+        try {
+            await client.disconnectDiscordLocal();
+            await refreshStatus();
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+        }
+        finally {
+            setDisconnecting(false);
+        }
+    }, [refreshStatus]);
+    const handleSaveSubscriptions = useCallback(async () => {
+        setSaving(true);
+        setError(null);
+        setSaveMessage(null);
+        try {
+            const response = await client.saveDiscordLocalSubscriptions(selectedChannelIds);
+            setStatus((current) => current
+                ? {
+                    ...current,
+                    subscribedChannelIds: response.subscribedChannelIds,
+                    configuredChannelIds: response.subscribedChannelIds,
+                }
+                : current);
+            setSelectedChannelIds(response.subscribedChannelIds);
+            setSaveMessage(t("pluginsview.DiscordLocalSubscriptionsSaved", {
+                defaultValue: "Channel subscriptions saved.",
+            }));
+        }
+        catch (nextError) {
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+        }
+        finally {
+            setSaving(false);
+        }
+    }, [selectedChannelIds, t]);
+    const connectedUser = currentUserLabel(status);
+    return (_jsx(PagePanel.Notice, { tone: error ? "danger" : status?.authenticated ? "accent" : "default", className: "mt-4", children: _jsxs("div", { className: "space-y-3 text-xs", children: [_jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [_jsx("div", { className: "font-semibold text-txt", children: status?.authenticated
+                                ? t("pluginsview.DiscordLocalAuthorized", {
+                                    defaultValue: "Discord desktop is authorized.",
+                                })
+                                : t("pluginsview.DiscordLocalAuthorizePrompt", {
+                                    defaultValue: "Authorize the app against the local Discord desktop app to read notifications, subscribe to channels, and send replies through macOS UI automation.",
+                                }) }), connectedUser ? (_jsx("code", { className: "rounded-md border border-border/40 bg-bg/60 px-2 py-1 text-xs-tight text-muted-strong", children: connectedUser })) : null] }), status?.ipcPath ? (_jsxs("div", { className: "text-muted", children: [t("pluginsview.DiscordLocalIpcPath", {
+                            defaultValue: "Discord IPC socket",
+                        }), ":", " ", _jsx("code", { className: "text-xs-tight text-muted-strong", children: status.ipcPath })] })) : null, status?.lastError ? (_jsx("div", { className: "text-danger", children: status.lastError })) : null, error ? _jsx("div", { className: "text-danger", children: error }) : null, saveMessage ? _jsx("div", { className: "text-ok", children: saveMessage }) : null, _jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [_jsx(Button, { variant: "outline", size: "sm", className: "h-8 rounded-xl px-4 text-xs-tight font-semibold", onClick: () => {
+                                void refreshStatus();
+                            }, disabled: loadingStatus, children: loadingStatus
+                                ? t("common.loading", { defaultValue: "Loading…" })
+                                : t("common.refresh", { defaultValue: "Refresh" }) }), _jsx(Button, { variant: "default", size: "sm", className: "h-8 rounded-xl px-4 text-xs-tight font-semibold", onClick: () => {
+                                void handleAuthorize();
+                            }, disabled: authorizing || !status?.available, children: authorizing
+                                ? t("pluginsview.DiscordLocalAuthorizing", {
+                                    defaultValue: "Authorizing…",
+                                })
+                                : t("pluginsview.DiscordLocalAuthorize", {
+                                    defaultValue: "Authorize Discord desktop",
+                                }) }), status?.authenticated ? (_jsx(Button, { variant: "outline", size: "sm", className: "h-8 rounded-xl px-4 text-xs-tight font-semibold", onClick: () => {
+                                void handleDisconnect();
+                            }, disabled: disconnecting, children: disconnecting
+                                ? t("common.disconnecting", {
+                                    defaultValue: "Disconnecting…",
+                                })
+                                : t("common.disconnect") })) : null] }), !status?.available ? (_jsx("div", { className: "text-muted", children: t("pluginsview.DiscordLocalUnavailable", {
+                        defaultValue: "Save the local Discord client ID and client secret above, enable the connector, and keep the Discord desktop app running on this Mac.",
+                    }) })) : null, status?.authenticated ? (_jsxs("div", { className: "space-y-3 rounded-xl border border-border/40 bg-bg/60 p-3", children: [_jsx("div", { className: "text-muted", children: t("pluginsview.DiscordLocalSubscriptionsHint", {
+                                defaultValue: "Select guild text channels to ingest directly. Direct-message notifications still flow through Discord RPC even without a subscribed channel list.",
+                            }) }), guilds.length > 0 ? (_jsxs("label", { className: "block space-y-1", children: [_jsx("span", { className: "font-medium text-txt", children: t("common.server", {
+                                        defaultValue: "Server",
+                                    }) }), _jsx("select", { className: "h-9 w-full rounded-xl border border-border/40 bg-bg px-3 text-sm text-txt", value: selectedGuildId, onChange: (event) => setSelectedGuildId(event.target.value), disabled: loadingGuilds, children: guilds.map((guild) => (_jsx("option", { value: guild.id, children: guild.name }, guild.id))) })] })) : loadingGuilds ? (_jsx("div", { className: "text-muted", children: t("pluginsview.DiscordLocalLoadingGuilds", {
+                                defaultValue: "Loading Discord servers…",
+                            }) })) : (_jsx("div", { className: "text-muted", children: t("pluginsview.DiscordLocalNoGuilds", {
+                                defaultValue: "No guilds were returned by the local Discord session.",
+                            }) })), selectedGuildId ? (_jsxs("div", { className: "space-y-2", children: [_jsx("div", { className: "font-medium text-txt", children: t("pluginsview.DiscordLocalChannels", {
+                                        defaultValue: "Subscribed channels",
+                                    }) }), loadingChannels ? (_jsx("div", { className: "text-muted", children: t("pluginsview.DiscordLocalLoadingChannels", {
+                                        defaultValue: "Loading channels…",
+                                    }) })) : channels.length > 0 ? (_jsx("div", { className: "max-h-56 space-y-2 overflow-y-auto rounded-lg border border-border/30 bg-bg/40 p-2", children: channels.map((channel) => {
+                                        const checked = selectedChannelIds.includes(channel.id);
+                                        return (_jsxs("label", { className: "flex items-center gap-3 rounded-lg px-2 py-1 hover:bg-bg-hover", children: [_jsx("input", { type: "checkbox", checked: checked, onChange: () => toggleChannel(channel.id) }), _jsx("span", { className: "min-w-0 flex-1 truncate text-sm text-txt", children: channelLabel(channel) })] }, channel.id));
+                                    }) })) : (_jsx("div", { className: "text-muted", children: t("pluginsview.DiscordLocalNoChannels", {
+                                        defaultValue: "No text channels were returned for the selected server.",
+                                    }) })), _jsxs("div", { className: "flex flex-wrap items-center gap-2", children: [_jsx(Button, { variant: "default", size: "sm", className: "h-8 rounded-xl px-4 text-xs-tight font-semibold", onClick: () => {
+                                                void handleSaveSubscriptions();
+                                            }, disabled: saving, children: saving
+                                                ? t("common.saving", { defaultValue: "Saving..." })
+                                                : t("pluginsview.SaveChannelSubscriptions", {
+                                                    defaultValue: "Save channel subscriptions",
+                                                }) }), _jsx("span", { className: "text-muted", children: t("pluginsview.DiscordLocalSelectedCount", {
+                                                count: selectedChannelIds.length,
+                                                defaultValue: "{{count}} selected",
+                                            }) })] })] })) : null] })) : null] }) }));
+}

package/components/connectors/IMessageStatusPanel.d.ts

@@ -0,0 +1,2 @@
+export declare function IMessageStatusPanel(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=IMessageStatusPanel.d.ts.map

package/components/connectors/IMessageStatusPanel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IMessageStatusPanel.d.ts","sourceRoot":"","sources":["../../../../../../src/components/connectors/IMessageStatusPanel.tsx"],"names":[],"mappings":"AAMA,wBAAgB,mBAAmB,4CAyHlC"}