@itsliaaa/baileys 0.1.5 → 0.1.6

package/lib/Socket/messages-recv.js

@@ -7,6 +7,8 @@ import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT, PLACEHOLDER_MAX_
 import { WAMessageStatus, WAMessageStubType } from '../Types/index.js';
 import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, extractAddressingContext, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, handleIdentityChange, hkdf, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, toNumber, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
+import { makeOfflineNodeProcessor } from '../Utils/offline-node-processor.js';
+import { buildAckStanza } from '../Utils/stanza-ack.js';
 import { areJidsSameUser, binaryNodeToString, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidNewsletter, isJidStatusBroadcast, isLidUser, isPnUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
 import { extractGroupMetadata } from './groups.js';
 import { makeMessagesSocket } from './messages-send.js';
@@ -217,32 +219,9 @@ export const makeMessagesRecvSocket = (config) => {
                 break;
         }
     };
-    const sendMessageAck = async ({ tag, attrs, content }, errorCode) => {
-        const stanza = {
-            tag: 'ack',
-            attrs: {
-                id: attrs.id,
-                to: attrs.from,
-                class: tag
-            }
-        };
-        if (!!errorCode) {
-            stanza.attrs.error = errorCode.toString();
-        }
-        if (!!attrs.participant) {
-            stanza.attrs.participant = attrs.participant;
-        }
-        if (!!attrs.recipient) {
-            stanza.attrs.recipient = attrs.recipient;
-        }
-        if (!!attrs.type &&
-            (tag !== 'message' || getBinaryNodeChild({ tag, attrs, content }, 'unavailable') || errorCode !== 0)) {
-            stanza.attrs.type = attrs.type;
-        }
-        if (tag === 'message' && getBinaryNodeChild({ tag, attrs, content }, 'unavailable')) {
-            stanza.attrs.from = authState.creds.me.id;
-        }
-        logger.debug({ recv: { tag, attrs }, sent: stanza.attrs }, 'sent ack');
+    const sendMessageAck = async (node, errorCode) => {
+        const stanza = buildAckStanza(node, errorCode, authState.creds.me.id);
+        logger.debug({ recv: { tag: node.tag, attrs: node.attrs }, sent: stanza.attrs }, 'sent ack');
         await sendNode(stanza);
     };
     const rejectCall = async (callId, callFrom) => {
@@ -995,7 +974,7 @@ export const makeMessagesRecvSocket = (config) => {
             ]);
         }
         finally {
-            await sendMessageAck(node);
+            await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack receipt'));
         }
     };
     const handleNotification = async (node) => {
@@ -1030,7 +1009,7 @@ export const makeMessagesRecvSocket = (config) => {
             ]);
         }
         finally {
-            await sendMessageAck(node);
+            await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack notification'));
         }
     };
     const handleMessage = async (node) => {
@@ -1046,36 +1025,34 @@ export const makeMessagesRecvSocket = (config) => {
             await sendMessageAck(node, NACK_REASONS.MissingMessageSecret);
             return;
         }
-        const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
-        const alt = msg.key.participantAlt || msg.key.remoteJidAlt;
-        // store new mappings we didn't have before
-        if (!!alt) {
-            const altServer = jidDecode(alt)?.server;
-            const primaryJid = msg.key.participant || msg.key.remoteJid;
-            if (altServer === 'lid') {
-                if (!(await signalRepository.lidMapping.getPNForLID(alt))) {
-                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }]);
-                    await signalRepository.migrateSession(primaryJid, alt);
+        let acked = false;
+        try {
+            const { fullMessage: msg, category, author, decrypt } = decryptMessageNode(node, authState.creds.me.id, authState.creds.me.lid || '', signalRepository, logger);
+            const alt = msg.key.participantAlt || msg.key.remoteJidAlt;
+            // store new mappings we didn't have before
+            if (!!alt) {
+                const altServer = jidDecode(alt)?.server;
+                const primaryJid = msg.key.participant || msg.key.remoteJid;
+                if (altServer === 'lid') {
+                    if (!(await signalRepository.lidMapping.getPNForLID(alt))) {
+                        await signalRepository.lidMapping.storeLIDPNMappings([{ lid: alt, pn: primaryJid }]);
+                        await signalRepository.migrateSession(primaryJid, alt);
+                    }
+                }
+                else {
+                    await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }]);
+                    await signalRepository.migrateSession(alt, primaryJid);
                 }
             }
