cowork-os 0.3.21

package/dist/electron/electron/gateway/channel-registry.js

@@ -0,0 +1,1102 @@
+"use strict";
+/**
+ * Channel Registry
+ *
+ * Centralized registry for channel adapters. Provides:
+ * - Registration of built-in and plugin-based channels
+ * - Channel discovery and metadata
+ * - Factory pattern for creating adapter instances
+ * - Channel capability tracking
+ * - Configuration validation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannelRegistry = exports.ChannelRegistry = void 0;
+const events_1 = require("events");
+const telegram_1 = require("./channels/telegram");
+const discord_1 = require("./channels/discord");
+const slack_1 = require("./channels/slack");
+const whatsapp_1 = require("./channels/whatsapp");
+const imessage_1 = require("./channels/imessage");
+const signal_1 = require("./channels/signal");
+const teams_1 = require("./channels/teams");
+const google_chat_1 = require("./channels/google-chat");
+const mattermost_1 = require("./channels/mattermost");
+const matrix_1 = require("./channels/matrix");
+const twitch_1 = require("./channels/twitch");
+const line_1 = require("./channels/line");
+const bluebubbles_1 = require("./channels/bluebubbles");
+const email_1 = require("./channels/email");
+/**
+ * Channel Registry - Singleton for managing channel types
+ */
+class ChannelRegistry extends events_1.EventEmitter {
+    constructor() {
+        super();
+        /** Registered channels by type */
+        this.channels = new Map();
+        /** Active adapter instances by type */
+        this.activeAdapters = new Map();
+        this.registerBuiltinChannels();
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!ChannelRegistry.instance) {
+            ChannelRegistry.instance = new ChannelRegistry();
+        }
+        return ChannelRegistry.instance;
+    }
+    /**
+     * Register built-in channels
+     */
+    registerBuiltinChannels() {
+        // Telegram
+        this.register({
+            metadata: {
+                type: 'telegram',
+                displayName: 'Telegram',
+                description: 'Telegram Bot API integration using grammY',
+                icon: '✈️',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: true,
+                    replyKeyboards: true,
+                    polls: true,
+                    voice: true,
+                    video: true,
+                    location: true,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: false,
+                    groups: true,
+                    threads: true,
+                    webhooks: true,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        botToken: {
+                            type: 'string',
+                            description: 'Bot token from @BotFather',
+                            required: true,
+                            secret: true,
+                        },
+                        webhookUrl: {
+                            type: 'string',
+                            description: 'Webhook URL (optional, uses polling if not set)',
+                        },
+                    },
+                    required: ['botToken'],
+                },
+            },
+            factory: (config) => (0, telegram_1.createTelegramAdapter)(config),
+        });
+        // Discord
+        this.register({
+            metadata: {
+                type: 'discord',
+                displayName: 'Discord',
+                description: 'Discord Bot integration using discord.js',
+                icon: '🎮',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: true,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: true,
+                    video: false,
+                    location: false,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: false,
+                    groups: true,
+                    threads: true,
+                    webhooks: true,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        botToken: {
+                            type: 'string',
+                            description: 'Bot token from Discord Developer Portal',
+                            required: true,
+                            secret: true,
+                        },
+                        applicationId: {
+                            type: 'string',
+                            description: 'Application ID',
+                            required: true,
+                        },
+                        guildIds: {
+                            type: 'array',
+                            description: 'Guild IDs to operate in (empty = all)',
+                        },
+                    },
+                    required: ['botToken', 'applicationId'],
+                },
+            },
+            factory: (config) => (0, discord_1.createDiscordAdapter)(config),
+        });
+        // Slack
+        this.register({
+            metadata: {
+                type: 'slack',
+                displayName: 'Slack',
+                description: 'Slack Bot integration using Bolt SDK',
+                icon: '💼',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: true,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: false,
+                    groups: true,
+                    threads: true,
+                    webhooks: true,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        botToken: {
+                            type: 'string',
+                            description: 'Bot token (xoxb-...)',
+                            required: true,
+                            secret: true,
+                        },
+                        appToken: {
+                            type: 'string',
+                            description: 'App token for Socket Mode (xapp-...)',
+                            required: true,
+                            secret: true,
+                        },
+                        signingSecret: {
+                            type: 'string',
+                            description: 'Signing secret for verifying requests',
+                            secret: true,
+                        },
+                    },
+                    required: ['botToken', 'appToken'],
+                },
+            },
+            factory: (config) => (0, slack_1.createSlackAdapter)(config),
+        });
+        // WhatsApp
+        this.register({
+            metadata: {
+                type: 'whatsapp',
+                displayName: 'WhatsApp',
+                description: 'WhatsApp integration using Baileys (unofficial)',
+                icon: '💬',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: true,
+                    voice: true,
+                    video: true,
+                    location: true,
+                    editMessage: false,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: true,
+                    groups: true,
+                    threads: false,
+                    webhooks: false,
+                    e2eEncryption: true,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        allowedNumbers: {
+                            type: 'array',
+                            description: 'Allowed phone numbers in E.164 format',
+                        },
+                        selfChatMode: {
+                            type: 'boolean',
+                            description: 'Enable self-chat mode (messaging yourself)',
+                            default: true,
+                        },
+                        responsePrefix: {
+                            type: 'string',
+                            description: 'Prefix for bot responses',
+                            default: '🤖',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            factory: (config) => (0, whatsapp_1.createWhatsAppAdapter)(config),
+        });
+        // iMessage
+        this.register({
+            metadata: {
+                type: 'imessage',
+                displayName: 'iMessage',
+                description: 'iMessage integration using imsg CLI (macOS only)',
+                icon: '💬',
+                builtin: true,
+                platforms: ['darwin'],
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: false,
+                    deleteMessage: false,
+                    typing: true,
+                    readReceipts: true,
+                    groups: true,
+                    threads: false,
+                    webhooks: false,
+                    e2eEncryption: true,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        cliPath: {
+                            type: 'string',
+                            description: 'Path to imsg CLI (default: "imsg")',
+                        },
+                        dbPath: {
+                            type: 'string',
+                            description: 'Path to Messages database',
+                        },
+                        dmPolicy: {
+                            type: 'string',
+                            description: 'DM access policy',
+                            default: 'pairing',
+                        },
+                        groupPolicy: {
+                            type: 'string',
+                            description: 'Group access policy',
+                            default: 'allowlist',
+                        },
+                        allowedContacts: {
+                            type: 'array',
+                            description: 'Allowed contacts (phone numbers, emails)',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            factory: (config) => (0, imessage_1.createImessageAdapter)(config),
+        });
+        // Signal
+        this.register({
+            metadata: {
+                type: 'signal',
+                displayName: 'Signal',
+                description: 'Signal messaging integration using signal-cli',
+                icon: '🔐',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: true,
+                    video: false,
+                    location: false,
+                    editMessage: false,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: true,
+                    groups: true,
+                    threads: false,
+                    webhooks: false,
+                    e2eEncryption: true,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        phoneNumber: {
+                            type: 'string',
+                            description: 'Phone number in E.164 format (e.g., +14155551234)',
+                            required: true,
+                        },
+                        cliPath: {
+                            type: 'string',
+                            description: 'Path to signal-cli executable (default: "signal-cli")',
+                        },
+                        dataDir: {
+                            type: 'string',
+                            description: 'signal-cli data directory',
+                        },
+                        mode: {
+                            type: 'string',
+                            description: 'Communication mode (native, json-rpc, dbus)',
+                            default: 'native',
+                        },
+                        trustMode: {
+                            type: 'string',
+                            description: 'Trust mode for new contacts (always, on-first-use, never)',
+                            default: 'on-first-use',
+                        },
+                        dmPolicy: {
+                            type: 'string',
+                            description: 'DM access policy',
+                            default: 'pairing',
+                        },
+                        groupPolicy: {
+                            type: 'string',
+                            description: 'Group access policy',
+                            default: 'allowlist',
+                        },
+                        allowedNumbers: {
+                            type: 'array',
+                            description: 'Allowed phone numbers in E.164 format',
+                        },
+                        sendReadReceipts: {
+                            type: 'boolean',
+                            description: 'Send read receipts',
+                            default: true,
+                        },
+                        sendTypingIndicators: {
+                            type: 'boolean',
+                            description: 'Send typing indicators',
+                            default: true,
+                        },
+                    },
+                    required: ['phoneNumber'],
+                },
+            },
+            factory: (config) => (0, signal_1.createSignalAdapter)(config),
+        });
+        // Microsoft Teams
+        this.register({
+            metadata: {
+                type: 'teams',
+                displayName: 'Microsoft Teams',
+                description: 'Microsoft Teams Bot integration using Bot Framework SDK',
+                icon: '🟦',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: true,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: false,
+                    groups: true,
+                    threads: true,
+                    webhooks: true,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        appId: {
+                            type: 'string',
+                            description: 'Microsoft App ID from Azure Bot registration',
+                            required: true,
+                        },
+                        appPassword: {
+                            type: 'string',
+                            description: 'Microsoft App Password (Client Secret)',
+                            required: true,
+                            secret: true,
+                        },
+                        tenantId: {
+                            type: 'string',
+                            description: 'Tenant ID for single-tenant apps (optional)',
+                        },
+                        displayName: {
+                            type: 'string',
+                            description: 'Bot display name',
+                        },
+                        webhookPort: {
+                            type: 'number',
+                            description: 'Webhook endpoint port (default: 3978)',
+                            default: 3978,
+                        },
+                    },
+                    required: ['appId', 'appPassword'],
+                },
+            },
+            factory: (config) => (0, teams_1.createTeamsAdapter)(config),
+        });
+        // Google Chat
+        this.register({
+            metadata: {
+                type: 'googlechat',
+                displayName: 'Google Chat',
+                description: 'Google Chat integration using Google Chat API with service account',
+                icon: '💚',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: false, // Limited - requires Google Drive integration
+                    reactions: true,
+                    inlineKeyboards: true, // Via cards
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: false,
+                    readReceipts: false,
+                    groups: true, // Spaces
+                    threads: true,
+                    webhooks: true,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        serviceAccountKeyPath: {
+                            type: 'string',
+                            description: 'Path to service account JSON key file',
+                        },
+                        projectId: {
+                            type: 'string',
+                            description: 'Google Cloud project ID',
+                        },
+                        displayName: {
+                            type: 'string',
+                            description: 'Bot display name',
+                        },
+                        webhookPort: {
+                            type: 'number',
+                            description: 'Webhook endpoint port (default: 3979)',
+                            default: 3979,
+                        },
+                        webhookPath: {
+                            type: 'string',
+                            description: 'Webhook path (default: /googlechat/webhook)',
+                            default: '/googlechat/webhook',
+                        },
+                    },
+                    required: [],
+                },
+            },
+            factory: (config) => (0, google_chat_1.createGoogleChatAdapter)(config),
+        });
+        // Mattermost
+        this.register({
+            metadata: {
+                type: 'mattermost',
+                displayName: 'Mattermost',
+                description: 'Mattermost integration using WebSocket and REST API',
+                icon: '🔵',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: false,
+                    groups: true,
+                    threads: true,
+                    webhooks: true,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        serverUrl: {
+                            type: 'string',
+                            description: 'Mattermost server URL (e.g., https://mattermost.example.com)',
+                            required: true,
+                        },
+                        token: {
+                            type: 'string',
+                            description: 'Personal access token',
+                            required: true,
+                            secret: true,
+                        },
+                        teamId: {
+                            type: 'string',
+                            description: 'Team ID to operate in (optional)',
+                        },
+                        responsePrefix: {
+                            type: 'string',
+                            description: 'Prefix for bot responses',
+                        },
+                    },
+                    required: ['serverUrl', 'token'],
+                },
+            },
+            factory: (config) => (0, mattermost_1.createMattermostAdapter)(config),
+        });
+        // Matrix
+        this.register({
+            metadata: {
+                type: 'matrix',
+                displayName: 'Matrix',
+                description: 'Matrix federated messaging integration',
+                icon: '🟢',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: true,
+                    deleteMessage: true,
+                    typing: true,
+                    readReceipts: true,
+                    groups: true,
+                    threads: true,
+                    webhooks: false,
+                    e2eEncryption: true,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        homeserver: {
+                            type: 'string',
+                            description: 'Matrix homeserver URL (e.g., https://matrix.org)',
+                            required: true,
+                        },
+                        userId: {
+                            type: 'string',
+                            description: 'User ID (e.g., @user:matrix.org)',
+                            required: true,
+                        },
+                        accessToken: {
+                            type: 'string',
+                            description: 'Access token',
+                            required: true,
+                            secret: true,
+                        },
+                        deviceId: {
+                            type: 'string',
+                            description: 'Device ID (optional)',
+                        },
+                        roomIds: {
+                            type: 'array',
+                            description: 'Room IDs to listen to (optional)',
+                        },
+                    },
+                    required: ['homeserver', 'userId', 'accessToken'],
+                },
+            },
+            factory: (config) => (0, matrix_1.createMatrixAdapter)(config),
+        });
+        // Twitch
+        this.register({
+            metadata: {
+                type: 'twitch',
+                displayName: 'Twitch',
+                description: 'Twitch IRC chat integration',
+                icon: '🟣',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: false,
+                    reactions: false,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: false,
+                    deleteMessage: true,
+                    typing: false,
+                    readReceipts: false,
+                    groups: true,
+                    threads: false,
+                    webhooks: false,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        username: {
+                            type: 'string',
+                            description: 'Twitch username (login name)',
+                            required: true,
+                        },
+                        oauthToken: {
+                            type: 'string',
+                            description: 'OAuth token',
+                            required: true,
+                            secret: true,
+                        },
+                        channels: {
+                            type: 'array',
+                            description: 'Channels to join (without # prefix)',
+                            required: true,
+                        },
+                        allowWhispers: {
+                            type: 'boolean',
+                            description: 'Whether to respond to whispers (DMs)',
+                            default: false,
+                        },
+                    },
+                    required: ['username', 'oauthToken', 'channels'],
+                },
+            },
+            factory: (config) => (0, twitch_1.createTwitchAdapter)(config),
+        });
+        // LINE
+        this.register({
+            metadata: {
+                type: 'line',
+                displayName: 'LINE',
+                description: 'LINE Messaging API integration with webhooks',
+                icon: '💚',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: false,
+                    inlineKeyboards: true,
+                    replyKeyboards: true,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: true,
+                    editMessage: false,
+                    deleteMessage: false,
+                    typing: false,
+                    readReceipts: true,
+                    groups: true,
+                    threads: false,
+                    webhooks: true,
+                    e2eEncryption: true,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        channelAccessToken: {
+                            type: 'string',
+                            description: 'LINE Channel Access Token',
+                            required: true,
+                            secret: true,
+                        },
+                        channelSecret: {
+                            type: 'string',
+                            description: 'LINE Channel Secret',
+                            required: true,
+                            secret: true,
+                        },
+                        webhookPort: {
+                            type: 'number',
+                            description: 'Webhook port (default: 3100)',
+                            default: 3100,
+                        },
+                        webhookPath: {
+                            type: 'string',
+                            description: 'Webhook path (default: /line/webhook)',
+                            default: '/line/webhook',
+                        },
+                        useReplyTokens: {
+                            type: 'boolean',
+                            description: 'Use reply tokens for faster responses',
+                            default: true,
+                        },
+                    },
+                    required: ['channelAccessToken', 'channelSecret'],
+                },
+            },
+            factory: (config) => (0, line_1.createLineAdapter)(config),
+        });
+        // BlueBubbles
+        this.register({
+            metadata: {
+                type: 'bluebubbles',
+                displayName: 'BlueBubbles',
+                description: 'iMessage integration via BlueBubbles server',
+                icon: '💙',
+                builtin: true,
+                platforms: ['darwin'],
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: true,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: false,
+                    deleteMessage: false,
+                    typing: true,
+                    readReceipts: true,
+                    groups: true,
+                    threads: false,
+                    webhooks: true,
+                    e2eEncryption: true,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        serverUrl: {
+                            type: 'string',
+                            description: 'BlueBubbles server URL (e.g., http://192.168.1.100:1234)',
+                            required: true,
+                        },
+                        password: {
+                            type: 'string',
+                            description: 'BlueBubbles server password',
+                            required: true,
+                            secret: true,
+                        },
+                        webhookPort: {
+                            type: 'number',
+                            description: 'Webhook port (default: 3101)',
+                            default: 3101,
+                        },
+                        webhookPath: {
+                            type: 'string',
+                            description: 'Webhook path (default: /bluebubbles/webhook)',
+                            default: '/bluebubbles/webhook',
+                        },
+                        pollInterval: {
+                            type: 'number',
+                            description: 'Poll interval in ms if webhooks unavailable',
+                            default: 5000,
+                        },
+                        allowedContacts: {
+                            type: 'array',
+                            description: 'Allowed contacts (phone numbers or emails)',
+                        },
+                    },
+                    required: ['serverUrl', 'password'],
+                },
+            },
+            factory: (config) => (0, bluebubbles_1.createBlueBubblesAdapter)(config),
+        });
+        // Email
+        this.register({
+            metadata: {
+                type: 'email',
+                displayName: 'Email',
+                description: 'Email integration using IMAP/SMTP',
+                icon: '📧',
+                builtin: true,
+                capabilities: {
+                    sendMessage: true,
+                    receiveMessage: true,
+                    attachments: true,
+                    reactions: false,
+                    inlineKeyboards: false,
+                    replyKeyboards: false,
+                    polls: false,
+                    voice: false,
+                    video: false,
+                    location: false,
+                    editMessage: false,
+                    deleteMessage: true,
+                    typing: false,
+                    readReceipts: false,
+                    groups: false,
+                    threads: true,
+                    webhooks: false,
+                    e2eEncryption: false,
+                },
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        imapHost: {
+                            type: 'string',
+                            description: 'IMAP server host',
+                            required: true,
+                        },
+                        imapPort: {
+                            type: 'number',
+                            description: 'IMAP port (default: 993)',
+                            default: 993,
+                        },
+                        smtpHost: {
+                            type: 'string',
+                            description: 'SMTP server host',
+                            required: true,
+                        },
+                        smtpPort: {
+                            type: 'number',
+                            description: 'SMTP port (default: 587)',
+                            default: 587,
+                        },
+                        email: {
+                            type: 'string',
+                            description: 'Email address',
+                            required: true,
+                        },
+                        password: {
+                            type: 'string',
+                            description: 'Password or app password',
+                            required: true,
+                            secret: true,
+                        },
+                        displayName: {
+                            type: 'string',
+                            description: 'Display name for outgoing emails',
+                        },
+                        mailbox: {
+                            type: 'string',
+                            description: 'IMAP mailbox to monitor (default: INBOX)',
+                            default: 'INBOX',
+                        },
+                        subjectFilter: {
+                            type: 'string',
+                            description: 'Subject line filter pattern',
+                        },
+                        allowedSenders: {
+                            type: 'array',
+                            description: 'Allowed sender email addresses',
+                        },
+                    },
+                    required: ['imapHost', 'smtpHost', 'email', 'password'],
+                },
+            },
+            factory: (config) => (0, email_1.createEmailAdapter)(config),
+        });
+    }
+    /**
+     * Register a channel
+     */
+    register(entry) {
+        const { metadata, factory } = entry;
+        // Check platform compatibility
+        if (metadata.platforms && !metadata.platforms.includes(process.platform)) {
+            console.log(`Channel ${metadata.type} not supported on ${process.platform}`);
+            return;
+        }
+        // Check for duplicate
+        if (this.channels.has(metadata.type)) {
+            console.warn(`Channel ${metadata.type} already registered, overwriting`);
+        }
+        this.channels.set(metadata.type, entry);
+        this.emit('channel:registered', { type: metadata.type, metadata });
+        console.log(`Channel registered: ${metadata.type} (${metadata.displayName})`);
+    }
+    /**
+     * Unregister a channel
+     */
+    unregister(type) {
+        const entry = this.channels.get(type);
+        if (!entry) {
+            return false;
+        }
+        // Cannot unregister built-in channels
+        if (entry.metadata.builtin) {
+            throw new Error(`Cannot unregister built-in channel: ${type}`);
+        }
+        this.channels.delete(type);
+        this.emit('channel:unregistered', { type });
+        return true;
+    }
+    /**
+     * Get all registered channel types
+     */
+    getChannelTypes() {
+        return Array.from(this.channels.keys());
+    }
+    /**
+     * Get channel metadata
+     */
+    getMetadata(type) {
+        return this.channels.get(type)?.metadata;
+    }
+    /**
+     * Get all channel metadata
+     */
+    getAllMetadata() {
+        return Array.from(this.channels.values()).map(e => e.metadata);
+    }
+    /**
+     * Get built-in channels
+     */
+    getBuiltinChannels() {
+        return Array.from(this.channels.values())
+            .filter(e => e.metadata.builtin)
+            .map(e => e.metadata);
+    }
+    /**
+     * Get plugin-provided channels
+     */
+    getPluginChannels() {
+        return Array.from(this.channels.values())
+            .filter(e => !e.metadata.builtin)
+            .map(e => e.metadata);
+    }
+    /**
+     * Check if a channel type is registered
+     */
+    hasChannel(type) {
+        return this.channels.has(type);
+    }
+    /**
+     * Check if a channel type is supported on current platform
+     */
+    isSupported(type) {
+        const entry = this.channels.get(type);
+        if (!entry) {
+            return false;
+        }
+        if (entry.metadata.platforms) {
+            return entry.metadata.platforms.includes(process.platform);
+        }
+        return true;
+    }
+    /**
+     * Create a channel adapter instance
+     */
+    createAdapter(type, config) {
+        const entry = this.channels.get(type);
+        if (!entry) {
+            throw new Error(`Unknown channel type: ${type}`);
+        }
+        return entry.factory(config);
+    }
+    /**
+     * Validate configuration for a channel type
+     */
+    validateConfig(type, config) {
+        const entry = this.channels.get(type);
+        if (!entry) {
+            return { valid: false, errors: [`Unknown channel type: ${type}`] };
+        }
+        const schema = entry.metadata.configSchema;
+        if (!schema) {
+            return { valid: true, errors: [] };
+        }
+        const errors = [];
+        // Check required fields
+        for (const required of schema.required || []) {
+            if (!(required in config) || config[required] === undefined || config[required] === '') {
+                errors.push(`Missing required field: ${required}`);
+            }
+        }
+        // Basic type validation
+        for (const [key, prop] of Object.entries(schema.properties)) {
+            const value = config[key];
+            if (value === undefined) {
+                continue;
+            }
+            const expectedType = prop.type;
+            const actualType = Array.isArray(value) ? 'array' : typeof value;
+            if (expectedType !== actualType) {
+                errors.push(`Field ${key} should be ${expectedType}, got ${actualType}`);
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Get channels by capability
+     */
+    getChannelsByCapability(capability) {
+        return Array.from(this.channels.values())
+            .filter(e => e.metadata.capabilities[capability])
+            .map(e => e.metadata);
+    }
+    /**
+     * Get channel capabilities
+     */
+    getCapabilities(type) {
+        return this.channels.get(type)?.metadata.capabilities;
+    }
+    /**
+     * Set an active adapter instance (for tracking)
+     */
+    setActiveAdapter(type, adapter) {
+        this.activeAdapters.set(type, adapter);
+    }
+    /**
+     * Get an active adapter instance
+     */
+    getActiveAdapter(type) {
+        return this.activeAdapters.get(type);
+    }
+    /**
+     * Remove an active adapter
+     */
+    removeActiveAdapter(type) {
+        this.activeAdapters.delete(type);
+    }
+    /**
+     * Get all active adapters
+     */
+    getActiveAdapters() {
+        return new Map(this.activeAdapters);
+    }
+    /**
+     * Get channel status summary
+     */
+    getStatusSummary() {
+        const summary = [];
+        for (const [type, entry] of this.channels) {
+            const adapter = this.activeAdapters.get(type);
+            summary.push({
+                type,
+                displayName: entry.metadata.displayName,
+                status: adapter?.status || 'disconnected',
+            });
+        }
+        return summary;
+    }
+}
+exports.ChannelRegistry = ChannelRegistry;
+// Export singleton getter
+const getChannelRegistry = () => ChannelRegistry.getInstance();
+exports.getChannelRegistry = getChannelRegistry;