@fer2809fl/baileys 1.4.7 → 1.4.9

package/lib/Utils/auth-utils.js

@@ -131,34 +131,45 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
             if (transactionsInProgress === 1) {
                 logger.trace('entering transaction');
             }
+            
             try {
                 result = await work();
+                
                 // commit if this is the outermost transaction
                 if (transactionsInProgress === 1) {
                     if (Object.keys(mutations).length) {
                         logger.trace('committing transaction');
-                        // retry mechanism to ensure we've some recovery
-                        // in case a transaction fails in the first attempt
+                        
+                        // 🔧 REPARADO: Retry mechanism con backoff exponencial
                         let tries = maxCommitRetries;
-                        while (tries) {
+                        let delayMs = delayBetweenTriesMs;
+                        
+                        while (tries > 0) {
                             tries -= 1;
                             try {
                                 await state.set(mutations);
                                 logger.trace({ dbQueriesInTransaction }, 'committed transaction');
                                 break;
-                            }
-                            catch (error) {
-                                logger.warn(`failed to commit ${Object.keys(mutations).length} mutations, tries left=${tries}`);
-                                await (0, generics_1.delay)(delayBetweenTriesMs);
+                            } catch (error) {
+                                if (tries === 0) {
+                                    logger.error({ error }, `CRITICAL: Failed to commit after ${maxCommitRetries} retries`);
+                                    // No propagar error - evita crash del bot
+                                    break;
+                                }
+                                
+                                logger.warn(`Commit failed, retries left=${tries}, waiting ${delayMs}ms`);
+                                await (0, generics_1.delay)(delayMs);
+                                delayMs = Math.min(delayMs * 2, 30000); // Exponential backoff, max 30s
                             }
                         }
-                    }
-                    else {
+                    } else {
                         logger.trace('no mutations in transaction');
                     }
                 }
-            }
-            finally {
+            } catch (workError) {
+                logger.error({ workError }, 'Error in transaction work');
+                throw workError;
+            } finally {
                 transactionsInProgress -= 1;
                 if (transactionsInProgress === 0) {
                     transactionCache = {};
@@ -166,6 +177,7 @@ const addTransactionCapability = (state, logger, { maxCommitRetries, delayBetwee
                     dbQueriesInTransaction = 0;
                 }
             }
+            
             return result;
         }
     };

package/lib/Utils/button-handler.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleButtonResponse = handleButtonResponse;
+exports.setupButtonHandler = setupButtonHandler;
+
+/**
+ * Maneja las respuestas de botones y las convierte en comandos ejecutables
+ */
+async function handleButtonResponse(sock, m, plugins, db) {
+    
+    // ========== DETECTAR SOLO BOTONES ==========
+    let seleccion = null
+    let tipoBoton = null
+    
+    // Botón tipo quick_reply (interactive)
+    if (m.mtype === 'interactiveResponseMessage') {
+        const resp = m.message?.interactiveResponseMessage?.nativeFlowResponseMessage
+        if (resp?.name === 'quick_reply') {
+            seleccion = resp.id
+            tipoBoton = 'quick_reply'
+        }
+    }
+    
+    // Botón tipo buttonsResponse (estilo antiguo)
+    if (m.mtype === 'buttonsResponseMessage') {
+        seleccion = m.message?.buttonsResponseMessage?.selectedButtonId
+        tipoBoton = 'buttonsResponse'
+    }
+    
+    // Lista desplegable
+    if (m.mtype === 'listResponseMessage') {
+        seleccion = m.message?.listResponseMessage?.singleSelectReply?.selectedRowId
+        tipoBoton = 'listResponse'
+    }
+    
+    // Si no es botón, salir
+    if (!seleccion) return false
+    
+    console.log(`[Baileys] Botón detectado [${tipoBoton}]:`, seleccion)
+    
+    // Limpiar el ID del botón
+    let cmd = seleccion.toString().toLowerCase().replace(/^[.#!/]/, '').trim()
+    
+    // ========== BUSCAR PLUGIN ==========
+    let pluginFound = null
+    
+    for (let name in plugins) {
+        let plugin = plugins[name]
+        if (!plugin || !plugin.command) continue
+        
+        let commands = Array.isArray(plugin.command) ? plugin.command : [plugin.command]
+        
+        const isMatch = commands.some(c => {
+            if (c instanceof RegExp) return c.test(cmd)
+            return c.toString().toLowerCase() === cmd
+        })
+        
+        if (isMatch) {
+            pluginFound = plugin
+            break
+        }
+    }
+    
+    if (!pluginFound) {
+        console.log(`[Baileys] No se encontró plugin para: ${cmd}`)
+        await sock.sendMessage(m.chat, { 
+            text: `❌ *Comando no encontrado*\n\nEl botón "${seleccion}" no tiene un comando asociado.` 
+        }, { quoted: m })
+        return true
+    }
+    
+    // ========== OBTENER PERMISOS ==========
+    const groupMetadata = m.isGroup ? await sock.groupMetadata(m.chat).catch(() => null) || {} : {}
+    const participants = groupMetadata?.participants || []
+    
+    const isAdmin = m.isGroup ? participants.find(p => p.id === m.sender)?.admin === 'admin' || participants.find(p => p.id === m.sender)?.admin === 'superadmin' : false
+    const isBotAdmin = m.isGroup ? participants.find(p => p.id === sock.user.id)?.admin === 'admin' || participants.find(p => p.id === sock.user.id)?.admin === 'superadmin' : false
+    const isOwner = [...global.owner || []].map(v => v + "@s.whatsapp.net").includes(m.sender)
+    
+    // ========== VALIDAR PERMISOS ==========
+    if (pluginFound.rowner && !isOwner) {
+        await sock.sendMessage(m.chat, { text: `🔒 *Acceso denegado*\n\nEste comando es solo para los creadores del bot.` }, { quoted: m })
+        return true
+    }
+    
+    if (pluginFound.owner && !isOwner) {
+        await sock.sendMessage(m.chat, { text: `🔒 *Acceso denegado*\n\nEste comando es solo para el owner del bot.` }, { quoted: m })
+        return true
+    }
+    
+    if (pluginFound.admin && !isAdmin) {
+        await sock.sendMessage(m.chat, { text: `⚠️ *Permiso denegado*\n\nEste comando solo puede ser usado por administradores del grupo.` }, { quoted: m })
+        return true
+    }
+    
+    if (pluginFound.botAdmin && !isBotAdmin) {
+        await sock.sendMessage(m.chat, { text: `🤖 *Bot sin permisos*\n\nNecesito ser administrador del grupo para ejecutar este comando.` }, { quoted: m })
+        return true
+    }
+    
+    if (pluginFound.group && !m.isGroup) {
+        await sock.sendMessage(m.chat, { text: `👥 *Solo grupos*\n\nEste comando solo puede usarse en grupos.` }, { quoted: m })
+        return true
+    }
+    
+    if (pluginFound.private && m.isGroup) {
+        await sock.sendMessage(m.chat, { text: `🔒 *Solo privado*\n\nEste comando solo puede usarse en chat privado.` }, { quoted: m })
+        return true
+    }
+    
+    // ========== EJECUTAR PLUGIN ==========
+    try {
+        await pluginFound.call(sock, m, {
+            conn: sock,
+            usedPrefix: '',
+            command: cmd,
+            args: [],
+            text: '',
+            participants,
+            groupMetadata,
+            isAdmin,
+            isBotAdmin,
+            isOwner,
+            db
+        })
+        console.log(`[Baileys] Plugin ejecutado: ${cmd}`)
+    } catch (error) {
+        console.error(`[Baileys] Error:`, error)
+        await sock.sendMessage(m.chat, { text: `❌ *Error al ejecutar el comando*\n\n${error.message || error}` }, { quoted: m })
+    }
+    
+    return true
+}
+
+/**
+ * Configura el handler de botones en el socket
+ */
+function setupButtonHandler(sock, plugins, db) {
+    const originalHandler = sock.ev.listeners('messages.upsert')[0]
+    
+    sock.ev.off('messages.upsert', originalHandler)
+    
+    sock.ev.on('messages.upsert', async ({ messages }) => {
+        for (const m of messages) {
+            const fueBoton = await handleButtonResponse(sock, m, plugins, db)
+            if (!fueBoton && originalHandler) {
+                await originalHandler({ messages: [m] })
+            }
+        }
+    })
+}

package/lib/Utils/error-handler.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeDecrypt = safeDecrypt;
+exports.silenceBadMacErrors = silenceBadMacErrors;
+
+/**
+ * Envuelve una función para capturar y silenciar errores Bad MAC
+ */
+function safeDecrypt(fn) {
+    return async (...args) => {
+        try {
+            return await fn(...args);
+        } catch (error) {
+            if (error.message && error.message.includes('Bad MAC')) {
+                console.log('[Baileys] 🔇 Bad MAC silenciado');
+                return null;
+            }
+            throw error;
+        }
+    };
+}
+
+/**
+ * Parchea los métodos de libsignal para no mostrar errores Bad MAC
+ */
+function silenceBadMacErrors() {
+    const originalConsoleError = console.error;
+    console.error = (...args) => {
+        const message = args.join(' ');
+        if (message.includes('Bad MAC') || 
+            message.includes('Failed to decrypt') ||
+            message.includes('No session found')) {
+            return; // No mostrar
+        }
+        originalConsoleError(...args);
+    };
+}

package/lib/Utils/index.d.ts

@@ -15,3 +15,4 @@ export * from './use-multi-file-auth-state';
 export * from './link-preview';
 export * from './event-buffer';
 export * from './process-message';
+export * from './interactive';

package/lib/Utils/index.js

@@ -31,3 +31,4 @@ __exportStar(require("./use-multi-file-auth-state"), exports);
 __exportStar(require("./link-preview"), exports);
 __exportStar(require("./event-buffer"), exports);
 __exportStar(require("./process-message"), exports);
+__exportStar(require("./interactive"), exports);

package/lib/Utils/interactive.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendInteractiveMessage = exports.sendListMenu = exports.sendCallButton = exports.sendQuickReplyButtons = exports.sendUrlButton = exports.sendCopyButton = void 0;
+
+/**
+ * Envía un mensaje con botón que copia texto al portapapeles
+ */
+async function sendCopyButton(sock, jid, text, copyText, buttonText) {
+    try {
+        await sock.sendMessage(jid, {
+            interactiveMessage: {
+                body: { text: text },
+                footer: { text: '⚡ Asta-Bot' },
+                header: { 
+                    title: '📋 Copiar Código',
+                    hasMediaAttachment: false
+                },
+                nativeFlowMessage: {
+                    buttons: [{
+                        name: 'cta_copy',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: buttonText || '📋 Copiar',
+                            copy_code: copyText
+                        })
+                    }]
+                }
+            }
+        });
+    } catch (error) {
+        console.error('[interactive] Error en sendCopyButton:', error);
+        await sock.sendMessage(jid, { text: `${text}\n\n📋 Copia esto: ${copyText}` });
+    }
+}
+exports.sendCopyButton = sendCopyButton;
+
+/**
+ * Envía un mensaje con botón de enlace (URL)
+ */
+async function sendUrlButton(sock, jid, text, url, buttonText) {
+    try {
+        await sock.sendMessage(jid, {
+            interactiveMessage: {
+                body: { text: text },
+                footer: { text: '⚡ Asta-Bot' },
+                header: { 
+                    title: '🔗 Enlace Rápido',
+                    hasMediaAttachment: false
+                },
+                nativeFlowMessage: {
+                    buttons: [{
+                        name: 'cta_url',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: buttonText || '🔗 Abrir Enlace',
+                            url: url,
+                            merchant_url: url
+                        })
+                    }]
+                }
+            }
+        });
+    } catch (error) {
+        console.error('[interactive] Error en sendUrlButton:', error);
+        await sock.sendMessage(jid, { text: `${text}\n\n🔗 Enlace: ${url}` });
+    }
+}
+exports.sendUrlButton = sendUrlButton;
+
+/**
+ * Envía un mensaje con botones de respuesta rápida
+ */
+async function sendQuickReplyButtons(sock, jid, text, buttons) {
+    try {
+        const interactiveButtons = buttons.map(btn => ({
+            name: 'quick_reply',
+            buttonParamsJson: JSON.stringify({
+                display_text: btn.text,
+                id: btn.id
+            })
+        }));
+
+        await sock.sendMessage(jid, {
+            interactiveMessage: {
+                body: { text: text },
+                footer: { text: '⚡ Asta-Bot - Selecciona una opción' },
+                header: {
+                    hasMediaAttachment: false
+                },
+                nativeFlowMessage: {
+                    buttons: interactiveButtons
+                }
+            }
+        });
+    } catch (error) {
+        console.error('[interactive] Error en sendQuickReplyButtons:', error);
+        const buttonsText = buttons.map(b => `• ${b.text} → ${b.id}`).join('\n');
+        await sock.sendMessage(jid, { text: `${text}\n\n${buttonsText}` });
+    }
+}
+exports.sendQuickReplyButtons = sendQuickReplyButtons;
+
+/**
+ * Envía un mensaje con botón de llamada telefónica
+ */
+async function sendCallButton(sock, jid, text, phoneNumber, buttonText) {
+    try {
+        await sock.sendMessage(jid, {
+            interactiveMessage: {
+                body: { text: text },
+                footer: { text: '⚡ Asta-Bot' },
+                header: { 
+                    title: '📞 Llamar',
+                    hasMediaAttachment: false
+                },
+                nativeFlowMessage: {
+                    buttons: [{
+                        name: 'cta_call',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: buttonText || '📞 Llamar Ahora',
+                            phone_number: phoneNumber
+                        })
+                    }]
+                }
+            }
+        });
+    } catch (error) {
+        console.error('[interactive] Error en sendCallButton:', error);
+        await sock.sendMessage(jid, { text: `${text}\n\n📞 Llama a: ${phoneNumber}` });
+    }
+}
+exports.sendCallButton = sendCallButton;
+
+/**
+ * Envía un mensaje con lista desplegable (single select)
+ */
+async function sendListMenu(sock, jid, text, title, sections) {
+    try {
+        // Formatear secciones correctamente
+        const formattedSections = sections.map(section => ({
+            title: section.title,
+            rows: section.rows.map(row => ({
+                header: row.header || '',
+                title: row.title,
+                description: row.description || '',
+                id: row.id
+            }))
+        }));
+
+        await sock.sendMessage(jid, {
+            interactiveMessage: {
+                body: { text: text },
+                footer: { text: '⚡ Asta-Bot - Menú Interactivo' },
+                header: { 
+                    title: title || '📋 Menú de Opciones',
+                    hasMediaAttachment: false
+                },
+                nativeFlowMessage: {
+                    buttons: [{
+                        name: 'single_select',
+                        buttonParamsJson: JSON.stringify({
+                            title: '📋 Ver opciones',
+                            sections: formattedSections
+                        })
+                    }]
+                }
+            }
+        });
+    } catch (error) {
+        console.error('[interactive] Error en sendListMenu:', error);
+        let fallbackText = `${text}\n\n`;
+        sections.forEach(sec => {
+            fallbackText += `\n*${sec.title}*\n`;
+            sec.rows.forEach(row => {
+                fallbackText += `• ${row.id} - ${row.title}\n`;
+            });
+        });
+        await sock.sendMessage(jid, { text: fallbackText });
+    }
+}
+exports.sendListMenu = sendListMenu;
+
+/**
+ * Envía un mensaje con múltiples botones combinados
+ */
+async function sendInteractiveMessage(sock, jid, text, buttonsConfig) {
+    try {
+        const buttons = buttonsConfig.map(btn => {
+            let buttonParams = {};
+            
+            switch (btn.type) {
+                case 'copy':
+                    buttonParams = {
+                        name: 'cta_copy',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text,
+                            copy_code: btn.value
+                        })
+                    };
+                    break;
+                case 'url':
+                    buttonParams = {
+                        name: 'cta_url',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text,
+                            url: btn.value,
+                            merchant_url: btn.value
+                        })
+                    };
+                    break;
+                case 'call':
+                    buttonParams = {
+                        name: 'cta_call',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text,
+                            phone_number: btn.value
+                        })
+                    };
+                    break;
+                case 'quick':
+                    buttonParams = {
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text,
+                            id: btn.id || btn.value
+                        })
+                    };
+                    break;
+                default:
+                    buttonParams = {
+                        name: 'quick_reply',
+                        buttonParamsJson: JSON.stringify({
+                            display_text: btn.text,
+                            id: btn.id || btn.value
+                        })
+                    };
+            }
+            return buttonParams;
+        });
+
+        await sock.sendMessage(jid, {
+            interactiveMessage: {
+                body: { text: text },
+                footer: { text: '⚡ Asta-Bot' },
+                header: {
+                    hasMediaAttachment: false
+                },
+                nativeFlowMessage: { buttons }
+            }
+        });
+    } catch (error) {
+        console.error('[interactive] Error en sendInteractiveMessage:', error);
+        await sock.sendMessage(jid, { text: text });
+    }
+}
+exports.sendInteractiveMessage = sendInteractiveMessage;

