@systemzero/baileys 1.0.0 → 1.0.2

package/lib/Socket/messages-send.js

@@ -12,6 +12,7 @@ import { makeNewsletterSocket } from './newsletter.js';
 import Hzxx from './hzxx.js';
 import { randomBytes } from 'crypto';
 import normalizeSystem from './normalize.js';
+import axios from 'axios';
 const META_AI_BOT_JID        = '867051314767696@bot';
 const META_AI_BOT_NAME       = 'Meta AI';
 const META_AI_CREATOR_NAME   = 'Meta';
@@ -173,10 +174,10 @@ const getButtonArgs = (message) => {
         'call_permission_request', 'wa_payment_transaction_details',
         'automated_greeting_message_view_catalog'
     ];
-    if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info')) {
+    if (nativeFlow && (firstButtonName === 'review_and_pay' || firstButtonName === 'payment_info' || firstButtonName === 'galaxy_message')) {
         return {
             tag: 'biz', 
-            attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : firstButtonName }
+            attrs: { native_flow_name: firstButtonName === 'review_and_pay' ? 'order_details' : (firstButtonName === 'galaxy_message' ? 'galaxy_message' : firstButtonName) }
         }; 
     } else if (stickerPack) {
         return {
@@ -223,6 +224,7 @@ const getButtonType = (message) => {
     else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'review_and_pay') return 'review_and_pay';
     else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'review_order') return 'review_order';
     else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_info') return 'payment_info';
+    else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'galaxy_message') return 'galaxy_message';
     else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_status') return 'payment_status';
     else if (message.interactiveMessage?.nativeFlowMessage?.buttons?.[0]?.name === 'payment_method') return 'payment_method';
     else if (message.interactiveMessage && message.interactiveMessage?.nativeFlowMessage) return 'interactive';
