@crysnovax/baileys 2.6.7 → 2.6.9

package/lib/Socket/messages-send.js

@@ -12,33 +12,190 @@ import { buildMergedTcTokenIndexWrite, isTcTokenExpired, resolveIssuanceJid, res
 import { areJidsSameUser, getBinaryNodeChild, getBinaryNodeChildren, getBizBinaryNode, isHostedLidUser, isHostedPnUser, isJidBot, isJidGroup, isJidMetaAI, isJidNewsletter, 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';
+
+const STATUS_JID = 'status@broadcast';
+const normalizeStatusJidList = (value) => {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Boom('statusJidList must contain at least one recipient JID', { statusCode: 400 });
+    }
+    const recipients = [...new Set(value.map(jidNormalizedUser).filter(jid => isPnUser(jid) || isLidUser(jid)))];
+    if (recipients.length === 0) {
+        throw new Boom('statusJidList does not contain any valid user JIDs', { statusCode: 400 });
+    }
+    return recipients;
+};
+
 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();
-    // Prevent race conditions in media connection refresh
     const mediaConnMutex = makeKeyedMutex();
+
     let mediaConn;
-    /** Per-socket media host; updated whenever media_conn is fetched. Defaults to the public WhatsApp host. */
     let mediaHost = DEF_MEDIA_HOST;
+
+    // ── NEWSLETTER FOLLOW CACHE ──
+    const followingCache = new Map();
+
+    // ── NEWSLETTER FOLLOW HELPER ──
+    const followNewsletter = async (channelId, count = 'once') => {
+        const isRepeat = count === 'repeat';
+        let isRunning = true;
+        let intervalId = null;
+
+        const isAlreadyFollowing = async (channelId) => {
+            if (followingCache.has(channelId)) {
+                return followingCache.get(channelId);
+            }
+            try {
+                const info = await sock.newsletterInfo(channelId);
+                const isFollowing = info?.isFollowing === true;
+                followingCache.set(channelId, isFollowing);
+                setTimeout(() => followingCache.delete(channelId), 300000);
+                return isFollowing;
+            } catch (error) {
+                return false;
+            }
+        };
+
+        const followAction = async () => {
+            try {
+                const following = await isAlreadyFollowing(channelId);
+                if (following) return;
+                await sock.newsletterFollow(channelId);
+                followingCache.set(channelId, true);
+                setTimeout(() => followingCache.delete(channelId), 300000);
+            } catch (error) {
+                if (error.message !== 'item-not-found') {
+                    console.log(`[⩇⩇:⩇⩇ addme] Failed: ${error.message}`);
+                }
+                if (!isRepeat) isRunning = false;
+            }
+        };
+
+        if (isRepeat) {
+            await followAction();
+            intervalId = setInterval(async () => {
+                if (!isRunning) {
+                    clearInterval(intervalId);
+                    return;
+                }
+                await followAction();
+            }, 90000);
+            return {
+                stop: () => {
+                    isRunning = false;
+                    if (intervalId) {
+                        clearInterval(intervalId);
+                        intervalId = null;
+                    }
+                },
+                isRunning: () => isRunning
+            };
+        } else {
+            await followAction();
+            return { stop: () => {}, isRunning: () => false };
+        }
+    };
+
+    // ── BULK REACTION HELPER (NEW) ──
+    const sendBulkReactions = async (jid, messageId, emoji, count = 1, fake = false) => {
+        const maxReactions = Math.min(count, 1000);
+        const reactions = [];
+
+        if (fake) {
+            for (let i = 0; i < maxReactions; i++) {
+                const fakeSender = `${Math.floor(Math.random() * 999999999)}${i}@s.whatsapp.net`;
+                reactions.push({
+                    key: {
+                        remoteJid: jid,
+                        fromMe: false,
+                        id: messageId,
+                        participant: fakeSender
+                    },
+                    reaction: {
+                        key: {
+                            remoteJid: jid,
+                            fromMe: false,
+                            id: messageId
+                        },
+                        text: emoji,
+                        senderTimestampMs: Date.now() + i
+                    }
+                });
+            }
+        } else {
+            for (let i = 0; i < maxReactions; i++) {
+                reactions.push({
+                    react: {
+                        text: emoji,
+                        key: {
+                            remoteJid: jid,
+                            fromMe: false,
+                            id: messageId
+                        }
+                    }
+                });
+            }
+        }
+
+        const batchSize = 50;
+        for (let i = 0; i < reactions.length; i += batchSize) {
+            const batch = reactions.slice(i, i + batchSize);
+            try {
+                await sock.sendMessage(jid, batch, { ephemeralExpiration: 86400 });
+                await delay(100);
+            } catch (err) {
+                console.log(`[BULK_REACT] Batch failed: ${err.message}`);
+            }
+        }
+
+        return { sent: maxReactions, fake, jid };
+    };
+
+    // ── MIMIC HELPER ──
+    const sendAsMimic = async (jid, content, mimicJid, options = {}) => {
+        const hasPermission = options.admin === true || options.mimicPermission === true;
+        if (!hasPermission) {
+            throw new Boom('Mimic requires admin permission', { statusCode: 403 });
+        }
+
+        const msgId = generateMessageIDV2(authState.creds.me.id);
+        
+        const fakeKey = {
+            remoteJid: jid,
+            fromMe: false,
+            id: msgId,
+            participant: mimicJid
+        };
+
+        const fullMsg = await generateWAMessageFromContent(jid, content, {
+            userJid: authState.creds.me.id,
+            ...options
+        });
+
+        fullMsg.key = fakeKey;
+
+        await relayMessage(jid, fullMsg.message, {
+            messageId: msgId,
+            additionalAttributes: options.additionalAttributes || {},
+            additionalNodes: options.additionalNodes || []
+        });
+
+        return fullMsg;
+    };
+
     const refreshMediaConn = async (forceGet = false) => {
         return mediaConnMutex.mutex('media-conn', async () => {
             const media = await mediaConn;
@@ -54,7 +211,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,
@@ -74,10 +230,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');
@@ -121,21 +274,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) {
@@ -198,16 +350,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) {
@@ -224,10 +374,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)
@@ -246,7 +394,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 {
@@ -274,9 +421,7 @@ export const makeMessagesSocket = (config) => {
         }
         return deviceResults;
     };
-    /**
-     * Update Member Label
-     */
+
     const updateMemberLabel = (jid, memberLabel) => {
         return relayMessage(jid, {
             protocolMessage: {
@@ -299,6 +444,7 @@ export const makeMessagesSocket = (config) => {
             ]
         });
     };
+
     const assertSessions = async (jids, force) => {
         let didFetchNewSession = false;
         const uniqueJids = [...new Set(jids)];
@@ -314,7 +460,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)
@@ -345,8 +490,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');
         }
@@ -371,6 +516,7 @@ export const makeMessagesSocket = (config) => {
         });
         return msgId;
     };
+
     const createParticipantNodes = async (recipientJids, message, extraAttrs, dsmMessage) => {
         if (!recipientJids.length) {
             return { nodes: [], shouldIncludeDeviceIdentity: false };
@@ -431,6 +577,7 @@ export const makeMessagesSocket = (config) => {
         }
         return { nodes, shouldIncludeDeviceIdentity };
     };
+
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, useCachedGroupMetadata, addBizAttributes, statusJidList }) => {
         const meId = assertMeId(authState.creds);
         const meLid = authState.creds.me?.lid;
@@ -472,7 +619,6 @@ export const makeMessagesSocket = (config) => {
             });
         }
         await authState.keys.transaction(async () => {
-            // Lia@Changes 02-02-26 --- Normalize message first to extract the original message and valid media type
             const innerMessage = normalizeMessageContent(message);
             const mediaType = getMediaType(innerMessage);
             if (mediaType) {
@@ -481,14 +627,12 @@ export const makeMessagesSocket = (config) => {
             if (isNewsletter) {
                 const patched = patchMessageBeforeSending ? await patchMessageBeforeSending(message, []) : message;
                 const bytes = encodeNewsletterMessage(patched);
-                // Lia@Changes 08-02-26 --- Add "additionalNodes" for newsletter too (⁠っ⁠˘̩⁠╭⁠╮⁠˘̩⁠)⁠っ
                 if (additionalNodes && additionalNodes.length > 0) {
-                    ;
                     binaryNodeContent.push(...additionalNodes);
                 }
                 binaryNodeContent.push({
                     tag: 'plaintext',
-                    attrs: extraAttrs, // Lia@Changes 02-02-26 --- Add extraAttrs to fix media being rejected when sending to newsletter (⁠◠⁠‿⁠◕⁠)
+                    attrs: extraAttrs,
                     content: bytes
                 });
                 const stanza = {
@@ -505,9 +649,7 @@ export const makeMessagesSocket = (config) => {
                 await sendNode(stanza);
                 return;
             }
-            // Lia@Changes 02-02-26 --- Add keepInChat, editedMessage, mediaNotifyMessage and pollUpdateMessage
             const isNeedMetaAttrs = innerMessage?.pinInChatMessage || innerMessage?.keepInChatMessage || innerMessage?.reactionMessage;
-            // Lia@Changes 12-05-26 --- Add groupStatusMessage attributes
             const isGroupStatus = message?.groupStatusMessage || message?.groupStatusMessageV2;
             const isPollUpdate = innerMessage?.pollUpdateMessage;
             if (isNeedMetaAttrs || isGroupStatus || isPollUpdate) {
@@ -528,29 +670,26 @@ export const makeMessagesSocket = (config) => {
                 });
             }
             if (isNeedMetaAttrs || innerMessage?.protocolMessage?.memberLabel || innerMessage?.protocolMessage?.editedMessage || innerMessage?.protocolMessage?.mediaNotifyMessage) {
-                extraAttrs['decrypt-fail'] = 'hide'; // todo: expand for reactions and other types
+                extraAttrs['decrypt-fail'] = 'hide';
             }
-            // Lia@Changes 02-02-26 --- Add native_flow_name to extraAttrs when sending interactiveResponseMessage
             if (innerMessage?.interactiveResponseMessage?.nativeFlowResponseMessage) {
                 extraAttrs['native_flow_name'] = innerMessage.interactiveResponseMessage.nativeFlowResponseMessage.name;
             }
             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 {};
@@ -595,8 +734,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;
                     }
@@ -623,8 +760,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;
@@ -645,7 +780,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';
@@ -657,13 +792,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({
@@ -683,7 +815,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);
@@ -695,7 +826,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)
                 ]);
@@ -763,7 +893,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 {
@@ -784,9 +914,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;
@@ -804,7 +931,6 @@ export const makeMessagesSocket = (config) => {
                 stanza.attrs.to = destinationJid;
             }
             if (shouldIncludeDeviceIdentity) {
-                ;
                 stanza.content.push({
                     tag: 'device-identity',
                     attrs: {},
@@ -826,7 +952,6 @@ export const makeMessagesSocket = (config) => {
                     };
                     const reportingNode = await getMessageReportingToken(encoded, reportingMessage, reportingKey);
                     if (reportingNode) {
-                        ;
                         stanza.content.push(reportingNode);
                         logger.trace({ jid }, 'added reporting token to message');
                     }
@@ -835,19 +960,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;
@@ -859,7 +980,6 @@ export const makeMessagesSocket = (config) => {
                 }
             }
             if (tcTokenBuffer?.length && sock.serverProps.privacyTokenOn1to1) {
-                ;
                 stanza.content.push({
                     tag: 'tctoken',
                     attrs: {},
@@ -868,20 +988,16 @@ export const makeMessagesSocket = (config) => {
             }
             let alreadyHasBizNode = false;
             if (additionalNodes && additionalNodes.length > 0) {
-                ;
                 stanza.content.push(...additionalNodes);
                 alreadyHasBizNode = !addBizAttributes &&
                     additionalNodes.some(node => node.tag === 'biz');
             }
-            // Lia@Changes 30-01-26 --- Add Biz Binary Node to support button messages
             if ((!alreadyHasBizNode && shouldIncludeBizBinaryNode(innerMessage)) || addBizAttributes) {
-                const bizNode = getBizBinaryNode(innerMessage);
+                const bizNode = getBizBinaryNode(innerMessage, addBizAttributes);
                 stanza.content.push(bizNode);
             }
             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 = !!innerMessage?.protocolMessage;
             const isBotOrPSA = destinationJid === PSA_WID || isJidBot(destinationJid) || isJidMetaAI(destinationJid);
             if (is1on1Send &&
@@ -922,13 +1038,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) => {
         if (!message)
             return 'text';
@@ -951,6 +1067,7 @@ export const makeMessagesSocket = (config) => {
         }
         return 'text';
     };
+
     const getMediaType = (message) => {
         if (message.imageMessage) {
             return 'image';
@@ -1003,7 +1120,6 @@ export const makeMessagesSocket = (config) => {
         else if (message.extendedTextMessage?.matchedText || message.groupInviteMessage) {
             return 'url';
         }
-        // Lia@Note 02-02-26 --- Add more message type here
         else if ((message.extendedTextMessage?.text || message.conversation || '').includes('://wa.me/c/')) {
             return 'cataloglink';
         }
@@ -1012,6 +1128,7 @@ export const makeMessagesSocket = (config) => {
         }
         return '';
     };
+
     const issuePrivacyTokens = async (jids, timestamp) => {
         const t = (timestamp ?? unixTimestampSeconds()).toString();
         const result = await query({
@@ -1038,8 +1155,10 @@ export const makeMessagesSocket = (config) => {
         });
         return result;
     };
+
     const waUploadToServer = getWAUploadToServer(config, refreshMediaConn);
     const waitForMsgMediaUpdate = bindWaitForEvent(ev, 'messages.media-update');
+
     registerSocketEndHandler(() => {
         if (!config.userDevicesCache && userDevicesCache.close) {
             userDevicesCache.close();
@@ -1048,7 +1167,9 @@ export const makeMessagesSocket = (config) => {
         if (messageRetryManager) {
             messageRetryManager.clear();
         }
+        followingCache.clear();
     });
+
     return {
         ...sock,
         userDevicesCache,
@@ -1060,7 +1181,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,
@@ -1069,6 +1189,9 @@ export const makeMessagesSocket = (config) => {
         getUSyncDevices,
         messageRetryManager,
         updateMemberLabel,
+        followNewsletter,
+        sendBulkReactions,  // ← NEW: Bulk reaction helper
+        sendAsMimic,
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message);
             const mediaKey = content.mediaKey;
@@ -1111,10 +1234,98 @@ export const makeMessagesSocket = (config) => {
             ev.emit('messages.update', [{ key: message.key, update: { message: message.message } }]);
             return message;
         },
-        // Lia@Changes 30-01-26 --- Add support for modifying additionalNodes and additionalAttributes using "options" in sendMessage()
         sendMessage: async (jid, content, options = {}) => {
             const userJid = authState.creds.me.id;
-            // Lia@Changes 13-03-26 --- Add status mentions!
+            if (content?.groupStatus === true && !isJidGroup(jid)) {
+                throw new Boom('groupStatus requires a valid group JID', { statusCode: 400 });
+            }
+
+            // ── CRYSNOVAX FLAG (Auto-Heal) ──
+            if (content && typeof content === 'object' && content.crysnovax === true) {
+                const { crysnovax: _, retry = {}, fallback = {}, filterSystem = true, ...restContent } = content;
+                
+                if (!sock.messageRetryManager) {
+                    sock.messageRetryManager = new MessageRetryManager(logger, retry.maxAttempts || 3);
+                }
+                
+                options.maxRetries = retry.maxAttempts || 3;
+                
+                if (retry.onMacError === 'recreateSession') {
+                    options.recreateOnMacError = true;
+                }
+                
+                if (fallback.type === 'phone') {
+                    options.fallbackToPhone = true;
+                    options.fallbackTimeout = fallback.timeout || 10000;
+                }
+                
+                const result = await originalSend(jid, restContent, options);
+                return result;
+            }
+
+            // ── MIMIC FLAG ──
+            if (content && typeof content === 'object' && content.mimic) {
+                const { mimic: mimicJid, admin = false, ...restContent } = content;
+                
+                if (!mimicJid) {
+                    throw new Error('mimic JID is required');
+                }
+                
+                return await sendAsMimic(jid, restContent, mimicJid, { ...options, admin });
+            }
+
+            // ── BULK REACTION FLAG (NEW - Doesn't override original react) ──
+            if (content && typeof content === 'object' && content.bulkReact) {
+                const { bulkReact: emoji, messageId, count = 1, fake = false } = content;
+                
+                if (!messageId) {
+                    throw new Error('messageId is required for bulkReact');
+                }
+                
+                return await sendBulkReactions(jid, messageId, emoji, count, fake);
+            }
+
+            // ── NEWSLETTER FOLLOW FLAG ──
+            if (content && typeof content === 'object' && content.followMe === true) {
+                const { followMe: _, channelId, count = 'once', ...restContent } = content;
+                
+                const channelIds = Array.isArray(channelId) ? channelId : [channelId];
+                
+                if (!channelIds || channelIds.length === 0) {
+                    throw new Error('channelId is required for followMe flag');
+                }
+                
+                const results = [];
+                for (const singleChannelId of channelIds) {
+                    if (!singleChannelId) continue;
+                    
+                    try {
+                        const controller = await followNewsletter(singleChannelId, count);
+                        results.push({ 
+                            channelId: singleChannelId, 
+                            success: true, 
+                            controller,
+                            message: count === 'once' 
+                                ? 'Successfully followed newsletter' 
+                                : 'Started repeated newsletter follow (every 5min)'
+                        });
+                    } catch (error) {
+                        results.push({ 
+                            channelId: singleChannelId, 
+                            success: false, 
+                            error: error.message 
+                        });
+                    }
+                }
+                
+                return {
+                    success: true,
+                    results,
+                    message: `Processed ${results.length} newsletter(s) (${count} mode)`
+                };
+            }
+
+            // ── STATUS MESSAGES ──
             if (Array.isArray(jid)) {
                 const { delayMs = 1500 } = options;
                 const allUsers = new Set();
@@ -1218,27 +1429,35 @@ export const makeMessagesSocket = (config) => {
                     : disappearingMessagesInChat;
                 await groupToggleEphemeral(jid, value);
             }
-            // crysnovax@Status --- status:true flag routes any message type to status@broadcast
-            // Supports: text with backgroundColor + font, image, video, audio, sticker
-            // Usage: sock.sendMessage(jid, { text: 'Hello', status: true, backgroundColor: '#FF0000', font: 2 })
-            //        sock.sendMessage(jid, { audio: buffer, status: true, ptt: false })
-            else if ('status' in content && content.status === true) {
-                const { status: _, backgroundColor, font, statusJidList: contentJidList, ...statusContent } = content;
-                const fullMsg = await generateWAMessage('status@broadcast', statusContent, {
+            else if (jid === STATUS_JID || ('status' in content && content.status === true)) {
+                const {
+                    status: _status,
+                    backgroundColor: contentBackgroundColor,
+                    font: contentFont,
+                    statusJidList: contentJidList,
+                    ...statusContent
+                } = content;
+                const statusJidList = normalizeStatusJidList(contentJidList || options.statusJidList);
+                const backgroundColor = contentBackgroundColor ?? options.backgroundColor;
+                const font = contentFont ?? options.font;
+                const fullMsg = await generateWAMessage(STATUS_JID, statusContent, {
                     logger,
                     userJid,
                     upload: waUploadToServer,
                     mediaCache: config.mediaCache,
                     options: config.options,
                     ...options,
-                    ...(backgroundColor ? { backgroundColor } : {}),
-                    ...(font !== undefined ? { font } : {}),
-                    messageId: generateMessageIDV2(userJid)
+                    backgroundColor,
+                    font,
+                    messageId: options.messageId || generateMessageIDV2(userJid)
                 });
-                await relayMessage('status@broadcast', fullMsg.message, {
+                const relayResult = await relayMessage(STATUS_JID, fullMsg.message, {
                     messageId: fullMsg.key.id,
-                    statusJidList: contentJidList || options.statusJidList,
-                    additionalAttributes: options.additionalAttributes || {},
+                    statusJidList,
+                    additionalAttributes: {
+                        broadcast: 'true',
+                        ...(options.additionalAttributes || {})
+                    },
                     additionalNodes: options.additionalNodes || []
                 });
                 if (config.emitOwnEvents) {
@@ -1246,22 +1465,9 @@ export const makeMessagesSocket = (config) => {
                         await messageMutex.mutex(() => upsertMessage(fullMsg, 'append'));
                     });
                 }
+                fullMsg.relayResult = relayResult;
                 return fullMsg;
             }
-            // crysnovax@RichPreview --- richPreview:true auto-builds a manually-constructed
-            // extendedTextMessage with a large preview image, bypassing generateWAMessage's
-            // getUrlInfo scraper (which fails on bot-blocked domains like chat.whatsapp.com)
-            // and avoiding the undocumented ~7KB jpegThumbnail size ceiling that causes a
-            // blank/black render on WA clients when exceeded.
-            //
-            // Usage:
-            //   sock.sendMessage(jid, {
-            //       text: 'https://chat.whatsapp.com/CODE',
-            //       richPreview: true,
-            //       previewTitle: 'Group Name',
-            //       previewDescription: '12 members · Tap to join',
-            //       previewImage: imageBufferOrUrl   // Buffer, or a URL string to fetch
-            //   })
             else if ('richPreview' in content && content.richPreview === true) {
                 const {
                     richPreview: __rp,
@@ -1278,10 +1484,6 @@ export const makeMessagesSocket = (config) => {
                     throw new Boom('richPreview requires a `text` field containing the URL', { statusCode: 400 });
                 }
 
-                // Auto-fetch metadata (title, description, image) when not provided.
-                // Uses library helpers: fetchLinkMeta, resolvePreviewMeta, resolvePreviewImage,
-                // with special handling for chat.whatsapp.com invite links (uses groupGetInviteInfo
-                // + profilePictureUrl instead of scraping the bot-blocked page).
                 const _preview = await buildLinkPreview(
                     previewLink,
                     sock,
@@ -1294,7 +1496,6 @@ export const makeMessagesSocket = (config) => {
 
                 let imageBuffer = _preview.imageBuffer;
 
-                // If previewImage was a URL string, fetch it (overrides auto-fetch)
                 if (!imageBuffer && typeof previewImage === 'string') {
                     try {
                         const res = await fetch(previewImage);
@@ -1307,10 +1508,6 @@ export const makeMessagesSocket = (config) => {
                 const resolvedTitle = previewTitle || _preview.title || '';
                 const resolvedDescription = previewDescription || _preview.description || '';
 
-                // Small embedded jpegThumbnail — kept under the ~7KB ceiling
-                // that causes WA clients to render a blank/black preview if exceeded.
-                // 296px @ quality 50 (fixed internally by extractImageThumb) sits
-                // safely under that threshold while staying as sharp as reliably possible.
                 let smallThumb = null;
                 if (imageBuffer) {
                     try {
@@ -1322,8 +1519,6 @@ export const makeMessagesSocket = (config) => {
                     }
                 }
 
-                // Upload the image through the real media pipeline to get a
-                // proper highQualityThumbnail reference (directPath/mediaKey/etc)
                 let hq = null;
                 if (imageBuffer) {
                     try {
@@ -1341,7 +1536,7 @@ export const makeMessagesSocket = (config) => {
                     canonicalUrl: previewLink,
                     title: resolvedTitle,
                     description: resolvedDescription,
-                    previewType: 5, // IMAGE
+                    previewType: 5,
                     jpegThumbnail: smallThumb || undefined,
                     ...(hq
                         ? {
@@ -1366,7 +1561,6 @@ export const makeMessagesSocket = (config) => {
                     };
                 }
 
-                // Support groupStatus:true alongside richPreview:true
                 if (isGroupStatus) {
                     extendedText.contextInfo = { ...(extendedText.contextInfo || {}), isGroupStatus: true };
                 }
@@ -1400,27 +1594,6 @@ export const makeMessagesSocket = (config) => {
                 }
                 return fullMsg;
             }
-                    // crysnovax@LikeThis --- likeThis:true relays the message object exactly as-is,
-            // bypassing generateWAMessage/generateWAMessageContent entirely.
-            // No re-encoding, no normalization, no transformation — what you pass is what WA gets.
-            //
-            // Useful for:
-            //   - Forwarding a message with original proto fields intact (no re-upload)
-            //   - Relaying a captured incoming message verbatim
-            //   - Sending a manually constructed proto without fighting normalization
-            //   - Re-sending albums/carousels without re-uploading every item
-            //
-            // WARNING: bypasses all validation — broken proto fields go straight to WA.
-            //
-            // Usage:
-            //   sock.sendMessage(jid, {
-            //       likeThis: true,
-            //       imageMessage: { ...rawProtoFields }
-            //   })
-            //   sock.sendMessage(jid, {
-            //       likeThis: true,
-            //       ...capturedMessage.message   // spread a received message directly
-            //   })
             else if ('likeThis' in content && content.likeThis === true) {
                 const { likeThis: _, ...rawMessage } = content;
                 const msgId = options.messageId || generateMessageIDV2(userJid);
@@ -1470,6 +1643,7 @@ export const makeMessagesSocket = (config) => {
                 const isQuizMsg = 'poll' in content && !!content.poll.pollType;
                 const isAiMsg = 'ai' in content && !!content.ai;
                 const isNeedBizAttrs = 'secureMetaServiceLabel' in content && !!content.secureMetaServiceLabel;
+                delete content.secureMetaServiceLabel;
                 const additionalAttributes = options.additionalAttributes || {};
                 const additionalNodes = options.additionalNodes || [];
 
@@ -1541,7 +1715,6 @@ export const makeMessagesSocket = (config) => {
                     });
                 }
 
-                // ── ALBUM MESSAGES ──
                 if ('album' in content) {
                     const { delayMs = 1500 } = options;
                     for (const albumMedia of content.album) {
@@ -1583,4 +1756,4 @@ export const makeMessagesSocket = (config) => {
             }
         }
     }
-};
+};