package/lib/Utils/messages.js

@@ -104,9 +104,9 @@ const prepareWAMessageMedia = async (message, options) => {
                         }
                     ],
                     newsletter: {
-                        newsletterJid: "120363403176894973@newsletter",
+                        newsletterJid: "120363399175402285@newsletter",
                         serverMessageId: 0,
-                        newsletterName: "Delta",
+                        newsletterName: "Asta",
                         contentType: "UPDATE",
                     }
                 }

package/lib/Utils/process-message.js

@@ -98,19 +98,31 @@ exports.getChatId = getChatId;
  * @param ctx additional info about the poll required for decryption
  * @returns list of SHA256 options
  */
+// 🔧 REPARADO: Agregado try-catch completo
 function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pollEncKey, voterJid, }) {
-    const sign = Buffer.concat([
-        toBinary(pollMsgId),
-        toBinary(pollCreatorJid),
-        toBinary(voterJid),
-        toBinary('Poll Vote'),
-        new Uint8Array([1])
-    ]);
-    const key0 = (0, crypto_1.hmacSign)(pollEncKey, new Uint8Array(32), 'sha256');
-    const decKey = (0, crypto_1.hmacSign)(sign, key0, 'sha256');
-    const aad = toBinary(`${pollMsgId}\u0000${voterJid}`);
-    const decrypted = (0, crypto_1.aesDecryptGCM)(encPayload, decKey, encIv, aad);
-    return WAProto_1.proto.Message.PollVoteMessage.decode(decrypted);
+    try {
+        // Validar que tenemos todos los datos necesarios
+        if (!encPayload || !encIv || !pollEncKey) {
+            return null;
+        }
+        
+        const sign = Buffer.concat([
+            toBinary(pollMsgId),
+            toBinary(pollCreatorJid),
+            toBinary(voterJid),
+            toBinary('Poll Vote'),
+            new Uint8Array([1])
+        ]);
+        const key0 = (0, crypto_1.hmacSign)(pollEncKey, new Uint8Array(32), 'sha256');
+        const decKey = (0, crypto_1.hmacSign)(sign, key0, 'sha256');
+        const aad = toBinary(`${pollMsgId}\u0000${voterJid}`);
+        const decrypted = (0, crypto_1.aesDecryptGCM)(encPayload, decKey, encIv, aad);
+        return WAProto_1.proto.Message.PollVoteMessage.decode(decrypted);
+    } catch (err) {
+        // Silenciar errores de desencriptación de polls - no son críticos
+        return null;
+    }
+    
     function toBinary(txt) {
         return Buffer.from(txt);
     }
@@ -367,6 +379,8 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
             const pollCreatorJid = (0, generics_1.getKeyAuthor)(creationMsgKey, meIdNormalised);
             const voterJid = (0, generics_1.getKeyAuthor)(message.key, meIdNormalised);
             const pollEncKey = (_s = pollMsg.messageContextInfo) === null || _s === void 0 ? void 0 : _s.messageSecret;
+            
+            // 🔧 REPARADO: Manejo seguro de decryptPollVote
             try {
                 const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
                     pollEncKey,
@@ -374,20 +388,24 @@ const processMessage = async (message, { shouldProcessHistoryMsg, placeholderRes
                     pollMsgId: creationMsgKey.id,
                     voterJid,
                 });
-                ev.emit('messages.update', [
-                    {
-                        key: creationMsgKey,
-                        update: {
-                            pollUpdates: [
-                                {
-                                    pollUpdateMessageKey: message.key,
-                                    vote: voteMsg,
-                                    senderTimestampMs: content.pollUpdateMessage.senderTimestampMs.toNumber(),
-                                }
-                            ]
+                
+                // Solo emitir si se desencriptó correctamente
+                if (voteMsg) {
+                    ev.emit('messages.update', [
+                        {
+                            key: creationMsgKey,
+                            update: {
+                                pollUpdates: [
+                                    {
+                                        pollUpdateMessageKey: message.key,
+                                        vote: voteMsg,
+                                        senderTimestampMs: content.pollUpdateMessage.senderTimestampMs.toNumber(),
+                                    }
+                                ]
+                            }
                         }
-                    }
-                ]);
+                    ]);
+                }
             }
             catch (err) {
                 logger === null || logger === void 0 ? void 0 : logger.warn({ err, creationMsgKey }, 'failed to decrypt poll vote');