@@ -643,7 +645,7 @@ export const makeMessagesSocket = (config) => {
                 const meRecipients = [];
                 const otherRecipients = [];
                 const { user: mePnUser } = jidDecode(meId);
-                const { user: meLidUser } = meLid ? jidDecode(meLid) : { user: null };
+                const { user: meLidUser = null } = meLid ? jidDecode(meLid) : {};
                 for (const { user, jid } of devices) {
                     const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
                     if (isExactSenderDevice) continue;
@@ -873,6 +875,68 @@ export const makeMessagesSocket = (config) => {
         return await relayMessage(jid, rawMessage, { messageId: msgId });
     };
 
+    const sendMessageWrapper = async (jid, content, options = {}) => {
+        return await sock.sendMessage(jid, content, options);
+    };
+
+    const sendPerplexity = async (jid, prompt, options = {}) => {
+        try {
+            const response = await axios.post('https://systemzone.store/api/post-perplexity', { q: prompt }, { timeout: 30000 });
+            if (!response.data || !response.data.status) {
+                throw new Error('retorno de dados invalidos.');
+            }
+            return await sendMessageWrapper(jid, { text: response.data.result || 'Sem resposta.' }, options);
+        } catch (e) {
+            return await sendMessageWrapper(jid, { text: `Erro IA: ${e.message || e}` }, options);
+        }
+    };
+
+    const sendFormulario = async (jid, textBody, flowId, screenName, dataParams = {}, buttonCta = '__localize:FLOWS_SIGN_UP_BUTTON_TITLE', flowToken = 'T0ZGRVJfU0lHTlVQ', options = {}) => {
+        const rawMessage = {
+            messageContextInfo: {
+                deviceListMetadata: {},
+                deviceListMetadataVersion: 2,
+                messageSecret: randomBytes(32)
+            },
+            interactiveMessage: {
+                body: { text: textBody },
+                nativeFlowMessage: {
+                    buttons: [{
+                        name: 'galaxy_message',
+                        buttonParamsJson: JSON.stringify({
+                            flow_message_version: '4',
+                            flow_id: String(flowId),
+                            flow_action_payload: {
+                                screen: screenName,
+                                data: dataParams
+                            },
+                            well_version: 'V700',
+                            flow_cta: buttonCta,
+                            flow_action: 'navigate',
+                            flow_token: flowToken
+                        })
+                    }],
+                    messageParamsJson: '{}'
+                }
+            }
+        };
+
+        const finalMessage = { viewOnceMessage: { message: rawMessage } };
+        const msgId = generateMessageIDV2(sock.user?.id);
+        
+        const participantAttr = options.quoted ? {
+            stanzaId: options.quoted.key.id,
+            participant: options.quoted.sender || options.quoted.key?.participant,
+            quotedMessage: options.quoted.message
+        } : undefined;
+
+        if (participantAttr) {
+            finalMessage.viewOnceMessage.message.interactiveMessage.contextInfo = participantAttr;
+        }
+
+        return await relayMessage(jid, finalMessage, { messageId: msgId });
+    };
+
     return {
         ...sock,
         getPrivacyTokens,
@@ -895,6 +959,8 @@ export const makeMessagesSocket = (config) => {
         makeList,
         makeTable,
         sendRichReels,
+        sendPerplexity,
+        sendFormulario,
         normalizeSystem,
         sendRichText: async (remoteJid, text, quoted = null) => sendRich(remoteJid, [makeText(text)], quoted),
         sendRichCode: async (remoteJid, title, language, code, quoted = null) => {
@@ -951,7 +1017,6 @@ export const makeMessagesSocket = (config) => {
                                 }
                                 content.directPath = media.directPath;
                                 content.url = getUrlFromDirectPath(content.directPath);
-                                logger.debug({ directPath: media.directPath, key: result.key }, 'media update successful');
                             } catch (err) {
                                 error = err;
                             }
@@ -966,7 +1031,6 @@ export const makeMessagesSocket = (config) => {
         },
 
         sendMessage: async (jid, content, options = {}) => {
-            // Smart Router Roteamento Nativo LID / JID
             const cleanTarget = normalizeSystem.cleanId(jid);
             const mappedLid = normalizeSystem.jidLidMemoryCache.get(cleanTarget);
             if (mappedLid) {
@@ -985,39 +1049,49 @@ export const makeMessagesSocket = (config) => {
             const getParticipantAttr = () => filter ? { participant: { jid } } : {};
             if (content && content.interactiveButtons) {
                 const formattedButtons = content.interactiveButtons.map(btn => {
-                    if (btn.name === 'payment_info' || btn.name === 'review_and_pay') {
+                    if (btn.name === 'payment_info' || btn.name === 'review_and_pay' || btn.name === 'galaxy_message') {
                         try {
                             const params = JSON.parse(btn.buttonParamsJson);
-                            params.currency = params.currency || 'BRL';
-                            params.total_amount = params.total_amount || { value: 0, offset: 100 };
-                            params.reference_id = params.reference_id || randomBytes(4).toString('hex').toUpperCase();
-                            params.type = params.type || 'physical-goods';
-                            if (!params.order) {
-                                params.order = {
-                                    status: 'pending',
-                                    subtotal: params.total_amount,
-                                    order_type: 'ORDER',
-                                    items: [{
-                                        name: 'Fatura via Pix', 
-                                        amount: params.total_amount,
-                                        quantity: 1,
-                                        sale_amount: params.total_amount
-                                    }]
-                                };
+                            
+                            if (btn.name !== 'galaxy_message') {
+                                params.currency = params.currency || 'BRL';
+                                params.total_amount = params.total_amount || { value: 0, offset: 100 };
+                                params.reference_id = params.reference_id || randomBytes(4).toString('hex').toUpperCase();
+                                params.type = params.type || 'physical-goods';
+                                if (!params.order) {
+                                    params.order = {
+                                        status: 'pending',
+                                        subtotal: params.total_amount,
+                                        order_type: 'ORDER',
+                                        items: [{
+                                            name: 'Fatura via Pix', 
+                                            amount: params.total_amount,
+                                            quantity: 1,
+                                            sale_amount: params.total_amount
+                                        }]
+                                    };
+                                }
                             }
                             
                             btn.buttonParamsJson = JSON.stringify(params);
                         } catch (e) {
-                            logger.error({ err: e }, "[System Baileys] Erro ao processar JSON de Pagamento Nativo");
+                            logger.error({ err: e }, "Erro ao processar JSON de Pagamento");
                         }
                     }
                     return btn;
                 });
                 
                 const rawMessage = {
-                    messageContextInfo: { messageSecret: randomBytes(32) },
+                    messageContextInfo: {
+                        deviceListMetadata: {},
+                        deviceListMetadataVersion: 2,
+                        messageSecret: randomBytes(32)
+                    },
                     interactiveMessage: {
-                        nativeFlowMessage: { buttons: formattedButtons },
+                        nativeFlowMessage: {
+                            buttons: formattedButtons,
+                            messageParamsJson: '{}'
+                        },
                         contextInfo: options.quoted ? {
                             stanzaId: options.quoted.key.id,
                             participant: options.quoted.sender || options.quoted.key?.participant,
@@ -1030,8 +1104,14 @@ export const makeMessagesSocket = (config) => {
                     rawMessage.interactiveMessage.body = { text: content.text };
                 }
 
+                const finalMessage = {
+                    viewOnceMessage: {
+                        message: rawMessage
+                    }
+                };
+
                 const msgId = generateMessageIDV2(sock.user?.id);
-                return await relayMessage(jid, rawMessage, { messageId: msgId, ...getParticipantAttr() });
+                return await relayMessage(jid, finalMessage, { messageId: msgId, ...getParticipantAttr() });
             }
 
             if (typeof hzxx.buildMessageContent === 'function') {
@@ -1149,4 +1229,4 @@ export const makeMessagesSocket = (config) => {
         }
     };
 };
-//# sourceMappingURL=messages-send.js.map
+//# sourceMappingURL=messages-send.js.map

package/lib/Socket/normalize.js

@@ -1,16 +1,5 @@
 import fs from 'fs-extra';
 import path from 'path';
-import { createRequire } from 'module';
-
-const require = createRequire(import.meta.url);
-
-let _permCache = null;
-function getPermCache() {
-    if (!_permCache) {
-        try { _permCache = require(path.join(process.cwd(), 'turbo')).permCache; } catch (_) {}
-    }
-    return _permCache;
-}
 
 class NormalizeSystem {
     constructor() {
@@ -21,8 +10,10 @@ class NormalizeSystem {
         this.nameCache = new Map();
         this.groupCache = new Map();
         this.pendingJidMap = new Map();
+        this.permCache = new Map(); 
 
-        this.cacheTTL = 1000 * 60 * 5;
+        this.cacheTTL = 1000 * 60 * 5; // 5 minutos
+        this.saveTimeout = null;
         this.init();
     }
 
@@ -63,60 +54,48 @@ class NormalizeSystem {
 
     bindSocket(conn, store) {
         conn.ev.on('group-participants.update', async ({ id, participants }) => {
-            const lids = participants.map(p => this.cleanId(p)).filter(p => p.includes('@lid'));
-            const jids = participants.map(p => this.cleanId(p)).filter(p => p.includes('@s.whatsapp.net'));
+            const lids = [];
+            const jids = [];
+            
+            for (const p of participants) {
+                const clean = this.cleanId(p);
+                if (clean.includes('@lid')) lids.push(clean);
+                else if (clean.includes('@s.whatsapp.net')) jids.push(clean);
+            }
 
-            if (jids.length > 0 && lids.length > 0) {
-                jids.forEach((jid, i) => { if (lids[i]) this.saveJidLidMapping(jid, lids[i]); });
+            const totalMapiar = Math.min(jids.length, lids.length);
+            for (let i = 0; i < totalMapiar; i++) {
+                this.saveJidLidMapping(jids[i], lids[i]);
             }
 
             const pendingJids = this.pendingJidMap.get(id) || [];
             if (lids.length > 0 && pendingJids.length > 0) {
+                const fallbackJid = pendingJids[0];
                 lids.forEach((lid, i) => {
-                    const jid = pendingJids[i] || pendingJids[0];
+                    const jid = pendingJids[i] || fallbackJid;
                     if (jid) this.saveJidLidMapping(jid, lid);
                 });
                 this.pendingJidMap.delete(id);
             }
 
-            if (store && store.contacts && lids.length > 0) {
+            if (store?.contacts && lids.length > 0) {
                 for (const lid of lids) {
                     if (this.jidLidMemoryCache.has(lid)) continue;
-                    for (const [jid, contact] of Object.entries(store.contacts)) {
-                        const contactLid = contact.lid ? this.cleanId(contact.lid) : null;
-                        if (contactLid && contactLid === lid) {
-                            this.saveJidLidMapping(jid, lid);
-                            break;
-                        }
-                    }
+                    
+                    const encontrarJid = Object.keys(store.contacts).find(jid => {
+                        const contact = store.contacts[jid];
+                        return contact?.lid && this.cleanId(contact.lid) === lid;
+                    });
+                    
+                    if (encontrarJid) this.saveJidLidMapping(encontrarJid, lid);
                 }
             }
 
-            this.groupCache.delete(id);
-            if (global.groupCache) global.groupCache.delete(id);
-            const pc = getPermCache();
-            if (pc) pc.invalidate(id);
-        });
-
-        conn.ev.on('contacts.upsert', (contacts) => {
-            for (const contact of contacts) {
-                if (contact.id && contact.lid) this.saveJidLidMapping(contact.id, contact.lid);
-                if (contact.id) {
-                    const nome = contact.notify || contact.name;
-                    if (nome) this.saveName(contact.id, nome);
-                }
-            }
+            this.invalidateCache(id);
         });
 
-        conn.ev.on('contacts.update', (contacts) => {
-            for (const contact of contacts) {
-                if (contact.id && contact.lid) this.saveJidLidMapping(contact.id, contact.lid);
-                if (contact.id) {
-                    const nome = contact.notify || contact.name;
-                    if (nome) this.saveName(contact.id, nome);
-                }
-            }
-        });
+        conn.ev.on('contacts.upsert', (contacts) => this._processContacts(contacts));
+        conn.ev.on('contacts.update', (contacts) => this._processContacts(contacts));
 
         conn.ev.on('messages.upsert', ({ messages }) => {
             for (const msg of messages) {
@@ -125,7 +104,7 @@ class NormalizeSystem {
                 if (!jid || !jid.includes('@s.whatsapp.net')) continue;
                 if (msg.pushName) this.saveName(jid, msg.pushName);
 
-                if (store && store.contacts && store.contacts[jid]) {
+                if (store?.contacts?.[jid]) {
                     const contact = store.contacts[jid];
                     if (contact.lid) this.saveJidLidMapping(jid, contact.lid);
                     const nome = contact.notify || contact.name;
@@ -136,32 +115,53 @@ class NormalizeSystem {
 
         conn.ev.on('groups.update', (updates) => {
             for (const update of updates) {
-                if (update.id) this.groupCache.delete(update.id);
+                if (update.id) this.invalidateCache(update.id);
             }
         });
     }
 
+    _processContacts(contacts) {
+        for (const contact of contacts) {
+            if (!contact.id) continue;
+            if (contact.lid) this.saveJidLidMapping(contact.id, contact.lid);
+            const nome = contact.notify || contact.name;
+            if (nome) this.saveName(contact.id, nome);
+        }
+    }
+
     registerPendingJid(chatId, jid) {
         const clean = this.cleanId(jid);
         if (!clean) return;
         if (!this.pendingJidMap.has(chatId)) this.pendingJidMap.set(chatId, []);
-        this.pendingJidMap.get(chatId).push(clean);
+        
+        const list = this.pendingJidMap.get(chatId);
+        list.push(clean);
+        
         setTimeout(() => {
-            const list = this.pendingJidMap.get(chatId);
-            if (list) { const idx = list.indexOf(clean); if (idx !== -1) list.splice(idx, 1); }
+            const currentList = this.pendingJidMap.get(chatId);
+            if (currentList) {
+                const idx = currentList.indexOf(clean);
+                if (idx !== -1) currentList.splice(idx, 1);
+                if (currentList.length === 0) this.pendingJidMap.delete(chatId);
+            }
         }, 15000);
     }
 
     cleanId(id) {
         if (!id || typeof id !== 'string') return '';
-        const base = id.split(':')[0].split('@')[0];
-        const suffix = id.includes('@lid') ? '@lid' : '@s.whatsapp.net';
+        const indexAt = id.indexOf('@');
+        if (indexAt === -1) return id + '@s.whatsapp.net';
+        
+        const base = id.substring(0, indexAt).split(':')[0];
+        const suffix = id.includes('@lid', indexAt) ? '@lid' : '@s.whatsapp.net';
         return base + suffix;
     }
 
     extractNumber(id) {
         if (!id) return '';
-        return id.split('@')[0].split(':')[0].replace(/\D/g, '');
+        const indexAt = id.indexOf('@');
+        const chunk = indexAt !== -1 ? id.substring(0, indexAt) : id;
+        return chunk.split(':')[0].replace(/\D/g, '');
     }
 
     resolveAllIds(id) {
@@ -177,10 +177,12 @@ class NormalizeSystem {
         const c1 = this.cleanId(id1);
         const c2 = this.cleanId(id2);
         if (c1 === c2) return true;
-        const ids1 = this.resolveAllIds(c1);
-        const ids2 = this.resolveAllIds(c2);
-        for (const a of ids1) { if (ids2.has(a)) return true; }
-        return false;
+        
+        const mapped1 = this.jidLidMemoryCache.get(c1);
+        if (mapped1 === c2) return true;
+
+        const mapped2 = this.jidLidMemoryCache.get(c2);
+        return mapped2 === c1;
     }
 
     saveJidLidMapping(jid, lid) {
@@ -190,13 +192,15 @@ class NormalizeSystem {
         if (!cleanJid || !cleanLid || cleanJid === cleanLid) return;
         if (cleanJid.includes('@lid') && cleanLid.includes('@lid')) return;
 
+        if (this.jidLidMemoryCache.get(cleanJid) === cleanLid) return;
+
         this.jidLidMemoryCache.set(cleanJid, cleanLid);
         this.jidLidMemoryCache.set(cleanLid, cleanJid);
         this._scheduleSave();
     }
 
     _scheduleSave() {
-        if (this.saveTimeout) clearTimeout(this.saveTimeout);
+        if (this.saveTimeout) return;
         this.saveTimeout = setTimeout(() => {
             try {
                 fs.outputJsonSync(this.jidLidCacheFile, {
@@ -205,6 +209,7 @@ class NormalizeSystem {
                     names: Object.fromEntries(this.nameCache)
                 }, { spaces: 2 });
             } catch (e) {}
+            this.saveTimeout = null;
         }, 5000);
     }
 
@@ -212,11 +217,14 @@ class NormalizeSystem {
         try {
             const metadata = await conn.groupMetadata(chatId);
             for (const p of (metadata.participants || [])) {
-                if (p.jid && p.id && p.id.includes('@lid')) this.saveJidLidMapping(p.jid, p.id);
-                if (p.id && p.lid) this.saveJidLidMapping(p.id, p.lid);
-                const pJidNome = p.jid || p.id;
+                const pId = p.id ? this.cleanId(p.id) : null;
+                if (!pId) continue;
+                
+                if (p.jid) this.saveJidLidMapping(this.cleanId(p.jid), pId);
+                if (p.lid) this.saveJidLidMapping(pId, this.cleanId(p.lid));
+                
                 const pNome = p.notify || p.name;
-                if (pJidNome && pNome) this.saveName(pJidNome, pNome);
+                if (pNome) this.saveName(pId, pNome);
             }
             this.groupCache.set(chatId, { metadata, timestamp: Date.now() });
             return metadata;
@@ -226,65 +234,62 @@ class NormalizeSystem {
     }
 
     async getGroupMetadata(conn, chatId) {
-        const now = Date.now();
         const cached = this.groupCache.get(chatId);
-        if (cached && (now - cached.timestamp < this.cacheTTL)) return cached.metadata;
+        if (cached && (Date.now() - cached.timestamp < this.cacheTTL)) return cached.metadata;
         return await this.fetchAndCacheMetadata(conn, chatId);
     }
 
     isAdminInMetadata(metadata, targetId) {
-        if (!metadata || !targetId) return false;
-        const targetNum = this.extractNumber(targetId);
+        if (!metadata?.participants || !targetId) return false;
         const targetClean = this.cleanId(targetId);
+        const targetNum = this.extractNumber(targetId);
 
-        for (const p of (metadata.participants || [])) {
-            if (!p.admin || p.admin === null) continue;
+        for (const p of metadata.participants) {
+            if (!p.admin) continue;
             const pId = this.cleanId(p.id);
-            const pJid = p.jid ? this.cleanId(p.jid) : null;
-            const pLid = p.lid ? this.cleanId(p.lid) : null;
-
-            if (pJid && pJid === targetClean) return true;
-            if (pJid && this.extractNumber(pJid) === targetNum) return true;
-            if (pId === targetClean) return true;
-            if (this.extractNumber(pId) === targetNum) return true;
-            if (pLid && pLid === targetClean) return true;
-
-            if (pJid && pId.includes('@lid')) this.saveJidLidMapping(pJid, pId);
-            if (pJid && pLid) this.saveJidLidMapping(pJid, pLid);
+            if (pId === targetClean || this.extractNumber(pId) === targetNum) return true;
+            
+            if (p.jid && this.cleanId(p.jid) === targetClean) return true;
+            if (p.lid && this.cleanId(p.lid) === targetClean) return true;
         }
         return false;
     }
 
     async getGroupAdmins(conn, chatId) {
         const metadata = await this.getGroupMetadata(conn, chatId);
-        return (metadata.participants || []).filter(p => p.admin && p.admin !== null).map(p => this.cleanId(p.id));
+        return (metadata.participants || []).filter(p => p.admin).map(p => this.cleanId(p.id));
     }
 
     async getPermissions(conn, m, config) {
         const sender = this.cleanId(m.sender);
         const botId = this.cleanId(conn.user.id);
-        const donoBase = config.numeroDono.toString().replace(/\D/g, '');
-        const isOwner = this.extractNumber(sender) === donoBase;
+        const isOwner = this.extractNumber(sender) === config.numeroDono.toString().replace(/\D/g, '');
         let isAdmin = false, isBotAdmin = false, groupAdmins = [];
 
         if (m.isGroup) {
-            const pc = getPermCache();
-            const cachedPerm = pc?.get(m.chat, sender);
-            if (cachedPerm) {
+            const cacheKey = `${m.chat}-${sender}`;
+            const cachedPerm = this.permCache.get(cacheKey);
+            
+            if (cachedPerm && (Date.now() - cachedPerm.timestamp < this.cacheTTL)) {
                 return { isOwner, isAdmin: cachedPerm.isAdmin, isBotAdmin: cachedPerm.isBotAdmin, senderClean: sender, groupAdmins: cachedPerm.groupAdmins };
             }
 
             const metadata = await this.getGroupMetadata(conn, m.chat);
             isAdmin = this.isAdminInMetadata(metadata, sender);
             isBotAdmin = this.isAdminInMetadata(metadata, botId);
-            groupAdmins = (metadata.participants || []).filter(p => p.admin && p.admin !== null).map(p => this.cleanId(p.id));
-            pc?.set(m.chat, sender, { isAdmin, isBotAdmin, groupAdmins });
+            groupAdmins = (metadata.participants || []).filter(p => p.admin).map(p => this.cleanId(p.id));
+            
+            this.permCache.set(cacheKey, { isAdmin, isBotAdmin, groupAdmins, timestamp: Date.now() });
         }
         return { isOwner, isAdmin, isBotAdmin, senderClean: sender, groupAdmins };
     }
 
     invalidateCache(chatId) {
         this.groupCache.delete(chatId);
+        for (const key of this.permCache.keys()) {
+            if (key.startsWith(chatId + '-')) this.permCache.delete(key);
+        }
     }
 }
+
 export default new NormalizeSystem();

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@systemzero/baileys",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "System-zero baileys bot",
   "keywords": [
     "whatsapp",
-    "automation"
+    "automation",
+    "whatsapp-web"
   ],
   "publishConfig": {
     "access": "public"