twinclaw 1.1.1 → 1.1.2

package/dist/interfaces/whatsapp_handler.js

@@ -1,15 +1,45 @@
 import WAWebJS from 'whatsapp-web.js';
 import qrcode from 'qrcode-terminal';
+import axios from 'axios';
 import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
+import { logThought } from '../utils/logger.js';
 const { Client, LocalAuth, MessageMedia } = WAWebJS;
 const RATE_LIMIT_MS = 1500;
+/**
+ * Create MessageMedia from URL
+ */
+async function MessageMediaFromUrl(url, caption, mimeType, filename) {
+    try {
+        const response = await axios.get(url, { responseType: 'arraybuffer' });
+        const buffer = Buffer.from(response.data);
+        const mime = mimeType || response.headers['content-type'] || 'application/octet-stream';
+        const name = filename || url.split('/').pop() || 'file';
+        return new MessageMedia(mime, buffer.toString('base64'), name);
+    }
+    catch (err) {
+        console.error('[WhatsAppHandler] Failed to fetch media from URL:', err);
+        throw err;
+    }
+}
 export class WhatsAppHandler {
     #client;
     #lastMessageAt = 0;
-    constructor() {
+    // Session recovery
+    #connectionState = 'disconnected';
+    #reconnectAttempts = 0;
+    #maxReconnectAttempts = 5;
+    #reconnectDelayMs = 1000;
+    #maxReconnectDelayMs = 60000;
+    // Message tracking for status updates
+    #trackedMessages = new Map();
+    // Event callbacks
+    onConnectionStateChange;
+    onMessageStatus;
+    onQrCode;
+    constructor(options = {}) {
         const disableChromiumSandbox = process.env.WHATSAPP_DISABLE_CHROMIUM_SANDBOX === 'true';
         const clientConfig = {
             authStrategy: new LocalAuth({ dataPath: './memory/whatsapp_auth' }),
@@ -20,6 +50,10 @@ export class WhatsAppHandler {
             };
         }
         this.#client = new Client(clientConfig);
+        // Configure reconnection options
+        this.#maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+        this.#reconnectDelayMs = options.reconnectDelayMs ?? 1000;
+        this.#maxReconnectDelayMs = options.maxReconnectDelayMs ?? 60000;
         this.#registerListeners();
     }
     onMessage;
@@ -31,13 +65,55 @@ export class WhatsAppHandler {
         this.#lastMessageAt = Date.now();
     }
     #registerListeners() {
+        // QR Code generation
         this.#client.on('qr', (qr) => {
             console.log('[WhatsAppHandler] Scan this QR code to authenticate:');
             qrcode.generate(qr, { small: true });
+            this.onQrCode?.(qr);
+        });
+        // Authentication success
+        this.#client.on('authenticated', () => {
+            console.log('[WhatsAppHandler] Session authenticated successfully');
+            this.#connectionState = 'connected';
+            this.#reconnectAttempts = 0;
+            this.onConnectionStateChange?.('connected');
         });
+        // Client ready
         this.#client.on('ready', () => {
             console.log('[WhatsAppHandler] Client is ready!');
+            this.#connectionState = 'connected';
+            this.#reconnectAttempts = 0;
+            this.onConnectionStateChange?.('connected');
+        });
+        // Connection failure
+        this.#client.on('failure', (error) => {
+            console.error('[WhatsAppHandler] Client failed:', error);
+            this.#connectionState = 'failed';
+            this.onConnectionStateChange?.('failed');
+            this.#handleDisconnection();
+        });
+        // Disconnected event
+        this.#client.on('disconnected', (reason) => {
+            console.log('[WhatsAppHandler] Client disconnected:', reason);
+            this.#connectionState = 'disconnected';
+            this.onConnectionStateChange?.('disconnected');
+            this.#handleDisconnection();
+        });
+        // Connection state changes
+        this.#client.on('change_state', (state) => {
+            console.log('[WhatsAppHandler] Connection state changed:', state);
+            if (state === 'close' || state === 'disconnected' || state === 'open') {
+                // Only trigger disconnection for non-connected states
+                if (state !== 'open' && this.#connectionState === 'connected') {
+                    this.#handleDisconnection();
+                }
+            }
+        });
+        // Message acknowledgment (acks)
+        this.#client.on('message_ack', (message, ack) => {
+            this.#handleMessageAck(message, ack);
         });
+        // Incoming messages
         this.#client.on('message', async (msg) => {
             await this.#applyRateLimit();
             const base = {
@@ -81,10 +157,175 @@ export class WhatsAppHandler {
         });
         this.#client.initialize().catch(err => {
             console.error('[WhatsAppHandler] Failed to initialize client:', err);
+            this.#connectionState = 'failed';
+            this.onConnectionStateChange?.('failed');
         });
     }