-            else {
-                await signalRepository.lidMapping.storeLIDPNMappings([{ lid: primaryJid, pn: alt }]);
-                await signalRepository.migrateSession(alt, primaryJid);
-            }
-        }
-        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');
-        }
-        try {
             await messageMutex.mutex(async () => {
                 await decrypt();
+                if (msg.key?.remoteJid && msg.key?.id && msg.message && messageRetryManager) {
+                    messageRetryManager.addRecentMessage(msg.key.remoteJid, msg.key.id, msg.message);
+                }
                 // message failed to decrypt
                 if (msg.messageStubType === proto.WebMessageInfo.StubType.CIPHERTEXT && msg.category !== 'peer') {
                     if (msg?.messageStubParameters?.[0] === MISSING_KEYS_ERROR_TEXT) {
+                        acked = true;
                         return sendMessageAck(node, NACK_REASONS.ParsingError);
                     }
                     if (msg.messageStubParameters?.[0] === NO_MESSAGE_FOUND_ERROR_TEXT) {
@@ -1087,11 +1064,13 @@ export const makeMessagesRecvSocket = (config) => {
                             unavailableType === 'hosted_unavailable_fanout' ||
                             unavailableType === 'view_once_unavailable_fanout') {
                             logger.debug({ msgId: msg.key.id, unavailableType }, 'skipping placeholder resend for excluded unavailable type');
+                            acked = true;
                             return sendMessageAck(node);
                         }
                         const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp);
                         if (messageAge > PLACEHOLDER_MAX_AGE_SECONDS) {
                             logger.debug({ msgId: msg.key.id, messageAge }, 'skipping placeholder resend for old message');
+                            acked = true;
                             return sendMessageAck(node);
                         }
                         // Request the real content from the phone via placeholder resend PDO.
@@ -1128,6 +1107,7 @@ export const makeMessagesRecvSocket = (config) => {
                             .catch(err => {
                             logger.warn({ err, msgId: msg.key.id }, 'failed to request placeholder resend for unavailable message');
                         });
+                        acked = true;
                         await sendMessageAck(node);
                         // Don't return — fall through to upsertMessage so the stub is emitted
                     }
@@ -1137,6 +1117,7 @@ export const makeMessagesRecvSocket = (config) => {
                             const messageAge = unixTimestampSeconds() - toNumber(msg.messageTimestamp);
                             if (messageAge > STATUS_EXPIRY_SECONDS) {
                                 logger.debug({ msgId: msg.key.id, messageAge, remoteJid: msg.key.remoteJid }, 'skipping retry for expired status message');
+                                acked = true;
                                 return sendMessageAck(node);
                             }
                         }
@@ -1180,6 +1161,7 @@ export const makeMessagesRecvSocket = (config) => {
                                     logger.error({ retryErr }, 'Failed to send retry after error handling');
                                 }
                             }
+                            acked = true;
                             await sendMessageAck(node, NACK_REASONS.UnhandledError);
                         });
                     }
@@ -1208,6 +1190,7 @@ export const makeMessagesRecvSocket = (config) => {
                         else if (!sendActiveReceipts) {
                             type = 'inactive';
                         }
+                        acked = true;
                         await sendReceipt(msg.key.remoteJid, participant, [msg.key.id], type);
                         // send ack for history message
                         const isAnyHistoryMsg = getHistoryMsg(msg.message);
@@ -1217,6 +1200,7 @@ export const makeMessagesRecvSocket = (config) => {
                         }
                     }
                     else {
+                        acked = true;
                         await sendMessageAck(node);
                         logger.debug({ key: msg.key }, 'processed newsletter message without receipts');
                     }
