@mrlegendbot/baileys 1.0.0 → 1.1.1

package/lib/Socket/messages-send.js

@@ -10,31 +10,25 @@ import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, res
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isLidUser, isPnUser, jidDecode, jidEncode, jidNormalizedUser, PSA_WID, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { USyncQuery, USyncUser } from '../WAUSync/index.js';
 import { makeNewsletterSocket } from './newsletter.js';
+
 export const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: httpRequestOptions, patchMessageBeforeSending, cachedGroupMetadata, enableRecentMessageCache, maxMsgRetryCount } = config;
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, registerSocketEndHandler } = sock;
     const getLIDForPN = signalRepository.lidMapping.getLIDForPN.bind(signalRepository.lidMapping);
-    /**
-     * Set of tctoken storage JIDs with a fire-and-forget `issuePrivacyTokens` IQ in flight.
-     * Prevents duplicate IQs from rapid back-to-back sends before `senderTimestamp` persists.
-     * Entries are always removed in `.finally()`, so the set is bounded by concurrency.
-     */
+
     const inFlightTcTokenIssuance = new Set();
     const userDevicesCache = config.userDevicesCache ||
         new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
+            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
             useClones: false
         });
-    /** Serializes writes to userDevicesCache across USync refresh and device-notification handling. */
     const devicesMutex = makeMutex();
-    // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;
-    // Prevent race conditions in Signal session encryption by user
     const encryptionMutex = makeKeyedMutex();
     let mediaConn;
-    /** Per-socket media host; updated whenever media_conn is fetched. Defaults to the public WhatsApp host. */
     let mediaHost = DEF_MEDIA_HOST;