+    /**
+     * Handle disconnection with exponential backoff reconnection
+     */
+    async #handleDisconnection() {
+        if (this.#reconnectAttempts >= this.#maxReconnectAttempts) {
+            console.error('[WhatsAppHandler] Max reconnection attempts reached');
+            await logThought('[WhatsAppHandler] Failed to reconnect after multiple attempts. Please scan a new QR code.');
+            return;
+        }
+        this.#connectionState = 'connecting';
+        this.onConnectionStateChange?.('connecting');
+        const delay = Math.min(this.#reconnectDelayMs * Math.pow(2, this.#reconnectAttempts), this.#maxReconnectDelayMs);
+        console.log(`[WhatsAppHandler] Attempting to reconnect in ${delay}ms (attempt ${this.#reconnectAttempts + 1}/${this.#maxReconnectAttempts})`);
+        await logThought(`[WhatsAppHandler] Reconnecting... attempt ${this.#reconnectAttempts + 1}`);
+        this.#reconnectAttempts++;
+        setTimeout(async () => {
+            try {
+                await this.#client.initialize();
+            }
+            catch (err) {
+                console.error('[WhatsAppHandler] Reconnection failed:', err);
+                // The failure event will trigger another attempt via the event handler
+            }
+        }, delay);
+    }
+    /**
+     * Handle message acknowledgment status updates
+     */
+    #handleMessageAck(message, ack) {
+        // Use _serialized which is the reliable message ID in whatsapp-web.js
+        const messageKey = message.id._serialized;
+        const tracked = this.#trackedMessages.get(messageKey);
+        let status;
+        // Map WhatsApp ack values to our status
+        // -1: Error, 0: Pending, 1: Server, 2: Device, 3: Read, 4: Played
+        switch (ack) {
+            case -1:
+                status = 'failed';
+                break;
+            case 0:
+                status = 'queued';
+                break;
+            case 1:
+            case 2:
+                status = 'sent';
+                break;
+            case 3:
+                status = 'delivered';
+                break;
+            case 4:
+                status = 'read';
+                break;
+            default:
+                status = 'sent';
+        }
+        if (tracked) {
+            tracked.ackStatus = ack;
+            tracked.status = status;
+            this.onMessageStatus?.(messageKey, message.from, status);
+        }
+    }
+    /** Get current connection state */
+    get connectionState() {
+        return this.#connectionState;
+    }
     async sendText(chatId, text) {
-        await this.#client.sendMessage(chatId, text);
+        const message = await this.#client.sendMessage(chatId, text);
+        // Use _serialized which is the reliable message ID in whatsapp-web.js
+        const messageId = message.id._serialized;
+        // Track the message for status updates
+        this.#trackedMessages.set(messageId, {
+            id: messageId,
+            chatId,
+            status: 'sent',
+            sentAt: new Date(),
+        });
+        return messageId;
+    }
+    /**
+     * Send an image with optional caption
+     */
+    async sendImage(chatId, imagePath, caption) {
+        const media = await MessageMedia.fromFilePath(imagePath);
+        const message = await this.#client.sendMessage(chatId, media, { caption });
+        const messageId = message.id._serialized;
+        this.#trackedMessages.set(messageId, {
+            id: messageId,
+            chatId,
+            status: 'sent',
+            sentAt: new Date(),
+        });
+        return messageId;
+    }
+    /**
+     * Send an image from URL
+     */
+    async sendImageFromUrl(chatId, url, caption) {
+        const media = await MessageMediaFromUrl(url, caption);
+        const message = await this.#client.sendMessage(chatId, media);
+        const messageId = message.id._serialized;
+        this.#trackedMessages.set(messageId, {
+            id: messageId,
+            chatId,
+            status: 'sent',
+            sentAt: new Date(),
+        });
+        return messageId;
+    }
+    /**
+     * Send a video with optional caption
+     */
+    async sendVideo(chatId, videoPath, caption) {
+        const media = await MessageMedia.fromFilePath(videoPath);
+        const message = await this.#client.sendMessage(chatId, media, { caption });
+        const messageId = message.id._serialized;
+        this.#trackedMessages.set(messageId, {
+            id: messageId,
+            chatId,
+            status: 'sent',
+            sentAt: new Date(),
+        });
+        return messageId;
+    }
+    /**
+     * Send a document/file
+     */
+    async sendDocument(chatId, filePath, caption) {
+        const media = await MessageMedia.fromFilePath(filePath);
+        const message = await this.#client.sendMessage(chatId, media, { caption });
+        const messageId = message.id._serialized;
+        this.#trackedMessages.set(messageId, {
+            id: messageId,
+            chatId,
+            status: 'sent',
+            sentAt: new Date(),
+        });
+        return messageId;
+    }
+    /**
+     * Send a document from URL
+     */
+    async sendDocumentFromUrl(chatId, url, filename, caption) {
+        const media = await MessageMediaFromUrl(url, caption, undefined, filename);
+        const message = await this.#client.sendMessage(chatId, media);
+        const messageId = message.id._serialized;
+        this.#trackedMessages.set(messageId, {
+            id: messageId,
+            chatId,
+            status: 'sent',
+            sentAt: new Date(),
+        });
+        return messageId;
+    }
+    /**
+     * Get message status
+     */
+    getMessageStatus(messageId) {
+        return this.#trackedMessages.get(messageId)?.status;
+    }
+    /**
+     * Force reconnection
+     */
+    async reconnect() {
+        this.#reconnectAttempts = 0;
+        await this.#client.initialize();
     }
     async sendVoice(chatId, audio) {
         const media = new MessageMedia('audio/wav', audio.toString('base64'), 'response.wav');