cowork-os 0.3.21

package/dist/electron/electron/gateway/index.js

@@ -0,0 +1,1063 @@
+"use strict";
+/**
+ * Channel Gateway
+ *
+ * Main entry point for multi-channel messaging support.
+ * Manages channel adapters, routing, and sessions.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAutoTunnel = exports.getAvailableTunnelProviders = exports.TunnelManager = exports.EmailClient = exports.createEmailAdapter = exports.EmailAdapter = exports.BlueBubblesClient = exports.createBlueBubblesAdapter = exports.BlueBubblesAdapter = exports.LineClient = exports.createLineAdapter = exports.LineAdapter = exports.TwitchClient = exports.createTwitchAdapter = exports.TwitchAdapter = exports.MatrixClient = exports.createMatrixAdapter = exports.MatrixAdapter = exports.MattermostClient = exports.createMattermostAdapter = exports.MattermostAdapter = exports.SignalClient = exports.createSignalAdapter = exports.SignalAdapter = exports.createImessageAdapter = exports.ImessageAdapter = exports.createWhatsAppAdapter = exports.WhatsAppAdapter = exports.createSlackAdapter = exports.SlackAdapter = exports.createDiscordAdapter = exports.DiscordAdapter = exports.createTelegramAdapter = exports.TelegramAdapter = exports.ChannelGateway = void 0;
+const router_1 = require("./router");
+const security_1 = require("./security");
+const session_1 = require("./session");
+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 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");
+const repositories_1 = require("../database/repositories");
+const personality_manager_1 = require("../settings/personality-manager");
+const channelMessages_1 = require("../../shared/channelMessages");
+const types_1 = require("../../shared/types");
+const DEFAULT_CONFIG = {
+    autoConnect: true,
+};
+/**
+ * Channel Gateway - Main class for managing multi-channel messaging
+ */
+class ChannelGateway {
+    constructor(db, config = {}) {
+        this.initialized = false;
+        this.daemonListeners = [];
+        this.db = db;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Initialize components
+        this.router = new router_1.MessageRouter(db, config.router, config.agentDaemon);
+        this.securityManager = new security_1.SecurityManager(db);
+        this.sessionManager = new session_1.SessionManager(db);
+        this.channelRepo = new repositories_1.ChannelRepository(db);
+        this.userRepo = new repositories_1.ChannelUserRepository(db);
+        this.sessionRepo = new repositories_1.ChannelSessionRepository(db);
+        this.messageRepo = new repositories_1.ChannelMessageRepository(db);
+        // Listen for agent daemon events to send responses back to channels
+        if (config.agentDaemon) {
+            this.agentDaemon = config.agentDaemon;
+            this.setupAgentDaemonListeners(config.agentDaemon);
+        }
+    }
+    /**
+     * Get the channel message context from personality settings
+     */
+    getMessageContext() {
+        try {
+            if (personality_manager_1.PersonalityManager.isInitialized()) {
+                const settings = personality_manager_1.PersonalityManager.loadSettings();
+                return {
+                    agentName: settings.agentName || 'CoWork',
+                    userName: settings.relationship?.userName,
+                    personality: settings.activePersonality || 'professional',
+                    emojiUsage: settings.responseStyle?.emojiUsage || 'minimal',
+                    quirks: settings.quirks || types_1.DEFAULT_QUIRKS,
+                };
+            }
+        }
+        catch (error) {
+            console.error('[ChannelGateway] Failed to load personality settings:', error);
+        }
+        return channelMessages_1.DEFAULT_CHANNEL_CONTEXT;
+    }
+    /**
+     * Set up listeners for agent daemon events
+     */
+    setupAgentDaemonListeners(agentDaemon) {
+        // Track the last assistant message for each task to send as completion result
+        const lastMessages = new Map();
+        // Listen for assistant messages (streaming responses)
+        // Note: daemon emits { taskId, message } not { taskId, content }
+        const onAssistantMessage = (data) => {
+            const message = data.message;
+            if (message && message.length > 10) {
+                // Keep the BEST (longest substantive) answer, not just the last one
+                // This prevents confused step messages from overwriting good answers
+                const existingMessage = lastMessages.get(data.taskId);
+                const isConfusedMessage = message.toLowerCase().includes("don't have") ||
+                    message.toLowerCase().includes("please provide") ||
+                    message.toLowerCase().includes("i cannot") ||
+                    message.toLowerCase().includes("not available");
+                // Only overwrite if new message is better (longer and not confused)
+                if (!existingMessage || (!isConfusedMessage && message.length >= existingMessage.length)) {
+                    lastMessages.set(data.taskId, message);
+                }
+                // Always stream updates to channel (so user sees progress)
+                this.router.sendTaskUpdate(data.taskId, message);
+            }
+        };
+        agentDaemon.on('assistant_message', onAssistantMessage);
+        this.daemonListeners.push({ event: 'assistant_message', handler: onAssistantMessage });
+        // Listen for task completion
+        const onTaskCompleted = (data) => {
+            // Use the last assistant message as the result
+            const result = lastMessages.get(data.taskId);
+            this.router.handleTaskCompletion(data.taskId, result);
+            lastMessages.delete(data.taskId);
+        };
+        agentDaemon.on('task_completed', onTaskCompleted);
+        this.daemonListeners.push({ event: 'task_completed', handler: onTaskCompleted });
+        // Listen for task errors
+        // Note: daemon emits { taskId, error } or { taskId, message }
+        const onError = (data) => {
+            const errorMsg = data.error || data.message || 'Unknown error';
+            this.router.handleTaskFailure(data.taskId, errorMsg);
+            lastMessages.delete(data.taskId);
+        };
+        agentDaemon.on('error', onError);
+        this.daemonListeners.push({ event: 'error', handler: onError });
+        // Listen for tool errors (individual tool execution failures)
+        const onToolError = (data) => {
+            const toolName = data.tool || 'Unknown tool';
+            const errorMsg = data.error || 'Unknown error';
+            const message = (0, channelMessages_1.getChannelMessage)('toolError', this.getMessageContext(), { tool: toolName, error: errorMsg });
+            this.router.sendTaskUpdate(data.taskId, message);
+        };
+        agentDaemon.on('tool_error', onToolError);
+        this.daemonListeners.push({ event: 'tool_error', handler: onToolError });
+        // Listen for follow-up message completion
+        // Track if any assistant messages were sent during follow-up
+        const followUpMessagesSent = new Map();
+        const originalOnAssistantMessage = onAssistantMessage;
+        // Override to track follow-up messages
+        agentDaemon.off('assistant_message', onAssistantMessage);
+        const trackingAssistantMessage = (data) => {
+            followUpMessagesSent.set(data.taskId, true);
+            originalOnAssistantMessage(data);
+        };
+        agentDaemon.on('assistant_message', trackingAssistantMessage);
+        // Update the stored handler
+        const assistantIdx = this.daemonListeners.findIndex(l => l.event === 'assistant_message');
+        if (assistantIdx >= 0) {
+            this.daemonListeners[assistantIdx] = { event: 'assistant_message', handler: trackingAssistantMessage };
+        }
+        const onFollowUpCompleted = async (data) => {
+            // If no assistant messages were sent during the follow-up, send a confirmation
+            if (!followUpMessagesSent.get(data.taskId)) {
+                const message = (0, channelMessages_1.getChannelMessage)('followUpProcessed', this.getMessageContext());
+                this.router.sendTaskUpdate(data.taskId, message);
+            }
+            followUpMessagesSent.delete(data.taskId);
+            // Send any artifacts (images, screenshots) created during the follow-up
+            await this.router.sendArtifacts(data.taskId);
+        };
+        agentDaemon.on('follow_up_completed', onFollowUpCompleted);
+        this.daemonListeners.push({ event: 'follow_up_completed', handler: onFollowUpCompleted });
+        // Listen for follow-up failures
+        const onFollowUpFailed = (data) => {
+            const errorMsg = data.error || 'Unknown error';
+            const message = (0, channelMessages_1.getChannelMessage)('followUpFailed', this.getMessageContext(), { error: errorMsg });
+            this.router.sendTaskUpdate(data.taskId, message);
+            followUpMessagesSent.delete(data.taskId);
+        };
+        agentDaemon.on('follow_up_failed', onFollowUpFailed);
+        this.daemonListeners.push({ event: 'follow_up_failed', handler: onFollowUpFailed });
+        // Listen for approval requests - forward to Discord/Telegram
+        const onApprovalRequested = (data) => {
+            this.router.sendApprovalRequest(data.taskId, data.approval);
+        };
+        agentDaemon.on('approval_requested', onApprovalRequested);
+        this.daemonListeners.push({ event: 'approval_requested', handler: onApprovalRequested });
+    }
+    /**
+     * Initialize the gateway
+     */
+    async initialize(mainWindow) {
+        if (this.initialized)
+            return;
+        if (mainWindow) {
+            this.router.setMainWindow(mainWindow);
+        }
+        // Load and register enabled channels
+        await this.loadChannels();
+        // Auto-connect if configured
+        if (this.config.autoConnect) {
+            await this.router.connectAll();
+        }
+        this.initialized = true;
+        console.log('Channel Gateway initialized');
+    }
+    /**
+     * Set the main window for IPC communication
+     */
+    setMainWindow(window) {
+        this.router.setMainWindow(window);
+    }
+    /**
+     * Shutdown the gateway
+     */
+    async shutdown() {
+        // Clean up daemon event listeners
+        if (this.agentDaemon) {
+            for (const { event, handler } of this.daemonListeners) {
+                this.agentDaemon.off(event, handler);
+            }
+            this.daemonListeners = [];
+        }
+        await this.router.disconnectAll();
+        this.initialized = false;
+        console.log('Channel Gateway shutdown');
+    }
+    // Channel Management
+    /**
+     * Add a new Telegram channel
+     */
+    async addTelegramChannel(name, botToken, securityMode = 'pairing') {
+        // Check if Telegram channel already exists
+        const existing = this.channelRepo.findByType('telegram');
+        if (existing) {
+            throw new Error('Telegram channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'telegram',
+            name,
+            enabled: false, // Don't enable until tested
+            config: { botToken },
+            securityConfig: {
+                mode: securityMode,
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Discord channel
+     */
+    async addDiscordChannel(name, botToken, applicationId, guildIds, securityMode = 'pairing') {
+        // Check if Discord channel already exists
+        const existing = this.channelRepo.findByType('discord');
+        if (existing) {
+            throw new Error('Discord channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'discord',
+            name,
+            enabled: false, // Don't enable until tested
+            config: { botToken, applicationId, guildIds },
+            securityConfig: {
+                mode: securityMode,
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Slack channel
+     */
+    async addSlackChannel(name, botToken, appToken, signingSecret, securityMode = 'pairing') {
+        // Check if Slack channel already exists
+        const existing = this.channelRepo.findByType('slack');
+        if (existing) {
+            throw new Error('Slack channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'slack',
+            name,
+            enabled: false, // Don't enable until tested
+            config: { botToken, appToken, signingSecret },
+            securityConfig: {
+                mode: securityMode,
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new WhatsApp channel
+     */
+    async addWhatsAppChannel(name, allowedNumbers, securityMode = 'pairing', selfChatMode = true, responsePrefix = '🤖') {
+        // Check if WhatsApp channel already exists
+        const existing = this.channelRepo.findByType('whatsapp');
+        if (existing) {
+            throw new Error('WhatsApp channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'whatsapp',
+            name,
+            enabled: false, // Don't enable until QR code is scanned
+            config: {
+                allowedNumbers,
+                selfChatMode,
+                responsePrefix,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: allowedNumbers,
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new iMessage channel
+     */
+    async addImessageChannel(name, cliPath, dbPath, allowedContacts, securityMode = 'pairing', dmPolicy = 'pairing', groupPolicy = 'allowlist') {
+        // Check if iMessage channel already exists
+        const existing = this.channelRepo.findByType('imessage');
+        if (existing) {
+            throw new Error('iMessage channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'imessage',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                cliPath,
+                dbPath,
+                allowedContacts,
+                dmPolicy,
+                groupPolicy,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: allowedContacts,
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Signal channel
+     */
+    async addSignalChannel(name, phoneNumber, dataDir, securityMode = 'pairing', mode = 'native', trustMode = 'tofu', dmPolicy = 'pairing', groupPolicy = 'allowlist', sendReadReceipts = true, sendTypingIndicators = true) {
+        // Check if Signal channel already exists
+        const existing = this.channelRepo.findByType('signal');
+        if (existing) {
+            throw new Error('Signal channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'signal',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                phoneNumber,
+                dataDir,
+                mode,
+                trustMode,
+                dmPolicy,
+                groupPolicy,
+                sendReadReceipts,
+                sendTypingIndicators,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: [],
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Mattermost channel
+     */
+    async addMattermostChannel(name, serverUrl, token, teamId, securityMode = 'pairing') {
+        // Check if Mattermost channel already exists
+        const existing = this.channelRepo.findByType('mattermost');
+        if (existing) {
+            throw new Error('Mattermost channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'mattermost',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                serverUrl,
+                token,
+                teamId,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: [],
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Matrix channel
+     */
+    async addMatrixChannel(name, homeserver, userId, accessToken, deviceId, roomIds, securityMode = 'pairing') {
+        // Check if Matrix channel already exists
+        const existing = this.channelRepo.findByType('matrix');
+        if (existing) {
+            throw new Error('Matrix channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'matrix',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                homeserver,
+                userId,
+                accessToken,
+                deviceId,
+                roomIds,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: [],
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Twitch channel
+     */
+    async addTwitchChannel(name, username, oauthToken, channels, allowWhispers = false, securityMode = 'pairing') {
+        // Check if Twitch channel already exists
+        const existing = this.channelRepo.findByType('twitch');
+        if (existing) {
+            throw new Error('Twitch channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'twitch',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                username,
+                oauthToken,
+                channels,
+                allowWhispers,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: [],
+                pairingCodeTTL: 300, // 5 minutes
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new LINE channel
+     */
+    async addLineChannel(name, channelAccessToken, channelSecret, webhookPort = 3100, securityMode = 'pairing') {
+        // Check if LINE channel already exists
+        const existing = this.channelRepo.findByType('line');
+        if (existing) {
+            throw new Error('LINE channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'line',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                channelAccessToken,
+                channelSecret,
+                webhookPort,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: [],
+                pairingCodeTTL: 300,
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new BlueBubbles channel
+     */
+    async addBlueBubblesChannel(name, serverUrl, password, webhookPort = 3101, allowedContacts, securityMode = 'pairing') {
+        // Check if BlueBubbles channel already exists
+        const existing = this.channelRepo.findByType('bluebubbles');
+        if (existing) {
+            throw new Error('BlueBubbles channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'bluebubbles',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                serverUrl,
+                password,
+                webhookPort,
+                allowedContacts,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: allowedContacts || [],
+                pairingCodeTTL: 300,
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Add a new Email channel
+     */
+    async addEmailChannel(name, email, password, imapHost, smtpHost, displayName, allowedSenders, subjectFilter, securityMode = 'pairing') {
+        // Check if Email channel already exists
+        const existing = this.channelRepo.findByType('email');
+        if (existing) {
+            throw new Error('Email channel already configured. Update or remove it first.');
+        }
+        // Create channel record
+        const channel = this.channelRepo.create({
+            type: 'email',
+            name,
+            enabled: false, // Don't enable until connected
+            config: {
+                email,
+                password,
+                imapHost,
+                smtpHost,
+                displayName,
+                allowedSenders,
+                subjectFilter,
+            },
+            securityConfig: {
+                mode: securityMode,
+                allowedUsers: allowedSenders || [],
+                pairingCodeTTL: 300,
+                maxPairingAttempts: 5,
+                rateLimitPerMinute: 30,
+            },
+            status: 'disconnected',
+        });
+        return channel;
+    }
+    /**
+     * Update a channel configuration
+     */
+    updateChannel(channelId, updates) {
+        this.channelRepo.update(channelId, updates);
+    }
+    /**
+     * Enable a channel and connect
+     */
+    async enableChannel(channelId) {
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel) {
+            throw new Error('Channel not found');
+        }
+        // Create and register adapter if not already done
+        let adapter = this.router.getAdapter(channel.type);
+        if (!adapter) {
+            adapter = this.createAdapterForChannel(channel);
+            this.router.registerAdapter(adapter);
+        }
+        // Update channel state
+        this.channelRepo.update(channelId, { enabled: true });
+        // Connect
+        await adapter.connect();
+    }
+    /**
+     * Disable a channel and disconnect
+     */
+    async disableChannel(channelId) {
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel) {
+            throw new Error('Channel not found');
+        }
+        const adapter = this.router.getAdapter(channel.type);
+        if (adapter) {
+            await adapter.disconnect();
+        }
+        this.channelRepo.update(channelId, { enabled: false, status: 'disconnected' });
+    }
+    /**
+     * Enable WhatsApp channel and set up QR code forwarding
+     * This method connects the WhatsApp adapter and forwards QR codes to the renderer
+     */
+    async enableWhatsAppWithQRForwarding(channelId) {
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel || channel.type !== 'whatsapp') {
+            throw new Error('WhatsApp channel not found');
+        }
+        // Create and register adapter if not already done
+        let adapter = this.router.getAdapter('whatsapp');
+        if (!adapter) {
+            adapter = this.createAdapterForChannel(channel);
+            this.router.registerAdapter(adapter);
+        }
+        // Set up QR code forwarding to renderer
+        const mainWindow = this.router.getMainWindow();
+        if (mainWindow && !mainWindow.isDestroyed()) {
+            adapter.onQrCode((qr) => {
+                console.log('WhatsApp QR code received, forwarding to renderer');
+                if (!mainWindow.isDestroyed()) {
+                    mainWindow.webContents.send('whatsapp:qr-code', qr);
+                }
+            });
+            adapter.onStatusChange((status, error) => {
+                console.log(`WhatsApp status changed to: ${status}`);
+                if (!mainWindow.isDestroyed()) {
+                    mainWindow.webContents.send('whatsapp:status', { status, error: error?.message });
+                    if (status === 'connected') {
+                        mainWindow.webContents.send('whatsapp:connected');
+                        // Update channel status in database
+                        this.channelRepo.update(channelId, {
+                            enabled: true,
+                            status: 'connected',
+                            botUsername: adapter?.botUsername,
+                        });
+                    }
+                    else if (status === 'error') {
+                        this.channelRepo.update(channelId, { status: 'error' });
+                    }
+                    else if (status === 'disconnected') {
+                        this.channelRepo.update(channelId, { status: 'disconnected' });
+                    }
+                }
+            });
+        }
+        // Update channel state to connecting
+        this.channelRepo.update(channelId, { enabled: true, status: 'connecting' });
+        // Connect (this will trigger QR code generation)
+        await adapter.connect();
+    }
+    /**
+     * Get WhatsApp channel info including QR code
+     */
+    async getWhatsAppInfo() {
+        const channel = this.channelRepo.findByType('whatsapp');
+        if (!channel) {
+            return {};
+        }
+        const adapter = this.router.getAdapter('whatsapp');
+        if (!adapter) {
+            return { status: channel.status };
+        }
+        return {
+            qrCode: adapter.qrCode,
+            phoneNumber: adapter.botUsername,
+            status: adapter.status,
+        };
+    }
+    /**
+     * Logout from WhatsApp and clear credentials
+     */
+    async whatsAppLogout() {
+        const adapter = this.router.getAdapter('whatsapp');
+        if (adapter) {
+            await adapter.logout();
+        }
+        const channel = this.channelRepo.findByType('whatsapp');
+        if (channel) {
+            this.channelRepo.update(channel.id, { enabled: false, status: 'disconnected', botUsername: undefined });
+        }
+    }
+    /**
+     * Remove a channel
+     */
+    async removeChannel(channelId) {
+        await this.disableChannel(channelId);
+        // Delete associated data first (to avoid foreign key constraint errors)
+        this.messageRepo.deleteByChannelId(channelId);
+        this.sessionRepo.deleteByChannelId(channelId);
+        this.userRepo.deleteByChannelId(channelId);
+        // Now delete the channel
+        this.channelRepo.delete(channelId);
+    }
+    /**
+     * Test a channel connection without enabling it
+     */
+    async testChannel(channelId) {
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel) {
+            return { success: false, error: 'Channel not found' };
+        }
+        try {
+            const adapter = this.createAdapterForChannel(channel);
+            await adapter.connect();
+            const info = await adapter.getInfo();
+            await adapter.disconnect();
+            return {
+                success: true,
+                botUsername: info.botUsername,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Get all channels
+     */
+    getChannels() {
+        return this.channelRepo.findAll();
+    }
+    /**
+     * Get a channel by ID
+     */
+    getChannel(channelId) {
+        return this.channelRepo.findById(channelId);
+    }
+    /**
+     * Get channel by type
+     */
+    getChannelByType(type) {
+        return this.channelRepo.findByType(type);
+    }
+    // User Management
+    /**
+     * Generate a pairing code for a user
+     */
+    generatePairingCode(channelId, userId, displayName) {
+        const channel = this.channelRepo.findById(channelId);
+        if (!channel) {
+            throw new Error('Channel not found');
+        }
+        return this.securityManager.generatePairingCode(channel, userId, displayName);
+    }
+    /**
+     * Grant access to a user
+     */
+    grantUserAccess(channelId, userId, displayName) {
+        this.securityManager.grantAccess(channelId, userId, displayName);
+    }
+    /**
+     * Revoke user access
+     */
+    revokeUserAccess(channelId, userId) {
+        this.securityManager.revokeAccess(channelId, userId);
+    }
+    /**
+     * Get users for a channel
+     * Automatically cleans up expired pending pairing entries
+     */
+    getChannelUsers(channelId) {
+        // Use securityManager to trigger cleanup of expired pending entries
+        return this.securityManager.getChannelUsers(channelId);
+    }
+    // Messaging
+    /**
+     * Send a message to a channel chat
+     */
+    async sendMessage(channelType, chatId, text, options) {
+        return this.router.sendMessage(channelType, {
+            chatId,
+            text,
+            replyTo: options?.replyTo,
+            parseMode: options?.parseMode,
+        });
+    }
+    /**
+     * Send a message to a session's chat
+     */
+    async sendMessageToSession(sessionId, text, options) {
+        const session = this.sessionManager.getSession(sessionId);
+        if (!session) {
+            console.error('Session not found:', sessionId);
+            return null;
+        }
+        const channel = this.channelRepo.findById(session.channelId);
+        if (!channel) {
+            console.error('Channel not found:', session.channelId);
+            return null;
+        }
+        return this.router.sendMessage(channel.type, {
+            chatId: session.chatId,
+            text,
+            replyTo: options?.replyTo,
+            parseMode: options?.parseMode,
+        });
+    }
+    // Events
+    /**
+     * Register an event handler
+     */
+    onEvent(handler) {
+        this.router.onEvent(handler);
+    }
+    // Task response methods
+    /**
+     * Send a task update to the channel
+     */
+    async sendTaskUpdate(taskId, text) {
+        return this.router.sendTaskUpdate(taskId, text);
+    }
+    /**
+     * Handle task completion
+     */
+    async handleTaskCompletion(taskId, result) {
+        return this.router.handleTaskCompletion(taskId, result);
+    }
+    /**
+     * Handle task failure
+     */
+    async handleTaskFailure(taskId, error) {
+        return this.router.handleTaskFailure(taskId, error);
+    }
+    // Private methods
+    /**
+     * Load and register channel adapters
+     */
+    async loadChannels() {
+        const channels = this.channelRepo.findAll();
+        for (const channel of channels) {
+            try {
+                const adapter = this.createAdapterForChannel(channel);
+                this.router.registerAdapter(adapter);
+            }
+            catch (error) {
+                console.error(`Failed to create adapter for channel ${channel.type}:`, error);
+            }
+        }
+    }
+    /**
+     * Create an adapter for a channel
+     */
+    createAdapterForChannel(channel) {
+        switch (channel.type) {
+            case 'telegram':
+                return (0, telegram_1.createTelegramAdapter)({
+                    enabled: channel.enabled,
+                    botToken: channel.config.botToken,
+                    webhookUrl: channel.config.webhookUrl,
+                });
+            case 'discord':
+                return (0, discord_1.createDiscordAdapter)({
+                    enabled: channel.enabled,
+                    botToken: channel.config.botToken,
+                    applicationId: channel.config.applicationId,
+                    guildIds: channel.config.guildIds,
+                });
+            case 'slack':
+                return (0, slack_1.createSlackAdapter)({
+                    enabled: channel.enabled,
+                    botToken: channel.config.botToken,
+                    appToken: channel.config.appToken,
+                    signingSecret: channel.config.signingSecret,
+                });
+            case 'whatsapp':
+                return (0, whatsapp_1.createWhatsAppAdapter)({
+                    enabled: channel.enabled,
+                    allowedNumbers: channel.config.allowedNumbers,
+                    printQrToTerminal: true, // For debugging
+                    selfChatMode: channel.config.selfChatMode ?? true,
+                    responsePrefix: channel.config.responsePrefix ?? '🤖',
+                });
+            case 'imessage':
+                return (0, imessage_1.createImessageAdapter)({
+                    enabled: channel.enabled,
+                    cliPath: channel.config.cliPath,
+                    dbPath: channel.config.dbPath,
+                    dmPolicy: channel.config.dmPolicy,
+                    groupPolicy: channel.config.groupPolicy,
+                    allowedContacts: channel.config.allowedContacts,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'signal':
+                return (0, signal_1.createSignalAdapter)({
+                    enabled: channel.enabled,
+                    phoneNumber: channel.config.phoneNumber,
+                    cliPath: channel.config.cliPath,
+                    dataDir: channel.config.dataDir,
+                    mode: channel.config.mode,
+                    socketPath: channel.config.socketPath,
+                    trustMode: channel.config.trustMode,
+                    dmPolicy: channel.config.dmPolicy,
+                    groupPolicy: channel.config.groupPolicy,
+                    allowedNumbers: channel.config.allowedNumbers,
+                    sendReadReceipts: channel.config.sendReadReceipts,
+                    sendTypingIndicators: channel.config.sendTypingIndicators,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'mattermost':
+                return (0, mattermost_1.createMattermostAdapter)({
+                    enabled: channel.enabled,
+                    serverUrl: channel.config.serverUrl,
+                    token: channel.config.token,
+                    teamId: channel.config.teamId,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'matrix':
+                return (0, matrix_1.createMatrixAdapter)({
+                    enabled: channel.enabled,
+                    homeserver: channel.config.homeserver,
+                    userId: channel.config.userId,
+                    accessToken: channel.config.accessToken,
+                    deviceId: channel.config.deviceId,
+                    roomIds: channel.config.roomIds,
+                    sendTypingIndicators: channel.config.sendTypingIndicators,
+                    sendReadReceipts: channel.config.sendReadReceipts,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'twitch':
+                return (0, twitch_1.createTwitchAdapter)({
+                    enabled: channel.enabled,
+                    username: channel.config.username,
+                    oauthToken: channel.config.oauthToken,
+                    channels: channel.config.channels,
+                    allowWhispers: channel.config.allowWhispers,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'line':
+                return (0, line_1.createLineAdapter)({
+                    enabled: channel.enabled,
+                    channelAccessToken: channel.config.channelAccessToken,
+                    channelSecret: channel.config.channelSecret,
+                    webhookPort: channel.config.webhookPort,
+                    webhookPath: channel.config.webhookPath,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'bluebubbles':
+                return (0, bluebubbles_1.createBlueBubblesAdapter)({
+                    enabled: channel.enabled,
+                    serverUrl: channel.config.serverUrl,
+                    password: channel.config.password,
+                    webhookPort: channel.config.webhookPort,
+                    webhookPath: channel.config.webhookPath,
+                    pollInterval: channel.config.pollInterval,
+                    allowedContacts: channel.config.allowedContacts,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            case 'email':
+                return (0, email_1.createEmailAdapter)({
+                    enabled: channel.enabled,
+                    imapHost: channel.config.imapHost,
+                    imapPort: channel.config.imapPort,
+                    imapSecure: channel.config.imapSecure,
+                    smtpHost: channel.config.smtpHost,
+                    smtpPort: channel.config.smtpPort,
+                    smtpSecure: channel.config.smtpSecure,
+                    email: channel.config.email,
+                    password: channel.config.password,
+                    displayName: channel.config.displayName,
+                    mailbox: channel.config.mailbox,
+                    pollInterval: channel.config.pollInterval,
+                    markAsRead: channel.config.markAsRead,
+                    allowedSenders: channel.config.allowedSenders,
+                    subjectFilter: channel.config.subjectFilter,
+                    responsePrefix: channel.config.responsePrefix,
+                });
+            default:
+                throw new Error(`Unsupported channel type: ${channel.type}`);
+        }
+    }
+}
+exports.ChannelGateway = ChannelGateway;
+// Re-export types and components
+__exportStar(require("./channels/types"), exports);
+__exportStar(require("./router"), exports);
+__exportStar(require("./session"), exports);
+__exportStar(require("./security"), exports);
+__exportStar(require("./channel-registry"), exports);
+var telegram_2 = require("./channels/telegram");
+Object.defineProperty(exports, "TelegramAdapter", { enumerable: true, get: function () { return telegram_2.TelegramAdapter; } });
+Object.defineProperty(exports, "createTelegramAdapter", { enumerable: true, get: function () { return telegram_2.createTelegramAdapter; } });
+var discord_2 = require("./channels/discord");
+Object.defineProperty(exports, "DiscordAdapter", { enumerable: true, get: function () { return discord_2.DiscordAdapter; } });
+Object.defineProperty(exports, "createDiscordAdapter", { enumerable: true, get: function () { return discord_2.createDiscordAdapter; } });
+var slack_2 = require("./channels/slack");
+Object.defineProperty(exports, "SlackAdapter", { enumerable: true, get: function () { return slack_2.SlackAdapter; } });
+Object.defineProperty(exports, "createSlackAdapter", { enumerable: true, get: function () { return slack_2.createSlackAdapter; } });
+var whatsapp_2 = require("./channels/whatsapp");
+Object.defineProperty(exports, "WhatsAppAdapter", { enumerable: true, get: function () { return whatsapp_2.WhatsAppAdapter; } });
+Object.defineProperty(exports, "createWhatsAppAdapter", { enumerable: true, get: function () { return whatsapp_2.createWhatsAppAdapter; } });
+var imessage_2 = require("./channels/imessage");
+Object.defineProperty(exports, "ImessageAdapter", { enumerable: true, get: function () { return imessage_2.ImessageAdapter; } });
+Object.defineProperty(exports, "createImessageAdapter", { enumerable: true, get: function () { return imessage_2.createImessageAdapter; } });
+var signal_2 = require("./channels/signal");
+Object.defineProperty(exports, "SignalAdapter", { enumerable: true, get: function () { return signal_2.SignalAdapter; } });
+Object.defineProperty(exports, "createSignalAdapter", { enumerable: true, get: function () { return signal_2.createSignalAdapter; } });
+var signal_client_1 = require("./channels/signal-client");
+Object.defineProperty(exports, "SignalClient", { enumerable: true, get: function () { return signal_client_1.SignalClient; } });
+var mattermost_2 = require("./channels/mattermost");
+Object.defineProperty(exports, "MattermostAdapter", { enumerable: true, get: function () { return mattermost_2.MattermostAdapter; } });
+Object.defineProperty(exports, "createMattermostAdapter", { enumerable: true, get: function () { return mattermost_2.createMattermostAdapter; } });
+var mattermost_client_1 = require("./channels/mattermost-client");
+Object.defineProperty(exports, "MattermostClient", { enumerable: true, get: function () { return mattermost_client_1.MattermostClient; } });
+var matrix_2 = require("./channels/matrix");
+Object.defineProperty(exports, "MatrixAdapter", { enumerable: true, get: function () { return matrix_2.MatrixAdapter; } });
+Object.defineProperty(exports, "createMatrixAdapter", { enumerable: true, get: function () { return matrix_2.createMatrixAdapter; } });
+var matrix_client_1 = require("./channels/matrix-client");
+Object.defineProperty(exports, "MatrixClient", { enumerable: true, get: function () { return matrix_client_1.MatrixClient; } });
+var twitch_2 = require("./channels/twitch");
+Object.defineProperty(exports, "TwitchAdapter", { enumerable: true, get: function () { return twitch_2.TwitchAdapter; } });
+Object.defineProperty(exports, "createTwitchAdapter", { enumerable: true, get: function () { return twitch_2.createTwitchAdapter; } });
+var twitch_client_1 = require("./channels/twitch-client");
+Object.defineProperty(exports, "TwitchClient", { enumerable: true, get: function () { return twitch_client_1.TwitchClient; } });
+var line_2 = require("./channels/line");
+Object.defineProperty(exports, "LineAdapter", { enumerable: true, get: function () { return line_2.LineAdapter; } });
+Object.defineProperty(exports, "createLineAdapter", { enumerable: true, get: function () { return line_2.createLineAdapter; } });
+var line_client_1 = require("./channels/line-client");
+Object.defineProperty(exports, "LineClient", { enumerable: true, get: function () { return line_client_1.LineClient; } });
+var bluebubbles_2 = require("./channels/bluebubbles");
+Object.defineProperty(exports, "BlueBubblesAdapter", { enumerable: true, get: function () { return bluebubbles_2.BlueBubblesAdapter; } });
+Object.defineProperty(exports, "createBlueBubblesAdapter", { enumerable: true, get: function () { return bluebubbles_2.createBlueBubblesAdapter; } });
+var bluebubbles_client_1 = require("./channels/bluebubbles-client");
+Object.defineProperty(exports, "BlueBubblesClient", { enumerable: true, get: function () { return bluebubbles_client_1.BlueBubblesClient; } });
+var email_2 = require("./channels/email");
+Object.defineProperty(exports, "EmailAdapter", { enumerable: true, get: function () { return email_2.EmailAdapter; } });
+Object.defineProperty(exports, "createEmailAdapter", { enumerable: true, get: function () { return email_2.createEmailAdapter; } });
+var email_client_1 = require("./channels/email-client");
+Object.defineProperty(exports, "EmailClient", { enumerable: true, get: function () { return email_client_1.EmailClient; } });
+var tunnel_1 = require("./tunnel");
+Object.defineProperty(exports, "TunnelManager", { enumerable: true, get: function () { return tunnel_1.TunnelManager; } });
+Object.defineProperty(exports, "getAvailableTunnelProviders", { enumerable: true, get: function () { return tunnel_1.getAvailableTunnelProviders; } });
+Object.defineProperty(exports, "createAutoTunnel", { enumerable: true, get: function () { return tunnel_1.createAutoTunnel; } });