cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/whatsapp.js

@@ -0,0 +1,953 @@
+"use strict";
+/**
+ * WhatsApp Channel Adapter
+ *
+ * Implements the ChannelAdapter interface using Baileys for WhatsApp Web API.
+ *
+ * Features:
+ * - QR code authentication for WhatsApp Web
+ * - Multi-file auth state persistence
+ * - Message deduplication
+ * - Group and DM message handling
+ * - Media message support (images, documents, audio, video)
+ * - Typing indicators (composing presence)
+ * - Message reactions
+ * - Auto-reconnection with exponential backoff
+ * - Read receipts
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppAdapter = void 0;
+exports.createWhatsAppAdapter = createWhatsAppAdapter;
+const baileys_1 = require("@whiskeysockets/baileys");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+class WhatsAppAdapter {
+    constructor(config) {
+        this.type = 'whatsapp';
+        this.sock = null;
+        this._status = 'disconnected';
+        this.messageHandlers = [];
+        this.errorHandlers = [];
+        this.statusHandlers = [];
+        this.qrCodeHandlers = [];
+        // Message deduplication
+        this.processedMessages = new Map();
+        this.DEDUP_CACHE_TTL = 60000; // 1 minute
+        this.DEDUP_CACHE_MAX_SIZE = 1000;
+        // Connection state
+        this.connectedAtMs = 0;
+        this.isReconnecting = false;
+        this.backoffAttempt = 0;
+        this.DEFAULT_BACKOFF = {
+            initialDelay: 2000,
+            maxDelay: 30000,
+            multiplier: 1.8,
+            jitter: 0.25,
+            maxAttempts: 10,
+        };
+        // Group metadata cache
+        this.groupMetaCache = new Map();
+        this.GROUP_META_TTL_MS = 5 * 60 * 1000; // 5 minutes
+        this.config = {
+            deduplicationEnabled: true,
+            sendReadReceipts: true,
+            printQrToTerminal: false,
+            selfChatMode: true, // Default to self-chat mode since most users use their own number
+            responsePrefix: '🤖', // Default prefix for bot responses
+            ...config,
+        };
+        // In self-chat mode, disable read receipts by default
+        if (this.config.selfChatMode && config.sendReadReceipts === undefined) {
+            this.config.sendReadReceipts = false;
+        }
+        // Set auth directory
+        this.authDir = config.authDir || path.join(electron_1.app.getPath('userData'), 'whatsapp-auth');
+    }
+    /**
+     * Check if self-chat mode is enabled
+     */
+    get isSelfChatMode() {
+        return this.config.selfChatMode === true;
+    }
+    /**
+     * Get the response prefix for bot messages
+     */
+    get responsePrefix() {
+        return this.config.responsePrefix || '🤖';
+    }
+    get status() {
+        return this._status;
+    }
+    get botUsername() {
+        return this._selfE164;
+    }
+    /**
+     * Get the current QR code (if in login state)
+     */
+    get qrCode() {
+        return this.currentQr;
+    }
+    /**
+     * Check if WhatsApp auth credentials exist
+     */
+    async hasCredentials() {
+        const credsPath = path.join(this.authDir, 'creds.json');
+        return fs.existsSync(credsPath);
+    }
+    /**
+     * Connect to WhatsApp Web
+     */
+    async connect() {
+        if (this._status === 'connected' || this._status === 'connecting') {
+            return;
+        }
+        this.setStatus('connecting');
+        this.resetBackoff();
+        try {
+            // Ensure auth directory exists
+            await this.ensureDir(this.authDir);
+            // Load auth state
+            const { state, saveCreds } = await (0, baileys_1.useMultiFileAuthState)(this.authDir);
+            // Get latest Baileys version
+            const { version } = await (0, baileys_1.fetchLatestBaileysVersion)();
+            // Create silent logger to suppress Baileys logs
+            const logger = {
+                level: 'silent',
+                trace: () => { },
+                debug: () => { },
+                info: () => { },
+                warn: () => { },
+                error: () => { },
+                fatal: () => { },
+                child: () => logger,
+            };
+            // Create WhatsApp socket
+            this.sock = (0, baileys_1.makeWASocket)({
+                auth: {
+                    creds: state.creds,
+                    keys: (0, baileys_1.makeCacheableSignalKeyStore)(state.keys, logger),
+                },
+                version,
+                logger: logger,
+                // Note: printQRInTerminal is deprecated - QR codes are handled via connection.update event
+                browser: ['CoWork-OS', 'Desktop', '1.0.0'],
+                syncFullHistory: false,
+                markOnlineOnConnect: false,
+            });
+            // Handle credential updates
+            this.sock.ev.on('creds.update', saveCreds);
+            // Handle connection updates
+            this.sock.ev.on('connection.update', (update) => {
+                this.handleConnectionUpdate(update);
+            });
+            // Handle incoming messages
+            this.sock.ev.on('messages.upsert', (upsert) => {
+                this.handleMessagesUpsert(upsert);
+            });
+            // Start deduplication cleanup
+            if (this.config.deduplicationEnabled) {
+                this.startDedupCleanup();
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.setStatus('error', err);
+            throw err;
+        }
+    }
+    /**
+     * Handle connection state updates
+     */
+    handleConnectionUpdate(update) {
+        const { connection, lastDisconnect, qr } = update;
+        // Handle QR code for authentication
+        if (qr) {
+            this.currentQr = qr;
+            console.log('WhatsApp QR code received - scan with WhatsApp mobile app');
+            // Notify QR handlers
+            for (const handler of this.qrCodeHandlers) {
+                try {
+                    handler(qr);
+                }
+                catch (e) {
+                    console.error('Error in QR code handler:', e);
+                }
+            }
+        }
+        // Handle connection open
+        if (connection === 'open') {
+            this.currentQr = undefined;
+            this.connectedAtMs = Date.now();
+            this._selfJid = this.sock?.user?.id;
+            this._selfE164 = this._selfJid ? this.jidToE164(this._selfJid) ?? undefined : undefined;
+            console.log(`WhatsApp connected as ${this._selfE164 || this._selfJid}`);
+            this.setStatus('connected');
+            this.resetBackoff();
+            // Send available presence
+            this.sock?.sendPresenceUpdate('available').catch(() => { });
+        }
+        // Handle connection close
+        if (connection === 'close') {
+            this.currentQr = undefined;
+            const statusCode = this.getStatusCode(lastDisconnect?.error);
+            if (statusCode === baileys_1.DisconnectReason.loggedOut) {
+                console.error('WhatsApp session logged out');
+                this.setStatus('error', new Error('WhatsApp session logged out. Please re-authenticate.'));
+                // Clear credentials on logout
+                this.clearCredentials().catch(() => { });
+            }
+            else if (statusCode === baileys_1.DisconnectReason.restartRequired) {
+                console.log('WhatsApp restart required, reconnecting...');
+                this.attemptReconnection();
+            }
+            else {
+                console.log(`WhatsApp connection closed (status: ${statusCode}), attempting reconnection...`);
+                this.attemptReconnection();
+            }
+        }
+    }
+    /**
+     * Handle incoming messages
+     */
+    async handleMessagesUpsert(upsert) {
+        if (upsert.type !== 'notify' && upsert.type !== 'append')
+            return;
+        for (const msg of upsert.messages ?? []) {
+            try {
+                await this.processInboundMessage(msg, upsert.type);
+            }
+            catch (error) {
+                console.error('Error processing WhatsApp message:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'messageProcessing');
+            }
+        }
+    }
+    /**
+     * Process a single inbound message
+     */
+    async processInboundMessage(msg, upsertType) {
+        const id = msg.key?.id;
+        const remoteJid = msg.key?.remoteJid;
+        if (!remoteJid)
+            return;
+        // Skip status and broadcast messages
+        if (remoteJid.endsWith('@status') || remoteJid.endsWith('@broadcast'))
+            return;
+        // CRITICAL: In self-chat mode, ONLY process messages from self-chat
+        // This prevents the bot from responding to messages sent to other people
+        if (this.isSelfChatMode && this._selfJid) {
+            // Normalize JIDs by removing device suffix (e.g., "123:5@s.whatsapp.net" -> "123@s.whatsapp.net")
+            const normalizeJid = (jid) => jid.replace(/:[\d]+@/, '@');
+            const selfJidNormalized = normalizeJid(this._selfJid);
+            const remoteJidNormalized = normalizeJid(remoteJid);
+            if (remoteJidNormalized !== selfJidNormalized) {
+                // Message is NOT in self-chat, silently ignore it
+                return;
+            }
+        }
+        // Deduplication
+        if (id && this.config.deduplicationEnabled) {
+            const dedupeKey = `${remoteJid}:${id}`;
+            if (this.processedMessages.has(dedupeKey))
+                return;
+            this.processedMessages.set(dedupeKey, Date.now());
+            // Cleanup if cache is too large
+            if (this.processedMessages.size > this.DEDUP_CACHE_MAX_SIZE) {
+                this.cleanupDedupCache();
+            }
+        }
+        const isGroup = (0, baileys_1.isJidGroup)(remoteJid) === true;
+        const participantJid = msg.key?.participant;
+        const from = isGroup ? remoteJid : this.jidToE164(remoteJid) || remoteJid;
+        const senderE164 = isGroup
+            ? participantJid ? this.jidToE164(participantJid) : null
+            : from;
+        // Check access control
+        if (this.config.allowedNumbers && this.config.allowedNumbers.length > 0) {
+            const senderNumber = senderE164?.replace(/[^0-9]/g, '');
+            if (senderNumber && !this.config.allowedNumbers.includes(senderNumber)) {
+                console.log(`WhatsApp: Ignoring message from unauthorized number: ${senderNumber}`);
+                return;
+            }
+        }
+        // Get group metadata if applicable
+        let groupSubject;
+        if (isGroup && this.sock) {
+            const meta = await this.getGroupMeta(remoteJid);
+            groupSubject = meta.subject;
+        }
+        // Extract message text
+        const body = this.extractText(msg.message);
+        if (!body) {
+            // Check for media placeholder
+            const mediaPlaceholder = this.extractMediaPlaceholder(msg.message);
+            if (!mediaPlaceholder)
+                return;
+        }
+        // Send read receipt
+        if (id && this.config.sendReadReceipts && upsertType === 'notify') {
+            try {
+                await this.sock?.readMessages([{
+                        remoteJid,
+                        id,
+                        participant: participantJid,
+                        fromMe: false,
+                    }]);
+            }
+            catch {
+                // Ignore read receipt errors
+            }
+        }
+        // Skip history/offline catch-up messages
+        if (upsertType === 'append')
+            return;
+        const messageTimestampMs = msg.messageTimestamp
+            ? Number(msg.messageTimestamp) * 1000
+            : undefined;
+        // Download audio attachment if present
+        const attachments = [];
+        if (msg.message?.audioMessage) {
+            const audioAttachment = await this.downloadAudioAttachment(msg.message);
+            if (audioAttachment) {
+                attachments.push(audioAttachment);
+            }
+        }
+        // Create incoming message
+        const incomingMessage = {
+            messageId: id || `wa-${Date.now()}`,
+            channel: 'whatsapp',
+            userId: senderE164 || participantJid || remoteJid,
+            userName: msg.pushName || senderE164 || 'Unknown',
+            chatId: remoteJid,
+            text: body || (attachments.length === 0 ? this.extractMediaPlaceholder(msg.message) : '') || '',
+            timestamp: messageTimestampMs ? new Date(messageTimestampMs) : new Date(),
+            attachments: attachments.length > 0 ? attachments : undefined,
+            raw: msg,
+        };
+        // Notify message handlers
+        await this.handleIncomingMessage(incomingMessage);
+    }
+    /**
+     * Disconnect from WhatsApp
+     */
+    async disconnect() {
+        this.resetBackoff();
+        // Clear timers
+        if (this.dedupCleanupTimer) {
+            clearInterval(this.dedupCleanupTimer);
+            this.dedupCleanupTimer = undefined;
+        }
+        // Clear caches
+        this.processedMessages.clear();
+        this.groupMetaCache.clear();
+        this.currentQr = undefined;
+        if (this.sock) {
+            try {
+                this.sock.ws?.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+            this.sock = null;
+        }
+        this._selfJid = undefined;
+        this._selfE164 = undefined;
+        this.setStatus('disconnected');
+    }
+    /**
+     * Convert standard Markdown to WhatsApp-compatible formatting
+     * WhatsApp supports: *bold*, _italic_, ~strikethrough~, ```monospace```
+     */
+    convertMarkdownToWhatsApp(text) {
+        let result = text;
+        // Convert headers (### Header) to bold text
+        result = result.replace(/^#{1,6}\s+(.+)$/gm, '*$1*');
+        // Convert **bold** to *bold* (WhatsApp style)
+        result = result.replace(/\*\*(.+?)\*\*/g, '*$1*');
+        // Convert __bold__ to *bold*
+        result = result.replace(/__(.+?)__/g, '*$1*');
+        // Convert _italic_ - already WhatsApp compatible, but handle markdown style
+        // Note: Single underscores are already WhatsApp italic
+        // Convert ~~strikethrough~~ to ~strikethrough~
+        result = result.replace(/~~(.+?)~~/g, '~$1~');
+        // Convert inline code `code` to monospace (WhatsApp uses triple backticks but single works in some clients)
+        // Keep as-is since WhatsApp renders `code` reasonably
+        // Convert code blocks ```code``` - already WhatsApp compatible
+        // Convert [link text](url) to "link text (url)" since WhatsApp auto-links URLs
+        result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 ($2)');
+        // Convert horizontal rules (---, ***, ___) to a line
+        result = result.replace(/^[-*_]{3,}$/gm, '───────────');
+        // Clean up excessive newlines
+        result = result.replace(/\n{3,}/g, '\n\n');
+        return result;
+    }
+    /**
+     * Send a message to a WhatsApp chat
+     */
+    async sendMessage(message) {
+        if (!this.sock || this._status !== 'connected') {
+            throw new Error('WhatsApp is not connected');
+        }
+        const jid = this.toWhatsAppJid(message.chatId);
+        let messageId = '';
+        // Convert markdown to WhatsApp formatting and apply response prefix
+        let textToSend = message.text ? this.convertMarkdownToWhatsApp(message.text) : message.text;
+        if (this.isSelfChatMode && textToSend && textToSend.trim()) {
+            const prefix = this.responsePrefix;
+            // Only add prefix if not already present
+            if (!textToSend.startsWith(prefix)) {
+                textToSend = `${prefix} ${textToSend}`;
+            }
+        }
+        // Send media attachments first
+        if (message.attachments && message.attachments.length > 0) {
+            for (const attachment of message.attachments) {
+                const result = await this.sendMediaAttachment(jid, attachment, textToSend);
+                messageId = result;
+                // Clear text after first media with caption
+                if (textToSend) {
+                    textToSend = '';
+                }
+            }
+        }
+        // Send text message if no media or text remains
+        if (textToSend && textToSend.trim()) {
+            // Send composing presence
+            await this.sendComposingTo(jid);
+            const result = await this.sock.sendMessage(jid, { text: textToSend });
+            messageId = result?.key?.id || `wa-${Date.now()}`;
+        }
+        return messageId;
+    }
+    /**
+     * Send a media attachment
+     */
+    async sendMediaAttachment(jid, attachment, caption) {
+        if (!this.sock)
+            throw new Error('WhatsApp is not connected');
+        let content;
+        if (attachment.type === 'image' && attachment.url) {
+            const buffer = fs.readFileSync(attachment.url);
+            content = {
+                image: buffer,
+                caption,
+                mimetype: attachment.mimeType || 'image/jpeg',
+            };
+        }
+        else if (attachment.type === 'document' && attachment.url) {
+            const buffer = fs.readFileSync(attachment.url);
+            content = {
+                document: buffer,
+                fileName: attachment.fileName || path.basename(attachment.url),
+                mimetype: attachment.mimeType || 'application/octet-stream',
+                caption,
+            };
+        }
+        else if (attachment.type === 'audio' && attachment.url) {
+            const buffer = fs.readFileSync(attachment.url);
+            content = {
+                audio: buffer,
+                mimetype: attachment.mimeType || 'audio/mpeg',
+                ptt: true, // Voice note
+            };
+        }
+        else if (attachment.type === 'video' && attachment.url) {
+            const buffer = fs.readFileSync(attachment.url);
+            content = {
+                video: buffer,
+                caption,
+                mimetype: attachment.mimeType || 'video/mp4',
+            };
+        }
+        else {
+            throw new Error(`Unsupported attachment type: ${attachment.type}`);
+        }
+        const result = await this.sock.sendMessage(jid, content);
+        return result?.key?.id || `wa-${Date.now()}`;
+    }
+    /**
+     * Send composing (typing) indicator
+     */
+    async sendComposingTo(chatId) {
+        if (!this.sock)
+            return;
+        const jid = this.toWhatsAppJid(chatId);
+        try {
+            await this.sock.sendPresenceUpdate('composing', jid);
+        }
+        catch {
+            // Ignore presence errors
+        }
+    }
+    /**
+     * Send typing indicator (alias for sendComposingTo)
+     */
+    async sendTyping(chatId) {
+        await this.sendComposingTo(chatId);
+    }
+    /**
+     * Edit an existing message (not supported by WhatsApp Web API)
+     */
+    async editMessage(_chatId, _messageId, _text) {
+        throw new Error('WhatsApp does not support message editing');
+    }
+    /**
+     * Delete a message
+     */
+    async deleteMessage(chatId, messageId) {
+        if (!this.sock)
+            throw new Error('WhatsApp is not connected');
+        const jid = this.toWhatsAppJid(chatId);
+        await this.sock.sendMessage(jid, {
+            delete: {
+                remoteJid: jid,
+                fromMe: true,
+                id: messageId,
+            },
+        });
+    }
+    /**
+     * Send a document/file
+     */
+    async sendDocument(chatId, filePath, caption) {
+        if (!this.sock)
+            throw new Error('WhatsApp is not connected');
+        const jid = this.toWhatsAppJid(chatId);
+        const buffer = fs.readFileSync(filePath);
+        const fileName = path.basename(filePath);
+        const result = await this.sock.sendMessage(jid, {
+            document: buffer,
+            fileName,
+            mimetype: 'application/octet-stream',
+            caption,
+        });
+        return result?.key?.id || `wa-${Date.now()}`;
+    }
+    /**
+     * Send a photo/image
+     */
+    async sendPhoto(chatId, filePath, caption) {
+        if (!this.sock)
+            throw new Error('WhatsApp is not connected');
+        const jid = this.toWhatsAppJid(chatId);
+        const buffer = fs.readFileSync(filePath);
+        const result = await this.sock.sendMessage(jid, {
+            image: buffer,
+            caption,
+        });
+        return result?.key?.id || `wa-${Date.now()}`;
+    }
+    /**
+     * Add a reaction to a message
+     */
+    async addReaction(chatId, messageId, emoji) {
+        if (!this.sock)
+            throw new Error('WhatsApp is not connected');
+        const jid = this.toWhatsAppJid(chatId);
+        await this.sock.sendMessage(jid, {
+            react: {
+                text: emoji,
+                key: {
+                    remoteJid: jid,
+                    id: messageId,
+                    fromMe: false,
+                },
+            },
+        });
+    }
+    /**
+     * Remove a reaction from a message
+     */
+    async removeReaction(chatId, messageId) {
+        await this.addReaction(chatId, messageId, ''); // Empty string removes reaction
+    }
+    /**
+     * Register a message handler
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register a callback query handler (not supported by WhatsApp)
+     */
+    onCallbackQuery(_handler) {
+        // WhatsApp doesn't support inline keyboards/callback queries
+    }
+    /**
+     * Register an error handler
+     */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Register a status change handler
+     */
+    onStatusChange(handler) {
+        this.statusHandlers.push(handler);
+    }
+    /**
+     * Register a QR code handler
+     */
+    onQrCode(handler) {
+        this.qrCodeHandlers.push(handler);
+    }
+    /**
+     * Get channel info
+     */
+    async getInfo() {
+        return {
+            type: 'whatsapp',
+            status: this._status,
+            botId: this._selfJid,
+            botUsername: this._selfE164,
+            botDisplayName: this._selfE164,
+            extra: {
+                qrCode: this.currentQr,
+                hasCredentials: await this.hasCredentials(),
+            },
+        };
+    }
+    /**
+     * Logout and clear credentials
+     */
+    async logout() {
+        await this.disconnect();
+        await this.clearCredentials();
+    }
+    /**
+     * Clear stored credentials
+     */
+    async clearCredentials() {
+        try {
+            if (fs.existsSync(this.authDir)) {
+                const files = fs.readdirSync(this.authDir);
+                for (const file of files) {
+                    fs.unlinkSync(path.join(this.authDir, file));
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error clearing WhatsApp credentials:', error);
+        }
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    /**
+     * Handle incoming message notification
+     */
+    async handleIncomingMessage(message) {
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(message);
+            }
+            catch (error) {
+                console.error('Error in WhatsApp message handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'messageHandler');
+            }
+        }
+    }
+    /**
+     * Handle errors
+     */
+    handleError(error, context) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error, context);
+            }
+            catch (e) {
+                console.error('Error in error handler:', e);
+            }
+        }
+    }
+    /**
+     * Set status and notify handlers
+     */
+    setStatus(status, error) {
+        this._status = status;
+        for (const handler of this.statusHandlers) {
+            try {
+                handler(status, error);
+            }
+            catch (e) {
+                console.error('Error in status handler:', e);
+            }
+        }
+    }
+    /**
+     * Attempt reconnection with exponential backoff
+     */
+    async attemptReconnection() {
+        if (this.isReconnecting)
+            return;
+        const config = this.DEFAULT_BACKOFF;
+        if (this.backoffAttempt >= config.maxAttempts) {
+            console.error(`WhatsApp: Max reconnection attempts (${config.maxAttempts}) reached`);
+            this.setStatus('error', new Error('Max reconnection attempts reached'));
+            return;
+        }
+        this.isReconnecting = true;
+        this.backoffAttempt++;
+        const delay = this.calculateBackoffDelay(config);
+        console.log(`WhatsApp: Reconnection attempt ${this.backoffAttempt}/${config.maxAttempts} in ${delay}ms`);
+        this.backoffTimer = setTimeout(async () => {
+            try {
+                this.sock = null;
+                this.isReconnecting = false;
+                this.setStatus('disconnected');
+                await this.connect();
+            }
+            catch (error) {
+                this.isReconnecting = false;
+                console.error('WhatsApp reconnection attempt failed:', error);
+                await this.attemptReconnection();
+            }
+        }, delay);
+    }
+    /**
+     * Calculate backoff delay with jitter
+     */
+    calculateBackoffDelay(config) {
+        let delay = config.initialDelay * Math.pow(config.multiplier, this.backoffAttempt - 1);
+        delay = Math.min(delay, config.maxDelay);
+        const jitterAmount = delay * config.jitter;
+        const jitter = (Math.random() * 2 - 1) * jitterAmount;
+        delay = Math.round(delay + jitter);
+        return Math.max(1000, delay);
+    }
+    /**
+     * Reset backoff state
+     */
+    resetBackoff() {
+        this.backoffAttempt = 0;
+        this.isReconnecting = false;
+        if (this.backoffTimer) {
+            clearTimeout(this.backoffTimer);
+            this.backoffTimer = undefined;
+        }
+    }
+    /**
+     * Start deduplication cache cleanup
+     */
+    startDedupCleanup() {
+        this.dedupCleanupTimer = setInterval(() => {
+            this.cleanupDedupCache();
+        }, this.DEDUP_CACHE_TTL);
+    }
+    /**
+     * Clean up old dedup cache entries
+     */
+    cleanupDedupCache() {
+        const now = Date.now();
+        for (const [key, timestamp] of this.processedMessages) {
+            if (now - timestamp > this.DEDUP_CACHE_TTL) {
+                this.processedMessages.delete(key);
+            }
+        }
+    }
+    /**
+     * Get group metadata with caching
+     */
+    async getGroupMeta(jid) {
+        const cached = this.groupMetaCache.get(jid);
+        if (cached && cached.expires > Date.now()) {
+            return cached;
+        }
+        try {
+            const meta = await this.sock?.groupMetadata(jid);
+            const entry = {
+                subject: meta?.subject,
+                expires: Date.now() + this.GROUP_META_TTL_MS,
+            };
+            this.groupMetaCache.set(jid, entry);
+            return entry;
+        }
+        catch {
+            return { subject: undefined };
+        }
+    }
+    /**
+     * Convert JID to E.164 phone number format
+     */
+    jidToE164(jid) {
+        if (!jid)
+            return null;
+        // Remove @s.whatsapp.net or @c.us suffix
+        const match = jid.match(/^(\d+)@/);
+        if (!match)
+            return null;
+        return match[1];
+    }
+    /**
+     * Convert phone number/chat ID to WhatsApp JID
+     */
+    toWhatsAppJid(chatId) {
+        // Already a JID
+        if (chatId.includes('@'))
+            return chatId;
+        // Group ID
+        if (chatId.includes('-')) {
+            return `${chatId}@g.us`;
+        }
+        // Phone number - remove any non-numeric characters
+        const cleaned = chatId.replace(/[^0-9]/g, '');
+        return `${cleaned}@s.whatsapp.net`;
+    }
+    /**
+     * Extract text from WhatsApp message
+     */
+    extractText(message) {
+        if (!message)
+            return undefined;
+        // Direct text message
+        if (message.conversation) {
+            return message.conversation.trim();
+        }
+        // Extended text message
+        if (message.extendedTextMessage?.text) {
+            return message.extendedTextMessage.text.trim();
+        }
+        // Image/video/document caption
+        const caption = message.imageMessage?.caption ||
+            message.videoMessage?.caption ||
+            message.documentMessage?.caption;
+        if (caption)
+            return caption.trim();
+        return undefined;
+    }
+    /**
+     * Extract media placeholder from message
+     */
+    extractMediaPlaceholder(message) {
+        if (!message)
+            return undefined;
+        if (message.imageMessage)
+            return '<media:image>';
+        if (message.videoMessage)
+            return '<media:video>';
+        if (message.audioMessage)
+            return '<media:audio>';
+        if (message.documentMessage)
+            return '<media:document>';
+        if (message.stickerMessage)
+            return '<media:sticker>';
+        if (message.contactMessage)
+            return '<contact>';
+        if (message.locationMessage)
+            return '<location>';
+        return undefined;
+    }
+    /**
+     * Download audio from a WhatsApp message and return as attachment
+     */
+    async downloadAudioAttachment(message) {
+        const audioMessage = message.audioMessage;
+        if (!audioMessage)
+            return null;
+        try {
+            console.log('[WhatsApp] Downloading audio message...');
+            // Download the audio content
+            const stream = await (0, baileys_1.downloadContentFromMessage)(audioMessage, 'audio');
+            // Collect the stream into a buffer
+            const chunks = [];
+            for await (const chunk of stream) {
+                chunks.push(chunk);
+            }
+            const audioBuffer = Buffer.concat(chunks);
+            console.log(`[WhatsApp] Downloaded audio: ${audioBuffer.length} bytes`);
+            // Determine mime type (usually audio/ogg for voice messages)
+            const mimeType = audioMessage.mimetype || 'audio/ogg; codecs=opus';
+            const isVoiceNote = audioMessage.ptt === true;
+            const fileName = isVoiceNote
+                ? `voice_message_${Date.now()}.ogg`
+                : `audio_${Date.now()}.${this.getAudioExtension(mimeType)}`;
+            return {
+                type: 'audio',
+                data: audioBuffer,
+                mimeType,
+                fileName,
+                size: audioBuffer.length,
+            };
+        }
+        catch (error) {
+            console.error('[WhatsApp] Failed to download audio:', error);
+            return null;
+        }
+    }
+    /**
+     * Get file extension from mime type
+     */
+    getAudioExtension(mimeType) {
+        if (mimeType.includes('ogg'))
+            return 'ogg';
+        if (mimeType.includes('mp3') || mimeType.includes('mpeg'))
+            return 'mp3';
+        if (mimeType.includes('wav'))
+            return 'wav';
+        if (mimeType.includes('m4a') || mimeType.includes('mp4'))
+            return 'm4a';
+        if (mimeType.includes('webm'))
+            return 'webm';
+        return 'audio';
+    }
+    /**
+     * Get status code from disconnect error
+     */
+    getStatusCode(err) {
+        if (!err)
+            return undefined;
+        const asAny = err;
+        return (asAny?.output?.statusCode ||
+            asAny?.status ||
+            undefined);
+    }
+    /**
+     * Ensure directory exists
+     */
+    async ensureDir(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+}
+exports.WhatsAppAdapter = WhatsAppAdapter;
+/**
+ * Create a WhatsApp adapter from configuration
+ */
+function createWhatsAppAdapter(config) {
+    return new WhatsAppAdapter(config);
+}