@periskope/baileys 6.8.0-alpha.1 → 7.0.0-alpha-2

package/lib/Socket/messages-recv.js

@@ -7,7 +7,7 @@ import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaul
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
 import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
-import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
+import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
 export const makeMessagesRecvSocket = (config) => {
@@ -32,187 +32,6 @@ export const makeMessagesRecvSocket = (config) => {
             useClones: false
         });
     let sendActiveReceipts = false;
-    const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
-        if (!authState.creds.me?.id) {
-            throw new Boom('Not authenticated');
-        }
-        const pdoMessage = {
-            historySyncOnDemandRequest: {
-                chatJid: oldestMsgKey.remoteJid,
-                oldestMsgFromMe: oldestMsgKey.fromMe,
-                oldestMsgId: oldestMsgKey.id,
-                oldestMsgTimestampMs: oldestMsgTimestamp,
-                onDemandMsgCount: count
-            },
-            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
-        };
-        return sendPeerDataOperationMessage(pdoMessage);
-    };
-    const requestPlaceholderResend = async (messageKey) => {
-        if (!authState.creds.me?.id) {
-            throw new Boom('Not authenticated');
-        }
-        if (placeholderResendCache.get(messageKey?.id)) {
-            logger.debug({ messageKey }, 'already requested resend');
-            return;
-        }
-        else {
-            placeholderResendCache.set(messageKey?.id, true);
-        }
-        await delay(5000);
-        if (!placeholderResendCache.get(messageKey?.id)) {
-            logger.debug({ messageKey }, 'message received while resend requested');
-            return 'RESOLVED';
-        }
-        const pdoMessage = {
-            placeholderMessageResendRequest: [
-                {
-                    messageKey
-                }
-            ],
-            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
-        };
-        setTimeout(() => {
-            if (placeholderResendCache.get(messageKey?.id)) {
-                logger.debug({ messageKey }, 'PDO message without response after 15 seconds. Phone possibly offline');
-                placeholderResendCache.del(messageKey?.id);
-            }
-        }, 15000);
-        return sendPeerDataOperationMessage(pdoMessage);
-    };
-    // Handles mex newsletter notifications
-    const handleMexNewsletterNotification = async (node) => {
-        const mexNode = getBinaryNodeChild(node, 'mex');
-        if (!mexNode?.content) {
-            logger.warn({ node }, 'Invalid mex newsletter notification');
-            return;
-        }
-        let data;
-        try {
-            data = JSON.parse(mexNode.content.toString());
-        }
-        catch (error) {
-            logger.error({ err: error, node }, 'Failed to parse mex newsletter notification');
-            return;
-        }
-        const operation = data?.operation;
-        const updates = data?.updates;
-        if (!updates || !operation) {
-            logger.warn({ data }, 'Invalid mex newsletter notification content');
-            return;
-        }
-        logger.info({ operation, updates }, 'got mex newsletter notification');
-        switch (operation) {
-            case 'NotificationNewsletterUpdate':
-                for (const update of updates) {
-                    if (update.jid && update.settings && Object.keys(update.settings).length > 0) {
-                        ev.emit('newsletter-settings.update', {
-                            id: update.jid,
-                            update: update.settings
-                        });
-                    }
-                }
-                break;
-            case 'NotificationNewsletterAdminPromote':
-                for (const update of updates) {
-                    if (update.jid && update.user) {
-                        ev.emit('newsletter-participants.update', {
-                            id: update.jid,
-                            author: node.attrs.from,
-                            user: update.user,
-                            new_role: 'ADMIN',
-                            action: 'promote'
-                        });
-                    }
-                }
-                break;
-            default:
-                logger.info({ operation, data }, 'Unhandled mex newsletter notification');
-                break;
-        }
-    };
-    // Handles newsletter notifications
-    const handleNewsletterNotification = async (node) => {
-        const from = node.attrs.from;
-        const child = getAllBinaryNodeChildren(node)[0];
-        const author = node.attrs.participant;
-        logger.info({ from, child }, 'got newsletter notification');
-        switch (child.tag) {
-            case 'reaction':
-                const reactionUpdate = {
-                    id: from,
-                    server_id: child.attrs.message_id,
-                    reaction: {
-                        code: getBinaryNodeChildString(child, 'reaction'),
-                        count: 1
-                    }
-                };
-                ev.emit('newsletter.reaction', reactionUpdate);
-                break;
-            case 'view':
-                const viewUpdate = {
-                    id: from,
-                    server_id: child.attrs.message_id,
-                    count: parseInt(child.content?.toString() || '0', 10)
-                };
-                ev.emit('newsletter.view', viewUpdate);
-                break;
-            case 'participant':
-                const participantUpdate = {
-                    id: from,
-                    author,
-                    user: child.attrs.jid,
-                    action: child.attrs.action,
-                    new_role: child.attrs.role
-                };
-                ev.emit('newsletter-participants.update', participantUpdate);
-                break;
-            case 'update':
-                const settingsNode = getBinaryNodeChild(child, 'settings');
-                if (settingsNode) {
-                    const update = {};
-                    const nameNode = getBinaryNodeChild(settingsNode, 'name');
-                    if (nameNode?.content)
-                        update.name = nameNode.content.toString();
-                    const descriptionNode = getBinaryNodeChild(settingsNode, 'description');
-                    if (descriptionNode?.content)
-                        update.description = descriptionNode.content.toString();
-                    ev.emit('newsletter-settings.update', {
-                        id: from,
-                        update
-                    });
-                }
-                break;
-            case 'message':
-                const plaintextNode = getBinaryNodeChild(child, 'plaintext');
-                if (plaintextNode?.content) {
-                    try {
-                        const contentBuf = typeof plaintextNode.content === 'string'
-                            ? Buffer.from(plaintextNode.content, 'binary')
-                            : Buffer.from(plaintextNode.content);
-                        const messageProto = proto.Message.decode(contentBuf);
-                        const fullMessage = proto.WebMessageInfo.create({
-                            key: {
-                                remoteJid: from,
-                                id: child.attrs.message_id || child.attrs.server_id,
-                                fromMe: false
-                            },
-                            message: messageProto,
-                            messageTimestamp: +child.attrs.t
-                        });
-                        await upsertMessage(fullMessage, 'append');
-                        logger.info('Processed plaintext newsletter message');
-                    }
-                    catch (error) {
-                        logger.error({ error }, 'Failed to decode plaintext newsletter message');
-                    }
-                }
-                break;
-            default:
-                logger.warn({ node }, 'Unknown newsletter notification');
-                break;
-        }
-    };
     const sendMessageAck = async ({ tag, attrs, content }, errorCode) => {
         const stanza = {
             tag: 'ack',
@@ -410,8 +229,8 @@ export const makeMessagesRecvSocket = (config) => {
                 ev.emit('creds.update', update);
             }
             await sendNode(receipt);
-            logger.info({ msgAttrs: node.attrs, retryCount }, 'sent retry receipt');
-        }, authState?.creds?.me?.id || 'sendRetryRequest');
+            logger.info({ msgAttrs: node.attrs, retryCount, shouldRecreateSession, recreateReason }, 'sent retry receipt');
+        });
     };
     const handleEncryptNotification = async (node) => {
         const from = node.attrs.from;
@@ -835,7 +654,7 @@ export const makeMessagesRecvSocket = (config) => {
                     if (typeof status !== 'undefined' &&
                         // basically, we only want to know when a message from us has been delivered to/read by the other person
                         // or another device of ours has read some messages
-                        (status >= proto.WebMessageInfo.Status.SERVER_ACK)) {
+                        status >= proto.WebMessageInfo.Status.SERVER_ACK) {
                         if (isJidGroup(remoteJid) || isJidStatusBroadcast(remoteJid)) {
                             const updateKey = status === proto.WebMessageInfo.Status.DELIVERY_ACK ? 'receiptTimestamp' : 'readTimestamp';
                             if (attrs.participant) {
@@ -946,7 +765,7 @@ export const makeMessagesRecvSocket = (config) => {
         // TODO: temporary fix for crashes and issues resulting of failed msmsg decryption
         if (encNode && encNode.attrs.type === 'msmsg') {
             logger.debug({ key: node.attrs.key }, 'ignored msmsg');
-            await sendMessageAck(node);
+            await sendMessageAck(node, NACK_REASONS.MissingMessageSecret);
             return;
         }
         let response;
@@ -989,105 +808,183 @@ export const makeMessagesRecvSocket = (config) => {
                     await lidMapping.storeLIDPNMapping(msg.key.participant || msg.key.remoteJid, alt);
                 }
             }
-            if (msg.key?.remoteJid && msg.key?.id && messageRetryManager) {
-                messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
+        }
+        if (msg.key?.remoteJid && msg.key?.id && messageRetryManager) {
+            messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
+            logger.debug({
+                jid: msg.key.remoteJid,
+                id: msg.key.id
+            }, 'Added message to recent cache for retry receipts');
+        }
+        if (msg.message?.protocolMessage?.lidMigrationMappingSyncMessage?.encodedMappingPayload) {
+            try {
+                const payload = msg.message.protocolMessage.lidMigrationMappingSyncMessage.encodedMappingPayload;
+                const decoded = proto.LIDMigrationMappingSyncPayload.decode(payload);
                 logger.debug({
-                    jid: msg.key.remoteJid,
-                    id: msg.key.id
-                }, 'Added message to recent cache for retry receipts');
+                    mappingCount: decoded.pnToLidMappings?.length || 0,
+                    timestamp: decoded.chatDbMigrationTimestamp
+                }, 'Received LID migration sync message from server');
+                const lidMapping = signalRepository.getLIDMappingStore();
+                if (decoded.pnToLidMappings && decoded.pnToLidMappings.length > 0) {
+                    for (const mapping of decoded.pnToLidMappings) {
+                        const pn = `${mapping.pn}@s.whatsapp.net`;
+                        // Use latestLid if available, otherwise assignedLid (proper LID refresh)
+                        const lidValue = mapping.latestLid || mapping.assignedLid;
+                        const lid = `${lidValue}@lid`;
+                        await lidMapping.storeLIDPNMapping(lid, pn);
+                        logger.debug({
+                            pn,
+                            lid,
+                            assignedLid: mapping.assignedLid,
+                            latestLid: mapping.latestLid,
+                            usedLatest: !!mapping.latestLid
+                        }, 'Stored server-provided PN-LID mapping');
+                    }
+                }
             }
-            try {
-                await Promise.all([
-                    processingMutex.mutex(async () => {
-                        await decrypt();
-                        // message failed to decrypt
-                        if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT) {
-                            if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
-                                return sendMessageAck(node, NACK_REASONS.ParsingError);
-                            }
-                            const errorMessage = msg?.messageStubParameters?.[0] || '';
-                            const isPreKeyError = errorMessage.includes('PreKey');
-                            console.debug(`[handleMessage] Attempting retry request for failed decryption`);
-                            // Handle both pre-key and normal retries in single mutex
-                            retryMutex.mutex(async () => {
-                                try {
-                                    if (!ws.isOpen) {
-                                        logger.debug({ node }, 'Connection closed, skipping retry');
-                                        return;
-                                    }
-                                    if (getBinaryNodeChild(node, 'unavailable')) {
-                                        logger.debug('Message unavailable, skipping retry');
-                                        return;
-                                    }
-                                    // Handle pre-key errors with upload and delay
-                                    if (isPreKeyError) {
-                                        logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying');
-                                        try {
-                                            logger.debug('Uploading pre-keys for error recovery');
-                                            await uploadPreKeys(5);
-                                            logger.debug('Waiting for server to process new pre-keys');
-                                            await delay(1000);
-                                        }
-                                        catch (uploadErr) {
-                                            logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
-                                        }
-                                    }
-                                    const encNode = getBinaryNodeChild(node, 'enc');
-                                    await sendRetryRequest(node, !encNode);
-                                    if (retryRequestDelayMs) {
-                                        await delay(retryRequestDelayMs);
-                                    }
+            catch (error) {
+                logger.error({ error }, 'Failed to process LID migration sync message');
+            }
+        }
+        try {
+            await Promise.all([
+                processingMutex.mutex(async () => {
+                    await decrypt();
+                    // message failed to decrypt
+                    if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT) {
+                        if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
+                            return sendMessageAck(node, NACK_REASONS.ParsingError);
+                        }
+                        const errorMessage = msg?.messageStubParameters?.[0] || '';
+                        const isPreKeyError = errorMessage.includes('PreKey');
+                        console.debug(`[handleMessage] Attempting retry request for failed decryption`);
+                        // Handle both pre-key and normal retries in single mutex
+                        retryMutex.mutex(async () => {
+                            try {
+                                if (!ws.isOpen) {
+                                    logger.debug({ node }, 'Connection closed, skipping retry');
+                                    return;
+                                }
+                                if (getBinaryNodeChild(node, 'unavailable')) {
+                                    logger.debug('Message unavailable, skipping retry');
+                                    return;
                                 }
-                                catch (err) {
-                                    logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry');
-                                    // Still attempt retry even if pre-key upload failed
+                                // Handle pre-key errors with upload and delay
+                                if (isPreKeyError) {
+                                    logger.info({ error: errorMessage }, 'PreKey error detected, uploading and retrying');
                                     try {
-                                        const encNode = getBinaryNodeChild(node, 'enc');
-                                        await sendRetryRequest(node, !encNode);
+                                        logger.debug('Uploading pre-keys for error recovery');
+                                        await uploadPreKeys(5);
+                                        logger.debug('Waiting for server to process new pre-keys');
+                                        await delay(1000);
                                     }
-                                    catch (retryErr) {
-                                        logger.error({ retryErr }, 'Failed to send retry after error handling');
+                                    catch (uploadErr) {
+                                        logger.error({ uploadErr }, 'Pre-key upload failed, proceeding with retry anyway');
                                     }
                                 }
-                            });
-                        }
-                        else {
-                            // no type in the receipt => message delivered
-                            let type = undefined;
-                            let participant = msg.key.participant;
-                            if (category === 'peer') {
-                                // special peer message
-                                type = 'peer_msg';
-                            }
-                            else if (msg.key.fromMe) {
-                                // message was sent by us from a different device
-                                type = 'sender';
-                                // need to specially handle this case
-                                if (isLidUser(msg.key.remoteJid) || isLidUser(msg.key.remoteJidAlt)) {
-                                    participant = author; // TODO: investigate sending receipts to LIDs and not PNs
+                                const encNode = getBinaryNodeChild(node, 'enc');
+                                await sendRetryRequest(node, !encNode);
+                                if (retryRequestDelayMs) {
+                                    await delay(retryRequestDelayMs);
                                 }
                             }
-                            else if (!sendActiveReceipts) {
-                                type = 'inactive';
+                            catch (err) {
+                                logger.error({ err, isPreKeyError }, 'Failed to handle retry, attempting basic retry');
+                                // Still attempt retry even if pre-key upload failed
+                                try {
+                                    const encNode = getBinaryNodeChild(node, 'enc');
+                                    await sendRetryRequest(node, !encNode);
+                                }
+                                catch (retryErr) {
+                                    logger.error({ retryErr }, 'Failed to send retry after error handling');
+                                }
                             }
-                            await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
-                            // send ack for history message
-                            const isAnyHistoryMsg = getHistoryMsg(msg.message);
-                            if (isAnyHistoryMsg) {
-                                const jid = jidNormalizedUser(msg.key.remoteJid);
-                                await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
+                        });
+                    }
+                    else {
+                        // no type in the receipt => message delivered
+                        let type = undefined;
+                        let participant = msg.key.participant;
+                        if (category === 'peer') {
+                            // special peer message
+                            type = 'peer_msg';
+                        }
+                        else if (msg.key.fromMe) {
+                            // message was sent by us from a different device
+                            type = 'sender';
+                            // need to specially handle this case
+                            if (isLidUser(msg.key.remoteJid) || isLidUser(msg.key.remoteJidAlt)) {
+                                participant = author; // TODO: investigate sending receipts to LIDs and not PNs
                             }
                         }
-                        cleanMessage(msg, authState.creds.me.id);
-                        await sendMessageAck(node);
-                        await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
-                    })
-                ]);
-            }
-            catch (error) {
-                logger.error({ error, node }, 'error in handling message');
-            }
+                        else if (!sendActiveReceipts) {
+                            type = 'inactive';
+                        }
+                        await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
+                        // send ack for history message
+                        const isAnyHistoryMsg = getHistoryMsg(msg.message);
+                        if (isAnyHistoryMsg) {
+                            const jid = jidNormalizedUser(msg.key.remoteJid);
+                            await sendReceipt(jid, undefined, [msg.key.id], 'hist_sync');
+                        }
+                    }
+                    cleanMessage(msg, authState.creds.me.id);
+                    await sendMessageAck(node);
+                    await upsertMessage(msg, node.attrs.offline ? 'append' : 'notify');
+                })
+            ]);
+        }
+        catch (error) {
+            logger.error({ error, node }, 'error in handling message');
+        }
+    };
+    const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated');
+        }
+        const pdoMessage = {
+            historySyncOnDemandRequest: {
+                chatJid: oldestMsgKey.remoteJid,
+                oldestMsgFromMe: oldestMsgKey.fromMe,
+                oldestMsgId: oldestMsgKey.id,
+                oldestMsgTimestampMs: oldestMsgTimestamp,
+                onDemandMsgCount: count
+            },
+            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
+        };
+        return sendPeerDataOperationMessage(pdoMessage);
+    };
+    const requestPlaceholderResend = async (messageKey) => {
+        if (!authState.creds.me?.id) {
+            throw new Boom('Not authenticated');
+        }
+        if (placeholderResendCache.get(messageKey?.id)) {
+            logger.debug({ messageKey }, 'already requested resend');
+            return;
+        }
+        else {
+            placeholderResendCache.set(messageKey?.id, true);
         }
+        await delay(5000);
+        if (!placeholderResendCache.get(messageKey?.id)) {
+            logger.debug({ messageKey }, 'message received while resend requested');
+            return 'RESOLVED';
+        }
+        const pdoMessage = {
+            placeholderMessageResendRequest: [
+                {
+                    messageKey
+                }
+            ],
+            peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.PLACEHOLDER_MESSAGE_RESEND
+        };
+        setTimeout(() => {
+            if (placeholderResendCache.get(messageKey?.id)) {
+                logger.debug({ messageKey }, 'PDO message without response after 15 seconds. Phone possibly offline');
+                placeholderResendCache.del(messageKey?.id);
+            }
+        }, 15000);
+        return sendPeerDataOperationMessage(pdoMessage);
     };
     const handleCall = async (node) => {
         let status;
@@ -1222,6 +1119,139 @@ export const makeMessagesRecvSocket = (config) => {
             processNodeWithBuffer(node, identifier, exec);
         }
     };
+    // Handles newsletter notifications
+    async function handleNewsletterNotification(node) {
+        const from = node.attrs.from;
+        const child = getAllBinaryNodeChildren(node)[0];
+        const author = node.attrs.participant;
+        logger.info({ from, child }, 'got newsletter notification');
+        switch (child.tag) {
+            case 'reaction':
+                const reactionUpdate = {
+                    id: from,
+                    server_id: child.attrs.message_id,
+                    reaction: {
+                        code: getBinaryNodeChildString(child, 'reaction'),
+                        count: 1
+                    }
+                };
+                ev.emit('newsletter.reaction', reactionUpdate);
+                break;
+            case 'view':
+                const viewUpdate = {
+                    id: from,
+                    server_id: child.attrs.message_id,
+                    count: parseInt(child.content?.toString() || '0', 10)
+                };
+                ev.emit('newsletter.view', viewUpdate);
+                break;
+            case 'participant':
+                const participantUpdate = {
+                    id: from,
+                    author,
+                    user: child.attrs.jid,
+                    action: child.attrs.action,
+                    new_role: child.attrs.role
+                };
+                ev.emit('newsletter-participants.update', participantUpdate);
+                break;
+            case 'update':
+                const settingsNode = getBinaryNodeChild(child, 'settings');
+                if (settingsNode) {
+                    const update = {};
+                    const nameNode = getBinaryNodeChild(settingsNode, 'name');
+                    if (nameNode?.content)
+                        update.name = nameNode.content.toString();
+                    const descriptionNode = getBinaryNodeChild(settingsNode, 'description');
+                    if (descriptionNode?.content)
+                        update.description = descriptionNode.content.toString();
+                    ev.emit('newsletter-settings.update', {
+                        id: from,
+                        update
+                    });
+                }
+                break;
+            case 'message':
+                const plaintextNode = getBinaryNodeChild(child, 'plaintext');
+                if (plaintextNode?.content) {
+                    try {
+                        const contentBuf = typeof plaintextNode.content === 'string'
+                            ? Buffer.from(plaintextNode.content, 'binary')
+                            : Buffer.from(plaintextNode.content);
+                        const messageProto = proto.Message.decode(contentBuf);
+                        const fullMessage = proto.WebMessageInfo.create({
+                            key: {
+                                remoteJid: from,
+                                id: child.attrs.message_id || child.attrs.server_id,
+                                fromMe: false
+                            },
+                            message: messageProto,
+                            messageTimestamp: +child.attrs.t
+                        });
+                        await upsertMessage(fullMessage, 'append');
+                        logger.info('Processed plaintext newsletter message');
+                    }
+                    catch (error) {
+                        logger.error({ error }, 'Failed to decode plaintext newsletter message');
+                    }
+                }
+                break;
+            default:
+                logger.warn({ node }, 'Unknown newsletter notification');
+                break;
+        }
+    }
+    // Handles mex newsletter notifications
+    async function handleMexNewsletterNotification(node) {
+        const mexNode = getBinaryNodeChild(node, 'mex');
+        if (!mexNode?.content) {
+            logger.warn({ node }, 'Invalid mex newsletter notification');
+            return;
+        }
+        let data;
+        try {
+            data = JSON.parse(mexNode.content.toString());
+        }
+        catch (error) {
+            logger.error({ err: error, node }, 'Failed to parse mex newsletter notification');
+            return;
+        }
+        const operation = data?.operation;
+        const updates = data?.updates;
+        if (!updates || !operation) {
+            logger.warn({ data }, 'Invalid mex newsletter notification content');
+            return;
+        }
+        logger.info({ operation, updates }, 'got mex newsletter notification');
+        switch (operation) {
+            case 'NotificationNewsletterUpdate':
+                for (const update of updates) {
+                    if (update.jid && update.settings && Object.keys(update.settings).length > 0) {
+                        ev.emit('newsletter-settings.update', {
+                            id: update.jid,
+                            update: update.settings
+                        });
+                    }
+                }
+                break;
+            case 'NotificationNewsletterAdminPromote':
+                for (const update of updates) {
+                    if (update.jid && update.user) {
+                        ev.emit('newsletter-participants.update', {
+                            id: update.jid,
+                            author: node.attrs.from,
+                            user: update.user,
+                            new_role: 'ADMIN',
+                            action: 'promote'
+                        });
+                    }
+                }
+                break;
+            default:
+                logger.info({ operation, data }, 'Unhandled mex newsletter notification');
+                break;
+        }
+    }
     // recv a message
     ws.on('CB:message', (node) => {
         processNode('message', node, 'processing message', handleMessage);