@@ -1227,45 +1211,55 @@ export const makeMessagesRecvSocket = (config) => {
         }
         catch (error) {
             logger.error({ error, node: binaryNodeToString(node) }, 'error in handling message');
+            if (!acked) {
+                await sendMessageAck(node, NACK_REASONS.UnhandledError).catch(ackErr => logger.error({ ackErr }, 'failed to ack message after error'));
+            }
         }
     };
     const handleCall = async (node) => {
-        const { attrs } = node;
-        const [infoChild] = getAllBinaryNodeChildren(node);
-        const status = getCallStatusFromNode(infoChild);
-        if (!infoChild) {
-            throw new Boom('Missing call info in call node');
-        }
-        const callId = infoChild.attrs['call-id'];
-        const from = infoChild.attrs.from || infoChild.attrs['call-creator'];
-        const call = {
-            chatId: attrs.from,
-            from,
-            callerPn: infoChild.attrs['caller_pn'],
-            id: callId,
-            date: new Date(+attrs.t * 1000),
-            offline: !!attrs.offline,
-            status
-        };
-        if (status === 'offer') {
-            call.isVideo = !!getBinaryNodeChild(infoChild, 'video');
-            call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
-            call.groupJid = infoChild.attrs['group-jid'];
-            await callOfferCache.set(call.id, call);
+        try {
+            const { attrs } = node;
+            const [infoChild] = getAllBinaryNodeChildren(node);
+            if (!infoChild) {
+                throw new Boom('Missing call info in call node');
+            }
+            const status = getCallStatusFromNode(infoChild);
+            const callId = infoChild.attrs['call-id'];
+            const from = infoChild.attrs.from || infoChild.attrs['call-creator'];
+            const call = {
+                chatId: attrs.from,
+                from,
+                callerPn: infoChild.attrs['caller_pn'],
+                id: callId,
+                date: new Date(+attrs.t * 1000),
+                offline: !!attrs.offline,
+                status
+            };
+            if (status === 'offer') {
+                call.isVideo = !!getBinaryNodeChild(infoChild, 'video');
+                call.isGroup = infoChild.attrs.type === 'group' || !!infoChild.attrs['group-jid'];
+                call.groupJid = infoChild.attrs['group-jid'];
+                await callOfferCache.set(call.id, call);
+            }
+            const existingCall = await callOfferCache.get(call.id);
+            // use existing call info to populate this event
+            if (existingCall) {
+                call.isVideo = existingCall.isVideo;
+                call.isGroup = existingCall.isGroup;
+                call.callerPn = call.callerPn || existingCall.callerPn;
+            }
+            // delete data once call has ended
+            if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
+                await callOfferCache.del(call.id);
+            }
+            ev.emit('call', [call]);
         }
-        const existingCall = await callOfferCache.get(call.id);
-        // use existing call info to populate this event
-        if (existingCall) {
-            call.isVideo = existingCall.isVideo;
-            call.isGroup = existingCall.isGroup;
-            call.callerPn = call.callerPn || existingCall.callerPn;
+        catch (error) {
+            logger.error({ error, node: binaryNodeToString(node) }, 'error in handling call');
         }
-        // delete data once call has ended
-        if (status === 'reject' || status === 'accept' || status === 'timeout' || status === 'terminate') {
-            await callOfferCache.del(call.id);
+        finally {
+            await sendMessageAck(node).catch(ackErr => logger.error({ ackErr }, 'failed to ack call'));
         }
-        ev.emit('call', [call]);
-        await sendMessageAck(node);
     };
     const handleBadAck = async ({ attrs }) => {
         const key = { remoteJid: attrs.from, fromMe: true, id: attrs.id };
@@ -1320,52 +1314,16 @@ export const makeMessagesRecvSocket = (config) => {
             return exec(node, false).catch(err => onUnexpectedError(err, identifier));
         }
     };
-    /** Yields control to the event loop to prevent blocking */
-    const yieldToEventLoop = () => {
-        return new Promise(resolve => setImmediate(resolve));
-    };
-    const makeOfflineNodeProcessor = () => {
-        const nodeProcessorMap = new Map([
-            ['message', handleMessage],
-            ['call', handleCall],
-            ['receipt', handleReceipt],
-            ['notification', handleNotification]
-        ]);
-        const nodes = [];
-        let isProcessing = false;
-        // Number of nodes to process before yielding to event loop
-        const BATCH_SIZE = 10;
-        const enqueue = (type, node) => {
-            nodes.push({ type, node });
-            if (isProcessing) {
-                return;
-            }
-            isProcessing = true;
-            const promise = async () => {
-                let processedInBatch = 0;
-                while (nodes.length && ws.isOpen) {
-                    const { type, node } = nodes.shift();
-                    const nodeProcessor = nodeProcessorMap.get(type);
-                    if (!nodeProcessor) {
-                        onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
-                        continue;
-                    }
-                    await nodeProcessor(node);
-                    processedInBatch++;
-                    // Yield to event loop after processing a batch
-                    // This prevents blocking the event loop for too long when there are many offline nodes
-                    if (processedInBatch >= BATCH_SIZE) {
-                        processedInBatch = 0;
-                        await yieldToEventLoop();
-                    }
-                }
-                isProcessing = false;
-            };
-            promise().catch(error => onUnexpectedError(error, 'processing offline nodes'));
-        };
-        return { enqueue };
-    };
-    const offlineNodeProcessor = makeOfflineNodeProcessor();
+    const offlineNodeProcessor = makeOfflineNodeProcessor(new Map([
+        ['message', handleMessage],
+        ['call', handleCall],
+        ['receipt', handleReceipt],
+        ['notification', handleNotification]
+    ]), {
+        isWsOpen: () => ws.isOpen,
+        onUnexpectedError,
+        yieldToEventLoop: () => new Promise(resolve => setImmediate(resolve))
+    });
     const processNode = async (type, node, identifier, exec) => {
         const isOffline = !!node.attrs.offline;
         if (isOffline) {

package/lib/Utils/index.js

@@ -16,4 +16,5 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
-export * from './identity-change-handler.js';
+export * from './identity-change-handler.js';
+export * from './stanza-ack.js';

package/lib/Utils/offline-node-processor.js

@@ -0,0 +1,39 @@
+/**
+ * Creates a processor for offline stanza nodes that:
+ * - Queues nodes for sequential processing
+ * - Yields to the event loop periodically to avoid blocking
+ * - Catches handler errors to prevent the processing loop from crashing
+ */
+export function makeOfflineNodeProcessor(nodeProcessorMap, deps, batchSize = 10) {
+    const nodes = [];
+    let isProcessing = false;
+    const enqueue = (type, node) => {
+        nodes.push({ type, node });
+        if (isProcessing) {
+            return;
+        }
+        isProcessing = true;
+        const promise = async () => {
+            let processedInBatch = 0;
+            while (nodes.length && deps.isWsOpen()) {
+                const { type, node } = nodes.shift();
+                const nodeProcessor = nodeProcessorMap.get(type);
+                if (!nodeProcessor) {
+                    deps.onUnexpectedError(new Error(`unknown offline node type: ${type}`), 'processing offline node');
+                    continue;
+                }
+                await nodeProcessor(node).catch(err => deps.onUnexpectedError(err, `processing offline ${type}`));
+                processedInBatch++;
+                // Yield to event loop after processing a batch
+                // This prevents blocking the event loop for too long when there are many offline nodes
+                if (processedInBatch >= batchSize) {
+                    processedInBatch = 0;
+                    await deps.yieldToEventLoop();
+                }
+            }
+            isProcessing = false;
+        };
+        promise().catch(error => deps.onUnexpectedError(error, 'processing offline nodes'));
+    };
+    return { enqueue };
+}

package/lib/Utils/stanza-ack.js

@@ -0,0 +1,37 @@
+/**
+ * Builds an ACK stanza for a received node.
+ * Pure function -- no I/O, no side effects.
+ *
+ * Mirrors WhatsApp Web's ACK construction:
+ * - WAWebHandleMsgSendAck.sendAck / sendNack
+ * - WAWebCreateNackFromStanza.createNackFromStanza
+ */
+export function buildAckStanza(node, errorCode, meId) {
+    const { tag, attrs } = node;
+    const stanza = {
+        tag: 'ack',
+        attrs: {
+            id: attrs.id,
+            to: attrs.from,
+            class: tag
+        }
+    };
+    if (errorCode) {
+        stanza.attrs.error = errorCode.toString();
+    }
+    if (attrs.participant) {
+        stanza.attrs.participant = attrs.participant;
+    }
+    if (attrs.recipient) {
+        stanza.attrs.recipient = attrs.recipient;
+    }
+    // WA Web always includes type when present: `n.type || DROP_ATTR`
+    if (attrs.type) {
+        stanza.attrs.type = attrs.type;
+    }
+    // WA Web WAWebHandleMsgSendAck.sendAck/sendNack always include `from` for message-class ACKs
+    if (tag === 'message' && meId) {
+        stanza.attrs.from = meId;
+    }
+    return stanza;
+}

package/lib/WABinary/generic-utils.js

@@ -124,12 +124,12 @@ export function binaryNodeToString(node, i = 0) {
  * @returns {object} A node with shape { tag, attrs, [content] } to inject into additionalNodes.
  */
 const FLOWS_MAP = {
-    mpm: 1,
-    cta_catalog: 1,
-    send_location: 1,
-    call_permission_request: 1,
-    wa_payment_transaction_details: 1,
-    automated_greeting_message_view_catalog: 1
+    mpm: true,
+    cta_catalog: true,
+    send_location: true,
+    call_permission_request: true,
+    wa_payment_transaction_details: true,
+    automated_greeting_message_view_catalog: true
 };
 const qualityAttribute = {
     tag: 'quality_control',
@@ -157,7 +157,7 @@ export const getBizBinaryNode = (message) => {
             content: defaultContent
         };
     }
-    else if (buttonName && FLOWS_MAP[buttonName]) {
+    if (buttonName && FLOWS_MAP[buttonName]) {
         return {
             tag: 'biz',
             attrs: {},
@@ -195,7 +195,7 @@ export const getBizBinaryNode = (message) => {
             ]
         };
     }
-    else if (message.listMessage) {
+    if (message.listMessage) {
         return {
             tag: 'biz',
             attrs: {},

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "@itsliaaa/baileys",
-   "version": "0.1.5",
+   "version": "0.1.6",
    "description": "A simple fork of Baileys for WhatsApp automation",
    "main": "lib/index.js",
    "type": "module",