@aunucore/baileys 1.0.81 → 1.0.82

package/lib/Socket/messages-recv.js

@@ -44,6 +44,14 @@ export const makeMessagesRecvSocket = (config) => {
      * upstream Baileys retries forever against the same stale session. */
     const decryptFailCounts = new Map();
     const DECRYPT_FAIL_SESSION_RESET_LIMIT = 3;
+    /** AunuBaileys (1.0.82, HB-153): upstream v7 skips the retry for
+     * status broadcasts older than this — the peer has already
+     * deleted the expired status, so a resend can never be honoured
+     * and the failure says nothing about the session. */
+    const STATUS_EXPIRY_SECONDS = 86400;
+    /** AunuBaileys (1.0.82, HB-152): upstream v7 only asks the phone
+     * to resend a placeholder for messages younger than this. */
+    const PLACEHOLDER_MAX_AGE_SECONDS = 14 * 86400;
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     // AunuBaileys: bounded by default (see bounded-cache.js) — a TTL
@@ -238,8 +246,28 @@ export const makeMessagesRecvSocket = (config) => {
             }
             if (retryCount > 1 || forceIncludeKeys) {
                 const { update, preKeys } = await getNextPreKeys(authState, 1);
-                const [keyId] = Object.keys(preKeys);
-                const key = preKeys[+keyId];
+                let [keyId] = Object.keys(preKeys);
+                let key = preKeys[+keyId];
+                if (!key) {
+                    // AunuBaileys (1.0.82, HB-154 + addendum): the
+                    // stored head pre-key is missing entirely (store
+                    // cleaned / partial restore) or was filtered out
+                    // as corrupt by getNextPreKeys ({} / wrong-typed
+                    // material, HB-83/98 filter) — the map came back
+                    // empty and the bare deref below used to throw a
+                    // TypeError inside this transaction: the receipt
+                    // was never built, yet the retry counter above
+                    // was already spent. Generate a fresh pair into
+                    // the dead head slot instead: `update` advances
+                    // firstUnuploadedPreKeyId past exactly this id,
+                    // and the write joins this transaction, so the
+                    // private half is persisted before the receipt
+                    // carrying its public half is sent.
+                    keyId = `${authState.creds.firstUnuploadedPreKeyId}`;
+                    key = Curve.generateKeyPair();
+                    await authState.keys.set({ 'pre-key': { [keyId]: key } });
+                    logger.warn({ keyId }, 'aunu: no usable stored pre-key for the retry receipt; generated a fresh one into the head slot');
+                }
                 const content = receipt.content;
                 content.push({
                     tag: 'keys',
@@ -670,7 +698,21 @@ export const makeMessagesRecvSocket = (config) => {
         msgRetryCache.set(key, newValue);
     };
     const sendMessagesAgain = async (key, ids, retryNode, sessionPreInjected = false) => {
-        const msgs = await Promise.all(ids.map(async (id) => (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config, (jid) => aunuLid?.getAltJid?.(jid)).get(key.remoteJid, id)));
+        // AunuBaileys (1.0.82, HB-107): per-id isolation at the FETCH
+        // stage, mirroring HB-61 at the relay stage below. getMessage
+        // is host code (a DB/file store can throw); one throwing id
+        // used to reject the whole Promise.all, so NO id in the batch
+        // was resent this round and no retry counter advanced — the
+        // next peer receipt walked into the same wall.
+        const msgs = await Promise.all(ids.map(async (id) => {
+            try {
+                return (await getMessage({ ...key, id })) ?? sentMessageCacheFor(config, (jid) => aunuLid?.getAltJid?.(jid)).get(key.remoteJid, id);
+            }
+            catch (err) {
+                logger.warn({ err, jid: key.remoteJid, id }, 'aunu: getMessage failed for one id in a retry batch; treating it as unavailable and continuing with the rest');
+                return undefined;
+            }
+        }));
         const remoteJid = key.remoteJid;
         const participant = key.participant || remoteJid;
         // if it's the primary jid sending the request
@@ -775,7 +817,18 @@ export const makeMessagesRecvSocket = (config) => {
                         // correctly set who is asking for the retry
                         key.participant = key.participant || attrs.from;
                         const retryNode = getBinaryNodeChild(node, 'retry');
-                        if (willSendMessageAgain(ids[0], key.participant)) {
+                        // AunuBaileys (1.0.82, HB-160): the gate used
+                        // to check ids[0] ALONE — a capped first id
+                        // starved the fresh ids behind it, and a
+                        // fresh first id let capped ids behind it be
+                        // resent past the cap without limit. Filter
+                        // per id; the loop below only ever sees ids
+                        // that still have budget.
+                        const eligibleIds = ids.filter(id => willSendMessageAgain(id, key.participant));
+                        if (eligibleIds.length < ids.length) {
+                            logger.debug({ skipped: ids.filter(id => !eligibleIds.includes(id)), participant: key.participant }, 'aunu: some ids in the retry receipt are at the resend cap; resending only the rest');
+                        }
+                        if (eligibleIds.length) {
                             if (key.fromMe) {
                                 try {
                                     logger.debug({ attrs, key }, 'recv retry request');
@@ -796,7 +849,7 @@ export const makeMessagesRecvSocket = (config) => {
                                             logger.debug({ err: injErr }, 'aunu: retry receipt bundle injection failed; falling back to server fetch');
                                         }
                                     }
-                                    await sendMessagesAgain(key, ids, retryNode, sessionPreInjected);
+                                    await sendMessagesAgain(key, eligibleIds, retryNode, sessionPreInjected);
                                 }
                                 catch (error) {
                                     logger.error({ key, ids, trace: error.stack }, 'error in sending message again');
@@ -880,13 +933,37 @@ export const makeMessagesRecvSocket = (config) => {
         let response;
         if (getBinaryNodeChild(node, 'unavailable') && !encNode) {
             await sendMessageAck(node);
-            const { key } = decodeMessageNode(node, authState.creds.me?.id, authState.creds.me?.lid || '').fullMessage;
+            // AunuBaileys (1.0.82, HB-146): this decode sat OUTSIDE
+            // any try (the HB-1 fix covered only the decrypt path
+            // below). A stanza whose `from` is not a recognised JID
+            // type — malformed today, a future JID domain tomorrow —
+            // threw 'Unknown message type' after the ack had already
+            // gone out: only logged by the caller, and the
+            // placeholder was never resent nor upserted. Classify
+            // and drop it here, like the main decode path.
+            let key;
+            try {
+                key = decodeMessageNode(node, authState.creds.me?.id, authState.creds.me?.lid || '').fullMessage.key;
+            }
+            catch (decodeErr) {
+                logger.error({ error: decodeErr, node }, 'aunu: error decoding unavailable message node; acked, skipping placeholder resend');
+                return;
+            }
             // AunuBaileys: bot / hosted / view_once placeholders can never
             // be resent by the phone — don't burn a resend request on
             // them (behaviour learned from @violetix/baileys).
             if (isUnrecoverableUnavailable(node)) {
                 logger.debug({ msgId: key.id, unavailableType: unavailablePlaceholderType(node) }, 'unavailable placeholder cannot be resent; skipping resend request');
             }
+            else if (!authState.creds.me?.id) {
+                // AunuBaileys (1.0.82, HB-106): requestPlaceholderResend
+                // throws Boom 'Not authenticated' in the pre-success
+                // window — and because the ack above has ALREADY gone
+                // out, the throw (caught only by the caller's logger)
+                // lost the placeholder silently: no resend, no upsert.
+                // Skip cleanly, like sendRetryRequest does (HB-6).
+                logger.warn({ msgId: key.id }, 'aunu: cannot request placeholder resend before pairing completes; skipping');
+            }
             else {
                 response = await requestPlaceholderResend(key);
             }
@@ -941,14 +1018,85 @@ export const makeMessagesRecvSocket = (config) => {
                     }
                     // 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 stubParam = msg?.messageStubParameters?.[0];
+                        const isMissingKeysFailure = stubParam === MISSING_KEYS_ERROR_TEXT;
+                        const isNoMessageFailure = stubParam === NO_MESSAGE_FOUND_ERROR_TEXT;
+                        // AunuBaileys (1.0.82, HB-170): an msmsg (Meta
+                        // AI) failure is a message-SECRET problem, not
+                        // an E2E session problem — @bot has no resend
+                        // path, so a retry receipt only burns budget
+                        // and the fail counter marched toward a
+                        // pointless @bot session reset.
+                        const isMsmsgFailure = encNode?.attrs?.type === 'msmsg' ||
+                            (typeof stubParam === 'string' && stubParam.startsWith('msmsg'));
+                        // AunuBaileys (1.0.82, HB-153): a status that
+                        // expired on the peer can never be resent.
+                        const isExpiredStatusFailure = !isNoMessageFailure &&
+                            isJidStatusBroadcast(msg.key.remoteJid) &&
+                            Number.isFinite(+node.attrs.t) &&
+                            (unixTimestampSeconds() - +node.attrs.t) > STATUS_EXPIRY_SECONDS;
+                        if (isMissingKeysFailure) {
+                            // AunuBaileys (1.0.82, HB-206): the 487
+                            // NACK stays, but the early return is
+                            // gone. 'Key used already or never filled'
+                            // is a SESSION-layer failure, so it now
+                            // flows through the counting / self-heal
+                            // machinery below and the stub upsert at
+                            // the end of this branch, like every other
+                            // decrypt failure — only the retry receipt
+                            // is skipped (a resend of the same
+                            // ciphertext cannot restore a message key
+                            // our ratchet no longer holds).
+                            await sendMessageAck(node, NACK_REASONS.ParsingError);
+                        }
+                        if (isNoMessageFailure) {
+                            // AunuBaileys (1.0.82, HB-152): the stanza
+                            // carried no encrypted content at all —
+                            // there is nothing to re-decrypt and
+                            // nothing wrong with the session, so no
+                            // retry receipt and no fail count (three
+                            // of these used to reset a healthy
+                            // session). Ask the phone for a placeholder
+                            // resend when eligible (v7 policy:
+                            // recoverable type, fresh enough) and let
+                            // the stub upsert below stand as the
+                            // trace. Fire-and-forget: the resend waits
+                            // 5 s and must not hold the processing
+                            // mutex (see the 1.0.70 note in
+                            // sendRetryRequest).
+                            if (!response && !msg.key.fromMe && !isUnrecoverableUnavailable(node) &&
+                                Number.isFinite(+node.attrs.t) &&
+                                (unixTimestampSeconds() - +node.attrs.t) <= PLACEHOLDER_MAX_AGE_SECONDS) {
+                                requestPlaceholderResend(msg.key).then(
+                                    (resendId) => logger.debug({ resendId }, 'aunu: requested placeholder resend for a message with no encrypted content'),
+                                    (err) => logger.debug({ err }, 'aunu: placeholder resend for a message with no encrypted content failed')
+                                );
+                            }
+                            logger.debug({ msgId: msg.key.id, author }, 'aunu: message stanza carried no encrypted content; no retry receipt, no session failure counted');
+                        }
+                        else if (isMsmsgFailure) {
+                            logger.debug({ msgId: msg.key.id, author, stubParam }, 'aunu: msmsg decrypt failure; no retry receipt and no session failure counted (a secret problem, not a session problem)');
                         }
-                        retryMutex.mutex(async () => {
+                        else if (isExpiredStatusFailure) {
+                            logger.debug({ msgId: msg.key.id, author, ageSeconds: unixTimestampSeconds() - +node.attrs.t }, 'aunu: decrypt failure for an expired status; no retry receipt and no session failure counted');
+                        }
+                        else retryMutex.mutex(async () => {
                             if (ws.isOpen) {
-                                if (getBinaryNodeChild(node, 'unavailable')) {
-                                    return;
-                                }
+                                // AunuBaileys (1.0.82, HB-183): the
+                                // blanket early return for stanzas
+                                // carrying an <unavailable> child is
+                                // gone — it suppressed the retry
+                                // receipt, the fail counting, the
+                                // self-heal AND the decrypt-failure
+                                // event for every enc-bearing failure
+                                // that rode along with one (view-once
+                                // above all), leaving the content
+                                // unrecoverable and the rotten session
+                                // uncounted. Upstream v7 has no such
+                                // guard on this path; the placeholder
+                                // choice for unavailable types lives in
+                                // the no-enc branch and in HB-152's
+                                // classification above.
                                 const encNode = getBinaryNodeChild(node, 'enc');
                                 let forceIncludeKeys = !encNode;
                                 if (author) {
@@ -1058,7 +1206,7 @@ export const makeMessagesRecvSocket = (config) => {
                                 // under that device's session; a retry
                                 // receipt would ask ourselves to resend to
                                 // ourselves.
-                                if (!msg.key.fromMe) {
+                                if (!msg.key.fromMe && !isMissingKeysFailure) {
                                     await sendRetryRequest(node, forceIncludeKeys);
                                     if (retryRequestDelayMs) {
                                         await delay(retryRequestDelayMs);
@@ -1474,12 +1622,16 @@ export const makeMessagesRecvSocket = (config) => {
     const offlineNodeProcessor = makeOfflineNodeProcessor();
     const processNode = (type, node, identifier, exec) => {
         // AunuBaileys: ignoreKey filter — a matching stanza is dropped
-        // before any handling (no decryption, no persistence); messages
+        // before any handling (no decryption, no persistence); stanzas
         // are still acked so the server stops redelivering them.
+        // AunuBaileys (1.0.82, HB-210): the ack used to cover only
+        // type 'message' — a dropped receipt/notification/call was
+        // never acked, so the server redelivered it forever while the
+        // rule stayed active (all four real handlers ack in a
+        // finally; the drop bypassed every one of them, against the
+        // filter's own documented intent).
         if (sock.aunuIgnoreFilter?.shouldDrop(type, node, [authState.creds.me?.id, authState.creds.me?.lid].filter(Boolean))) {
-            if (type === 'message') {
-                sendMessageAck(node).catch(() => { });
-            }
+            sendMessageAck(node).catch(() => { });
             logger.debug({ type, from: node.attrs.from, id: node.attrs.id }, 'aunu: stanza dropped by ignoreKey');
             return;
         }

package/lib/Utils/decode-wa-message.js

@@ -287,6 +287,17 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                 // 'last' = complete response, 'first' =
                                 // streaming partial, intentionally skipped.
                                 if (botType !== null && !['full', 'last'].includes(botType)) {
+                                    // AunuBaileys (1.0.82, HB-171
+                                    // addendum): the skip used to leave
+                                    // no trace at all — the caller took
+                                    // the SUCCESS branch, sent a
+                                    // 'delivered' receipt and upserted
+                                    // an empty message for content that
+                                    // was never read. Leave a CIPHERTEXT
+                                    // stub, like any other undecrypted
+                                    // content.
+                                    fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
+                                    fullMessage.messageStubParameters = [`msmsg streaming partial skipped (edit=${botType})`];
                                     break;
                                 }
                                 const secretIdCandidates = [botEditTargetId, metaTargetId, fullMessage.key?.id].filter(Boolean);
@@ -315,6 +326,16 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                                 }
                                 if (!secretCandidates.length) {
                                     logger.warn({ metaTargetId, botType, secretIdCandidates }, 'msmsg: no candidate messageSecret found, skipping');
+                                    // AunuBaileys (1.0.82, HB-171): same
+                                    // false-success as the partial skip
+                                    // above — without a stub the caller
+                                    // receipts this as delivered and
+                                    // stores an empty message. The stub
+                                    // is the trace; messages-recv
+                                    // excludes the msmsg class from
+                                    // retry/fail counting (HB-170).
+                                    fullMessage.messageStubType = proto.WebMessageInfo.StubType.CIPHERTEXT;
+                                    fullMessage.messageStubParameters = ['msmsg: no candidate messageSecret found'];
                                     break;
                                 }
                                 const msMsg = proto.MessageSecretMessage.decode(content);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aunucore/baileys",
   "type": "module",
-  "version": "1.0.81",
+  "version": "1.0.82",
   "description": "AunuBaileys — the self-healing WhatsApp Web API for Node.js. Bad MAC and \"2000 messages into the future\" errors repair themselves, LID and phone-number identities stay in sync, anti-ban is built in, pairing codes are custom — plus 29 experimental features no other Baileys fork ships: invisible watermarks, per-person tag-all cards, side-profile text, ghost mentions and more. ESM, CJS and full TypeScript types.",
   "keywords": [
     "whatsapp",