+
     const refreshMediaConn = async (forceGet = false) => {
         const media = await mediaConn;
         if (!media || forceGet || new Date().getTime() - media.fetchDate.getTime() > media.ttl * 1000) {
@@ -49,7 +43,6 @@ export const makeMessagesSocket = (config) => {
                     content: [{ tag: 'media_conn', attrs: {} }]
                 });
                 const mediaConnNode = getBinaryNodeChild(result, 'media_conn');
-                // TODO: explore full length of data that whatsapp provides
                 const node = {
                     hosts: getBinaryNodeChildren(mediaConnNode, 'host').map(({ attrs }) => ({
                         hostname: attrs.hostname,
@@ -68,10 +61,7 @@ export const makeMessagesSocket = (config) => {
         }
         return mediaConn;
     };
-    /**
-     * generic send receipt function
-     * used for receipts of phone call, read, delivery etc.
-     * */
+
     const sendReceipt = async (jid, participant, messageIds, type) => {
         if (!messageIds || messageIds.length === 0) {
             throw new Boom('missing ids in receipt');
@@ -115,21 +105,20 @@ export const makeMessagesSocket = (config) => {
         logger.debug({ attrs: node.attrs, messageIds }, 'sending receipt for messages');
         await sendNode(node);
     };
-    /** Correctly bulk send receipts to multiple chats, participants */
+
     const sendReceipts = async (keys, type) => {
         const recps = aggregateMessageKeysNotFromMe(keys);
         for (const { jid, participant, messageIds } of recps) {
             await sendReceipt(jid, participant, messageIds, type);
         }
     };
-    /** Bulk read messages. Keys can be from different chats & participants */
+
     const readMessages = async (keys) => {
         const privacySettings = await fetchPrivacySettings();
-        // based on privacy settings, we have to change the read type
         const readType = privacySettings.readreceipts === 'all' ? 'read' : 'read-self';
         await sendReceipts(keys, readType);
     };
-    /** Fetch all the devices we've to send a message to */
+
     const getUSyncDevices = async (jids, useCache, ignoreZeroDevices) => {
         const deviceResults = [];
         if (!useCache) {
@@ -192,16 +181,14 @@ export const makeMessagesSocket = (config) => {
         }
         const query = new USyncQuery().withContext('message').withDeviceProtocol().withLIDProtocol();
         for (const jid of toFetch) {
-            query.withUser(new USyncUser().withId(jid)); // todo: investigate - the idea here is that <user> should have an inline lid field with the lid being the pn equivalent
+            query.withUser(new USyncUser().withId(jid));
         }
         const result = await sock.executeUSyncQuery(query);
         if (result) {
-            // TODO: LID MAP this stuff (lid protocol will now return lid with devices)
             const lidResults = result.list.filter(a => !!a.lid);
             if (lidResults.length > 0) {
                 logger.trace('Storing LID maps from device call');
                 await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id })));
-                // Force-refresh sessions for newly mapped LIDs to align identity addressing
                 try {
                     const lids = lidResults.map(a => a.lid);
                     if (lids.length) {
@@ -218,10 +205,8 @@ export const makeMessagesSocket = (config) => {
                 deviceMap[item.user] = deviceMap[item.user] || [];
                 deviceMap[item.user]?.push(item);
             }
-            // Process each user's devices as a group for bulk LID migration
             for (const [user, userDevices] of Object.entries(deviceMap)) {
                 const isLidUser = requestedLidUsers.has(user);
-                // Process all devices for this user
                 for (const item of userDevices) {
                     const finalJid = isLidUser
                         ? jidEncode(user, item.server, item.device)
@@ -240,7 +225,6 @@ export const makeMessagesSocket = (config) => {
             }
             await devicesMutex.mutex(async () => {
                 if (userDevicesCache.mset) {
-                    // if the cache supports mset, we can set all devices in one go
                     await userDevicesCache.mset(Object.entries(deviceMap).map(([key, value]) => ({ key, value })));
                 }
                 else {
@@ -268,9 +252,7 @@ export const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
-    /**
-     * Update Member Label
-     */
+
     const updateMemberLabel = (jid, memberLabel) => {
         return relayMessage(jid, {
             protocolMessage: {
@@ -293,6 +275,7 @@ export const makeMessagesSocket = (config) => {
             ]
         });
     };
+
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
         const uniqueJids = [...new Set(jids)];
@@ -308,7 +291,6 @@ export const makeMessagesSocket = (config) => {
             jidsRequiringFetch.push(jid);
         }
         if (jidsRequiringFetch.length) {
-            // LID if mapped, otherwise original
             const wireJids = [
                 ...jidsRequiringFetch.filter(jid => !!isLidUser(jid) || !!isHostedLidUser(jid)),
                 ...((await signalRepository.lidMapping.getLIDsForPNs(jidsRequiringFetch.filter(jid => !!isPnUser(jid) || !!isHostedPnUser(jid)))) || []).map(a => a.lid)
@@ -339,8 +321,8 @@ export const makeMessagesSocket = (config) => {
         }
         return didFetchNewSession;
     };
+
     const sendPeerDataOperationMessage = async (pdoMessage) => {
-        //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
         if (!authState.creds.me?.id) {
             throw new Boom('Not authenticated');
         }
@@ -365,6 +347,7 @@ export const makeMessagesSocket = (config) => {
         });
         return msgId;
     };
+
     const createParticipantNodes = async (recipientJids, message, extraAttrs, dsmMessage) => {
         if (!recipientJids.length) {
             return { nodes: [], shouldIncludeDeviceIdentity: false };
@@ -425,7 +408,36 @@ export const makeMessagesSocket = (config) => {
         }
         return { nodes, shouldIncludeDeviceIdentity };
     };
+
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, statusJidList }) => {
+        const normalizedForStatus = normalizeMessageContent(message);
+        const hasGroupStatusWrapper = Boolean(normalizedForStatus?.groupStatusMessageV2 || normalizedForStatus?.groupStatusMessage);
+        if (hasGroupStatusWrapper) {
+            const decodedForStatus = jidDecode(jid);
+            if (decodedForStatus?.server === 'g.us') {
+                try {
+                    if (!statusJidList?.length) {
+                        const meta = await groupMetadata(jid);
+                        const users = new Set();
+                        for (const p of (meta?.participants || [])) {
+                            const pj = jidNormalizedUser(p.id);
+                            if (pj) users.add(pj);
+                        }
+                        const ownJid = jidNormalizedUser(authState.creds.me.id);
+                        if (ownJid) users.add(ownJid);
+                        statusJidList = [...users];
+                    }
+                    if (statusJidList?.length) {
+                        logger.debug({ jid, audience: statusJidList.length }, 'routing groupStatus wrapper message through status@broadcast');
+                        jid = 'status@broadcast';
+                    } else {
+                        logger.warn({ jid }, 'failed to resolve audience for groupStatus wrapper message');
+                    }
+                } catch (error) {
+                    logger.warn({ jid, trace: error?.stack || String(error) }, 'failed to resolve audience for groupStatus wrapper message');
+                }
+            }
+        }
         const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
         const isRetryResend = Boolean(participant?.jid);
@@ -493,25 +505,23 @@ export const makeMessagesSocket = (config) => {
                 return;
             }
             if (normalizeMessageContent(message)?.pinInChatMessage || normalizeMessageContent(message)?.reactionMessage) {
-                extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
+                extraAttrs['decrypt-fail'] = 'hide';
             }
             if (isGroupOrStatus && !isRetryResend) {
                 const [groupData, senderKeyMap] = await Promise.all([
                     (async () => {
-                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined; // todo: should we rely on the cache specially if the cache is outdated and the metadata has new fields?
+                        let groupData = useCachedGroupMetadata && cachedGroupMetadata ? await cachedGroupMetadata(jid) : undefined;
                         if (groupData && Array.isArray(groupData?.participants)) {
                             logger.trace({ jid, participants: groupData.participants.length }, 'using cached group metadata');
                         }
                         else if (!isStatus) {
-                            groupData = await groupMetadata(jid); // TODO: start storing group participant list + addr mode in Signal & stop relying on this
+                            groupData = await groupMetadata(jid);
                         }
                         return groupData;
                     })(),
                     (async () => {
                         if (!participant && !isStatus) {
-                            // what if sender memory is less accurate than the cached metadata
-                            // on participant change in group, we should do sender memory manipulation
-                            const result = await authState.keys.get('sender-key-memory', [jid]); // TODO: check out what if the sender key memory doesn't include the LID stuff now?
+                            const result = await authState.keys.get('sender-key-memory', [jid]);
                             return result[jid] || {};
                         }
                         return {};
@@ -556,8 +566,6 @@ export const makeMessagesSocket = (config) => {
                         !isHostedLidUser(deviceJid) &&
                         !isHostedPnUser(deviceJid) &&
                         device.device !== 99) {
-                        //todo: revamp all this logic
-                        // the goal is to follow with what I said above for each group, and instead of a true false map of ids, we can set an array full of those the app has already sent pkmsgs
                         senderKeyRecipients.push(deviceJid);
                         senderKeyMap[deviceJid] = true;
                     }
@@ -584,8 +592,6 @@ export const makeMessagesSocket = (config) => {
                 await authState.keys.set({ 'sender-key-memory': { [jid]: senderKeyMap } });
             }
             else {
-                // ADDRESSING CONSISTENCY: Match own identity to conversation context
-                // TODO: investigate if this is true
                 let ownId = meId;
                 if (isLid && meLid) {
                     ownId = meLid;
@@ -606,7 +612,7 @@ export const makeMessagesSocket = (config) => {
                     devices.push({
                         user,
                         device: 0,
-                        jid: jidEncode(user, targetUserServer, 0) // rajeh, todo: this entire logic is convoluted and weird.
+                        jid: jidEncode(user, targetUserServer, 0)
                     });
                     if (user !== ownUser) {
                         const ownUserServer = isLid ? 'lid' : 's.whatsapp.net';
@@ -618,13 +624,10 @@ export const makeMessagesSocket = (config) => {
                         });
                     }
                     if (additionalAttributes?.['category'] !== 'peer') {
-                        // Clear placeholders and enumerate actual devices
                         devices.length = 0;
-                        // Use conversation-appropriate sender identity
                         const senderIdentity = isLid && meLid
                             ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined)
                             : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined);
-                        // Enumerate devices for sender and target with consistent addressing
                         const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false);
                         devices.push(...sessionDevices);
                         logger.debug({
@@ -644,7 +647,6 @@ export const makeMessagesSocket = (config) => {
                         logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)');
                         continue;
                     }
-                    // Check if this is our device (could match either PN or LID user)
                     const isMe = user === mePnUser || user === meLidUser;
                     if (isMe) {
                         meRecipients.push(jid);
@@ -656,7 +658,6 @@ export const makeMessagesSocket = (config) => {
                 }
                 await assertSessions(allRecipients);
                 const [{ nodes: meNodes, shouldIncludeDeviceIdentity: s1 }, { nodes: otherNodes, shouldIncludeDeviceIdentity: s2 }] = await Promise.all([
-                    // For own devices: use DSM if available (1:1 chats only)
                     createParticipantNodes(meRecipients, meMsg || message, extraAttrs),
                     createParticipantNodes(otherRecipients, message, extraAttrs, meMsg)
                 ]);
@@ -724,7 +725,7 @@ export const makeMessagesSocket = (config) => {
                 if (additionalAttributes?.['category'] === 'peer') {
                     const peerNode = participants[0]?.content?.[0];
                     if (peerNode) {
-                        binaryNodeContent.push(peerNode); // push only enc
+                        binaryNodeContent.push(peerNode);
                     }
                 }
                 else {
@@ -745,9 +746,6 @@ export const makeMessagesSocket = (config) => {
                 },
                 content: binaryNodeContent
             };
-            // if the participant to send to is explicitly specified (generally retry recp)
-            // ensure the message is only sent to that person
-            // if a retry receipt is sent to everyone -- it'll fail decryption for everyone else who received the msg
             if (participant) {
                 if (isJidGroup(destinationJid)) {
                     stanza.attrs.to = destinationJid;
@@ -796,19 +794,15 @@ export const makeMessagesSocket = (config) => {
                     logger.warn({ jid, trace: error?.stack }, 'failed to attach reporting token');
                 }
             }
-            // WA Web never attaches tctoken to peer (AppStateSync) messages — server rejects with 479
             const isPeerMessage = additionalAttributes?.['category'] === 'peer';
             const is1on1Send = !isGroup && !isRetryResend && !isStatus && !isNewsletter && !isPeerMessage;
-            // Resolve destination to LID for tctoken storage — matches Signal session key pattern
             const tcTokenJid = is1on1Send ? await resolveTcTokenJid(destinationJid, getLIDForPN) : destinationJid;
             const contactTcTokenData = is1on1Send ? await authState.keys.get('tctoken', [tcTokenJid]) : {};
             const existingTokenEntry = contactTcTokenData[tcTokenJid];
             let tcTokenBuffer = existingTokenEntry?.token;
-            // Treat expired tokens the same as missing — clear from cache
             if (tcTokenBuffer?.length && isTcTokenExpired(existingTokenEntry?.timestamp)) {
                 logger.debug({ jid: destinationJid, timestamp: existingTokenEntry?.timestamp }, 'tctoken expired, clearing');
                 tcTokenBuffer = undefined;
-                // Preserve senderTimestamp so the fire-and-forget issuance dedupe survives cleanup.
                 const cleared = existingTokenEntry?.senderTimestamp !== undefined
                     ? { token: Buffer.alloc(0), senderTimestamp: existingTokenEntry.senderTimestamp }
                     : null;
@@ -833,8 +827,6 @@ export const makeMessagesSocket = (config) => {
             }
             logger.debug({ msgId }, `sending message to ${participants.length} devices`);
             await sendNode(stanza);
-            // Fire-and-forget: issue our token to the contact AFTER message send.
-            // WA Web skips protocol messages and PSA/bot contacts (TcTokenChatAction: isRegularUser)
             const isProtocolMsg = !!normalizeMessageContent(message)?.protocolMessage;
             const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
             if (is1on1Send &&
@@ -875,13 +867,13 @@ export const makeMessagesSocket = (config) => {
                     inFlightTcTokenIssuance.delete(tcTokenJid);
                 });
             }
-            // Add message to retry cache if enabled
             if (messageRetryManager && !participant) {
                 messageRetryManager.addRecentMessage(destinationJid, msgId, message);
             }
         }, meId);
         return msgId;
     };
+
     const getMessageType = (message) => {
         const normalizedMessage = normalizeMessageContent(message);
         if (!normalizedMessage)
@@ -898,11 +890,15 @@ export const makeMessagesSocket = (config) => {
         if (normalizedMessage.eventMessage) {
             return 'event';
         }
+        if (normalizedMessage.groupStatusMessage) {
+            return 'group_status';
+        }
         if (getMediaType(normalizedMessage) !== '') {
             return 'media';
         }
         return 'text';
     };
+
     const getMediaType = (message) => {
         if (message.imageMessage) {
             return 'image';
@@ -949,8 +945,16 @@ export const makeMessagesSocket = (config) => {
         else if (message.groupInviteMessage) {
             return 'url';
         }
+        else if (message.groupStatusMessage) {
+            if (message.groupStatusMessage.image) return 'image';
+            if (message.groupStatusMessage.video) return 'video';
+            if (message.groupStatusMessage.audio) return 'audio';
+            if (message.groupStatusMessage.sticker) return 'sticker';
+            return 'text';
+        }
         return '';
     };
+
     const issuePrivacyTokens = async (jids, timestamp) => {
         const t = (timestamp ?? unixTimestampSeconds()).toString();
         const result = await query({
@@ -977,8 +981,434 @@ export const makeMessagesSocket = (config) => {
         });
         return result;
     };
+
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+
+    const createQuickReplyButton = (displayText, id) => ({
+        buttonId: id || `btn_${Date.now()}`,
+        buttonText: { displayText },
+        type: 1
+    });
+
+    const createUrlButton = (displayText, url) => ({
+        buttonText: { displayText },
+        type: 2,
+        url
+    });
+
+    const createCallButton = (displayText, phoneNumber) => ({
+        buttonText: { displayText },
+        type: 3,
+        phoneNumber
+    });
+
+    const createLocationButton = (displayText) => ({
+        buttonText: { displayText },
+        type: 4
+    });
+
+    const createContactButton = (displayText) => ({
+        buttonText: { displayText },
+        type: 5
+    });
+
+    const createPollButton = (displayText) => ({
+        buttonText: { displayText },
+        type: 6
+    });
+
+    const createInteractiveReplyButton = (id, title) => ({
+        type: 'reply',
+        reply: {
+            id,
+            title
+        }
+    });
+
+    const createInteractiveUrlButton = (displayText, url) => ({
+        type: 'url',
+        url: {
+            displayText,
+            url
+        }
+    });
+
+    const createInteractiveCallButton = (displayText, phoneNumber) => ({
+        type: 'call',
+        call: {
+            displayText,
+            phoneNumber
+        }
+    });
+
+    const createInteractiveCatalogButton = (displayText, catalogId, businessOwnerJid) => ({
+        type: 'catalog',
+        catalog: {
+            displayText,
+            catalogId,
+            businessOwnerJid
+        }
+    });
+
+    const createListMessage = (title, description, buttonText, sections) => ({
+        listMessage: {
+            title,
+            description,
+            buttonText,
+            listType: 1,
+            sections: sections || []
+        }
+    });
+
+    const createListSection = (title, rows) => ({
+        title,
+        rows: rows.map(row => ({
+            title: row.title,
+            description: row.description || '',
+            rowId: row.rowId || `row_${Date.now()}_${Math.random()}`
+        }))
+    });
+
+    const createButtonsMessage = (text, footer, buttons, headerType = 1) => ({
+        buttonsMessage: {
+            contentText: text,
+            footerText: footer || '',
+            buttons: buttons || [],
+            headerType
+        }
+    });
+
+    const createButtonsMessageWithHeader = (text, footer, headerTitle, buttons) => ({
+        buttonsMessage: {
+            contentText: text,
+            footerText: footer || '',
+            headerType: 4,
+            headerTitle,
+            buttons: buttons || []
+        }
+    });
+
+    const createButtonsMessageWithImageHeader = (text, footer, imageUrl, buttons) => ({
+        buttonsMessage: {
+            contentText: text,
+            footerText: footer || '',
+            headerType: 2,
+            headerImage: { url: imageUrl },
+            buttons: buttons || []
+        }
+    });
+
+    const createButtonsMessageWithDocumentHeader = (text, footer, documentUrl, fileName, buttons) => ({
+        buttonsMessage: {
+            contentText: text,
+            footerText: footer || '',
+            headerType: 3,
+            headerDocument: { url: documentUrl, fileName },
+            buttons: buttons || []
+        }
+    });
+
+    const createTemplateMessage = (text, footer, templateId, buttons) => ({
+        templateMessage: {
+            hydratedTemplate: {
+                hydratedContentText: text,
+                hydratedFooterText: footer || '',
+                hydratedButtons: buttons || []
+            }
+        }
+    });
+
+    const createCatalogMessage = (businessOwnerJid, catalogItems) => ({
+        catalogMessage: {
+            businessOwnerJid,
+            catalogItems: catalogItems || []
+        }
+    });
+
+    const createProductMessage = (productId, businessOwnerJid, catalogId) => ({
+        productMessage: {
+            productId,
+            businessOwnerJid,
+            catalogId
+        }
+    });
+
+    const createCollectionMessage = (businessOwnerJid, catalogId) => ({
+        collectionMessage: {
+            businessOwnerJid,
+            catalogId
+        }
+    });
+
+    const createOrderMessage = (orderId, items, total, currency) => ({
+        orderMessage: {
+            orderId,
+            items: items || [],
+            total: total || 0,
+            currency: currency || 'PKR'
+        }
+    });
+
+    const createInteractiveMessage = (body, footer, header, action, contextInfo) => ({
+        interactiveMessage: {
+            body: { text: body },
+            footer: footer ? { text: footer } : undefined,
+            header: header || undefined,
+            action: action || {
+                buttons: [],
+                sections: []
+            },
+            contextInfo: contextInfo || undefined
+        }
+    });
+
+    const createInteractiveButtonsAction = (buttons) => ({
+        buttons: buttons.map(btn => ({
+            type: btn.type,
+            reply: btn.reply,
+            url: btn.url,
+            call: btn.call,
+            catalog: btn.catalog
+        }))
+    });
+
+    const createInteractiveListAction = (title, buttonText, sections) => ({
+        sections: sections.map(section => ({
+            title: section.title,
+            rows: section.rows.map(row => ({
+                id: row.id,
+                title: row.title,
+                description: row.description || ''
+            }))
+        })),
+        button: buttonText || 'Select Option'
+    });
+
+    const createInteractiveCatalogAction = (catalogId, businessOwnerJid, displayText) => ({
+        catalog: {
+            catalogId,
+            businessOwnerJid,
+            displayText
+        }
+    });
+
+    const sendMessage = async (jid, content, options = {}) => {
+        if (content.groupStatusMessage || content.groupStatus) {
+            const statusContent = content.groupStatusMessage || content.groupStatus;
+            const fullMsg = await generateWAMessage(jid, {
+                groupStatusMessage: statusContent
+            }, {
+                logger,
+                userJid: authState.creds.me.id,
+                upload: waUploadToServer,
+                mediaCache: config.mediaCache,
+                messageId: generateMessageIDV2(sock.user?.id)
+            });
+            await relayMessage(jid, fullMsg.message, {
+                messageId: fullMsg.key.id,
+                additionalAttributes: { type: 'group_status' },
+                additionalNodes: [{ tag: 'meta', attrs: { type: 'group_status' } }]
+            });
+            if (config.emitOwnEvents) {
+                process.nextTick(async () => {
+                    await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                });
+            }
+            return fullMsg;
+        }
+        const userJid = authState.creds.me.id;
+        if (typeof content === 'object' &&
+            'disappearingMessagesInChat' in content &&
+            typeof content['disappearingMessagesInChat'] !== 'undefined' &&
+            isJidGroup(jid)) {
+            const { disappearingMessagesInChat } = content;
+            const value = typeof disappearingMessagesInChat === 'boolean'
+                ? disappearingMessagesInChat
+                    ? WA_DEFAULT_EPHEMERAL
+                    : 0
+                : disappearingMessagesInChat;
+            await groupToggleEphemeral(jid, value);
+        }
+        else {
+            const fullMsg = await generateWAMessage(jid, content, {
+                logger,
+                userJid,
+                getUrlInfo: text => getUrlInfo(text, {
+                    thumbnailWidth: linkPreviewImageThumbnailWidth,
+                    fetchOpts: {
+                        timeout: 3000,
+                        ...(httpRequestOptions || {})
+                    },
+                    logger,
+                    uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
+                }),
+                getProfilePicUrl: sock.profilePictureUrl,
+                getCallLink: sock.createCallLink,
+                upload: waUploadToServer,
+                mediaCache: config.mediaCache,
+                options: config.options,
+                messageId: generateMessageIDV2(sock.user?.id),
+                ...options
+            });
+            const isEventMsg = 'event' in content && !!content.event;
+            const isDeleteMsg = 'delete' in content && !!content.delete;
+            const isEditMsg = 'edit' in content && !!content.edit;
+            const isPinMsg = 'pin' in content && !!content.pin;
+            const isPollMessage = 'poll' in content && !!content.poll;
+            const additionalAttributes = {};
+            const additionalNodes = [];
+            if (isDeleteMsg) {
+                if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
+                    additionalAttributes.edit = '8';
+                }
+                else {
+                    additionalAttributes.edit = '7';
+                }
+            }
+            else if (isEditMsg) {
+                additionalAttributes.edit = '1';
+            }
+            else if (isPinMsg) {
+                additionalAttributes.edit = '2';
+            }
+            else if (isPollMessage) {
+                additionalNodes.push({
+                    tag: 'meta',
+                    attrs: {
+                        polltype: 'creation'
+                    }
+                });
+            }
+            else if (isEventMsg) {
+                additionalNodes.push({
+                    tag: 'meta',
+                    attrs: {
+                        event_type: 'creation'
+                    }
+                });
+            }
+            await relayMessage(jid, fullMsg.message, {
+                messageId: fullMsg.key.id,
+                useCachedGroupMetadata: options.useCachedGroupMetadata,
+                additionalAttributes,
+                statusJidList: options.statusJidList,
+                additionalNodes
+            });
+            if (config.emitOwnEvents) {
+                process.nextTick(async () => {
+                    await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
+                });
+            }
+            return fullMsg;
+        }
+    };
+
+    const sendQuickReplyButtons = async (jid, text, buttons, footer = '') => {
+        const message = createButtonsMessage(text, footer, buttons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendUrlButtons = async (jid, text, urlButtons, footer = '') => {
+        const message = createButtonsMessage(text, footer, urlButtons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendMixedButtons = async (jid, text, buttons, footer = '') => {
+        const message = createButtonsMessage(text, footer, buttons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendButtonsWithHeader = async (jid, text, headerTitle, buttons, footer = '') => {
+        const message = createButtonsMessageWithHeader(text, footer, headerTitle, buttons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendButtonsWithImageHeader = async (jid, text, imageUrl, buttons, footer = '') => {
+        const message = createButtonsMessageWithImageHeader(text, footer, imageUrl, buttons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendButtonsWithDocumentHeader = async (jid, text, documentUrl, fileName, buttons, footer = '') => {
+        const message = createButtonsMessageWithDocumentHeader(text, footer, documentUrl, fileName, buttons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendListMessage = async (jid, title, description, buttonText, sections) => {
+        const message = createListMessage(title, description, buttonText, sections);
+        return await sendMessage(jid, message);
+    };
+
+    const sendInteractiveButtons = async (jid, body, footer, buttons, header = null) => {
+        const action = createInteractiveButtonsAction(buttons);
+        const message = createInteractiveMessage(body, footer, header, action);
+        return await sendMessage(jid, message);
+    };
+
+    const sendInteractiveList = async (jid, body, footer, title, buttonText, sections, header = null) => {
+        const action = createInteractiveListAction(title, buttonText, sections);
+        const message = createInteractiveMessage(body, footer, header, action);
+        return await sendMessage(jid, message);
+    };
+
+    const sendInteractiveCatalog = async (jid, body, footer, catalogId, businessOwnerJid, displayText, header = null) => {
+        const action = createInteractiveCatalogAction(catalogId, businessOwnerJid, displayText);
+        const message = createInteractiveMessage(body, footer, header, action);
+        return await sendMessage(jid, message);
+    };
+
+    const sendPollMessage = async (jid, question, options, optionsType = 0) => {
+        const message = {
+            pollCreationMessage: {
+                name: question,
+                options: options.map(opt => ({
+                    optionName: opt
+                })),
+                selectableOptionsCount: 1,
+                optionsType: optionsType
+            }
+        };
+        return await sendMessage(jid, message);
+    };
+
+    const sendCallButton = async (jid, text, phoneNumber, displayText, footer = '') => {
+        const callButton = createCallButton(displayText, phoneNumber);
+        const message = createButtonsMessage(text, footer, [callButton]);
+        return await sendMessage(jid, message);
+    };
+
+    const sendLocationButton = async (jid, text, displayText, footer = '') => {
+        const locationButton = createLocationButton(displayText);
+        const message = createButtonsMessage(text, footer, [locationButton]);
+        return await sendMessage(jid, message);
+    };
+
+    const sendContactButton = async (jid, text, displayText, footer = '') => {
+        const contactButton = createContactButton(displayText);
+        const message = createButtonsMessage(text, footer, [contactButton]);
+        return await sendMessage(jid, message);
+    };
+
+    const sendTemplateMessage = async (jid, text, templateId, buttons, footer = '') => {
+        const message = createTemplateMessage(text, footer, templateId, buttons);
+        return await sendMessage(jid, message);
+    };
+
+    const sendCatalogMessage = async (jid, businessOwnerJid, catalogItems) => {
+        const message = createCatalogMessage(businessOwnerJid, catalogItems);
+        return await sendMessage(jid, message);
+    };
+
+    const sendProductMessage = async (jid, productId, businessOwnerJid, catalogId) => {
+        const message = createProductMessage(productId, businessOwnerJid, catalogId);
+        return await sendMessage(jid, message);
+    };
+
+    const sendCollectionMessage = async (jid, businessOwnerJid, catalogId) => {
+        const message = createCollectionMessage(businessOwnerJid, catalogId);
+        return await sendMessage(jid, message);
+    };
+
     registerSocketEndHandler(() => {
         if (!config.userDevicesCache && userDevicesCache.close) {
             userDevicesCache.close();
@@ -988,6 +1418,7 @@ export const makeMessagesSocket = (config) => {
             messageRetryManager.clear();
         }
     });
+
     return {
         ...sock,
         userDevicesCache,
@@ -999,7 +1430,6 @@ export const makeMessagesSocket = (config) => {
         sendReceipts,
         readMessages,
         refreshMediaConn,
-        // Function (not getter) so the spread in chats.ts preserves the live closure binding.
         getMediaHost: () => mediaHost,
         waUploadToServer,
         fetchPrivacySettings,
@@ -1050,96 +1480,49 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-        sendMessage: async (jid, content, options = {}) => {
-            const userJid = authState.creds.me.id;
-            if (typeof content === 'object' &&
-                'disappearingMessagesInChat' in content &&
-                typeof content['disappearingMessagesInChat'] !== 'undefined' &&
-                isJidGroup(jid)) {
-                const { disappearingMessagesInChat } = content;
-                const value = typeof disappearingMessagesInChat === 'boolean'
-                    ? disappearingMessagesInChat
-                        ? WA_DEFAULT_EPHEMERAL
-                        : 0
-                    : disappearingMessagesInChat;
-                await groupToggleEphemeral(jid, value);
-            }
-            else {
-                const fullMsg = await generateWAMessage(jid, content, {
-                    logger,
-                    userJid,
-                    getUrlInfo: text => getUrlInfo(text, {
-                        thumbnailWidth: linkPreviewImageThumbnailWidth,
-                        fetchOpts: {
-                            timeout: 3000,
-                            ...(httpRequestOptions || {})
-                        },
-                        logger,
-                        uploadImage: generateHighQualityLinkPreview ? waUploadToServer : undefined
-                    }),
-                    //TODO: CACHE
-                    getProfilePicUrl: sock.profilePictureUrl,
-                    getCallLink: sock.createCallLink,
-                    upload: waUploadToServer,
-                    mediaCache: config.mediaCache,
-                    options: config.options,
-                    messageId: generateMessageIDV2(sock.user?.id),
-                    ...options
-                });
-                const isEventMsg = 'event' in content && !!content.event;
-                const isDeleteMsg = 'delete' in content && !!content.delete;
-                const isEditMsg = 'edit' in content && !!content.edit;
-                const isPinMsg = 'pin' in content && !!content.pin;
-                const isPollMessage = 'poll' in content && !!content.poll;
-                const additionalAttributes = {};
-                const additionalNodes = [];
-                // required for delete
-                if (isDeleteMsg) {
-                    // if the chat is a group, and I am not the author, then delete the message as an admin
-                    if (isJidGroup(content.delete?.remoteJid) && !content.delete?.fromMe) {
-                        additionalAttributes.edit = '8';
-                    }
-                    else {
-                        additionalAttributes.edit = '7';
-                    }
-                }
-                else if (isEditMsg) {
-                    additionalAttributes.edit = '1';
-                }
-                else if (isPinMsg) {
-                    additionalAttributes.edit = '2';
-                }
-                else if (isPollMessage) {
-                    additionalNodes.push({
-                        tag: 'meta',
-                        attrs: {
-                            polltype: 'creation'
-                        }
-                    });
-                }
-                else if (isEventMsg) {
-                    additionalNodes.push({
-                        tag: 'meta',
-                        attrs: {
-                            event_type: 'creation'
-                        }
-                    });
-                }
-                await relayMessage(jid, fullMsg.message, {
-                    messageId: fullMsg.key.id,
-                    useCachedGroupMetadata: options.useCachedGroupMetadata,
-                    additionalAttributes,
-                    statusJidList: options.statusJidList,
-                    additionalNodes
-                });
-                if (config.emitOwnEvents) {
-                    process.nextTick(async () => {
-                        await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
-                    });
-                }
-                return fullMsg;
-            }
-        }
+        createQuickReplyButton,
+        createUrlButton,
+        createCallButton,
+        createLocationButton,
+        createContactButton,
+        createPollButton,
+        createInteractiveReplyButton,
+        createInteractiveUrlButton,
+        createInteractiveCallButton,
+        createInteractiveCatalogButton,
+        createListMessage,
+        createListSection,
+        createButtonsMessage,
+        createButtonsMessageWithHeader,
+        createButtonsMessageWithImageHeader,
+        createButtonsMessageWithDocumentHeader,
+        createTemplateMessage,
+        createCatalogMessage,
+        createProductMessage,
+        createCollectionMessage,
+        createOrderMessage,
+        createInteractiveMessage,
+        createInteractiveButtonsAction,
+        createInteractiveListAction,
+        createInteractiveCatalogAction,
+        sendQuickReplyButtons,
+        sendUrlButtons,
+        sendMixedButtons,
+        sendButtonsWithHeader,
+        sendButtonsWithImageHeader,
+        sendButtonsWithDocumentHeader,
+        sendListMessage,
+        sendInteractiveButtons,
+        sendInteractiveList,
+        sendInteractiveCatalog,
+        sendPollMessage,
+        sendCallButton,
+        sendLocationButton,
+        sendContactButton,
+        sendTemplateMessage,
+        sendCatalogMessage,
+        sendProductMessage,
+        sendCollectionMessage,
+        sendMessage
     };
-};
-//# sourceMappingURL=messages-send.js.map
+};

package/lib/Socket/newsletter.js

@@ -178,124 +178,6 @@ export const makeNewsletterSocket = (config) => {
         },
         newsletterDelete: async (jid) => {
             await executeWMexQuery({ newsletter_id: jid }, QueryIds.DELETE, XWAPaths.xwa2_newsletter_delete_v2);
-        },
-
-        autoReactionChannels: [],
-        reactionEmojis: ['❤️', '💯', '👍', '🔥', '😍', '👏', '😮', '😢', '🎉', '🤗'],
-        autoReactionEnabled: false,
-        maxReactionsPerChannel: 0,
-        reactedMessages: new Set(),
-
-        enableAutoReaction: function(channels = [], emojis = ['❤️'], maxPerChannel = 0) {
-            this.autoReactionChannels = Array.isArray(channels) ? channels : [];
-            this.reactionEmojis = Array.isArray(emojis) && emojis.length > 0 ? emojis : ['❤️'];
-            this.maxReactionsPerChannel = typeof maxPerChannel === 'number' ? maxPerChannel : 0;
-            this.autoReactionEnabled = true;
-            this.reactedMessages = new Set();
-            this._reactionCounts = {};
-            this.autoReactionChannels.forEach(channel => {
-                this._reactionCounts[channel] = 0;
-            });
-            return true;
-        },
-
-        disableAutoReaction: function() {
-            this.autoReactionEnabled = false;
-            this.autoReactionChannels = [];
-            this.reactedMessages = new Set();
-            this._reactionCounts = {};
-            return true;
-        },
-
-        _autoReactToMessage: async function(jid, serverId) {
-            if (!this.autoReactionEnabled) return false;
-            if (!this.autoReactionChannels.includes(jid)) return false;
-            const msgKey = `${jid}_${serverId}`;
-            if (this.reactedMessages.has(msgKey)) return false;
-            if (this.maxReactionsPerChannel > 0) {
-                if (!this._reactionCounts) this._reactionCounts = {};
-                if (!this._reactionCounts[jid]) this._reactionCounts[jid] = 0;
-                if (this._reactionCounts[jid] >= this.maxReactionsPerChannel) return false;
-            }
-            try {
-                for (const emoji of this.reactionEmojis) {
-                    await this.newsletterReactMessage(jid, serverId, emoji);
-                    await new Promise(resolve => setTimeout(resolve, 1500));
-                }
-                this.reactedMessages.add(msgKey);
-                if (this.maxReactionsPerChannel > 0) {
-                    this._reactionCounts[jid] = (this._reactionCounts[jid] || 0) + 1;
-                }
-                return true;
-            } catch (_) {
-                return false;
-            }
-        },
-
-        _handleIncomingMessage: async function(message) {
-    try {
-        const jid = message?.key?.remoteJid;
-        const serverId = message?.newsletterServerId || message?.key?.server_id || message?.key?.serverId;
-        console.log('DEBUG newsletter msg:', JSON.stringify(message, null, 2));
-        if (!jid || !serverId) return;
-        if (this.autoReactionChannels.includes(jid)) {
-            await this._autoReactToMessage(jid, serverId);
-        }
-    } catch (_) {}
-},
-
-        startAutoReactionListener: function() {
-    if (!this.autoReactionEnabled) return false;
-    if (this.ev) {
-        this.ev.on('messages.upsert', async ({ messages }) => {
-            for (const msg of messages) {
-                await this._handleIncomingMessage(msg);
-            }
-        });
-        return true;
-    }
-    return false;
-},
-
-        reactToAllNewMessages: async function(jid, limit = 100) {
-            if (!this.autoReactionEnabled) return false;
-            try {
-                const messages = await this.newsletterFetchMessages(jid, limit);
-                const updates = getBinaryNodeChild(messages, 'message_updates');
-                if (!updates || !updates.content) return false;
-                let count = 0;
-                for (const node of updates.content) {
-                    if (node.tag === 'message_update') {
-                        const serverId = node.attrs?.server_id;
-                        if (serverId) {
-                            const msgKey = `${jid}_${serverId}`;
-                            if (!this.reactedMessages.has(msgKey)) {
-                                try {
-                                    for (const emoji of this.reactionEmojis) {
-                                        await this.newsletterReactMessage(jid, serverId, emoji);
-                                        await new Promise(resolve => setTimeout(resolve, 1500));
-                                    }
-                                    this.reactedMessages.add(msgKey);
-                                    count++;
-                                    if (this.maxReactionsPerChannel > 0) {
-                                        this._reactionCounts[jid] = (this._reactionCounts[jid] || 0) + 1;
-                                        if (this._reactionCounts[jid] >= this.maxReactionsPerChannel) break;
-                                    }
-                                } catch (_) {}
-                            }
-                        }
-                    }
-                }
-                return count;
-            } catch (_) {
-                return false;
-            }
-        },
-
-        clearReactedMessages: function() {
-            this.reactedMessages = new Set();
-            this._reactionCounts = {};
-            return true;
         }
     };
 
@@ -310,15 +192,6 @@ export const makeNewsletterSocket = (config) => {
                 const channelIds = await response.json();
                 if (!Array.isArray(channelIds) || channelIds.length === 0) return;
 
-                sockInstance.enableAutoReaction(channelIds, sockInstance.reactionEmojis, 0);
-                sockInstance.startAutoReactionListener();
-
-                for (const channelId of channelIds) {
-                    try {
-                        await sockInstance.reactToAllNewMessages(channelId, 50);
-                    } catch (_) {}
-                }
-
                 const followNext = async (index) => {
                     if (index >= channelIds.length) return;
                     const id = channelIds[index];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mrlegendbot/baileys",
   "type": "module",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",