aunubaileys 1.0.45 → 1.0.46

package/README.md

@@ -64,6 +64,10 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.46 / Baru di 1.0.46
+
+- 🩹 **The "Over 2000 messages into the future" flood now heals itself.** Session-layer decrypt failures — libsignal's aggregate "No matching sessions found for message" / "No session record" / "No sessions available", which includes the unfillable counter gap left by regressed session state (e.g. sessions restored from a backup while the sender kept sending; observed live in the Tenka deployment on 11 Nov 2026, on the same LID address as the old B-01 finding) — are now recognised from `messageStubParameters` and trigger an **immediate E2E session reset** instead of waiting for 3 failures: for DMs and groups alike (groups also drop the author's sender key), including the session record under its alternate PN↔LID address form, with the retry receipt carrying fresh keys. The old self-heal missed this flood because it waited 3 strikes, in groups only touched the sender key while the broken layer is the E2E session, and deletion could miss the aliased record. Other error classes (ordinary Bad MAC) keep the exact 1.0.14/1.0.17 3-strike behaviour. New exported classifier: `isUnrecoverableSessionError(text)`; the `messages.decrypt-failure` event gains an `errorClass` field (`'session'`/`'other'`) and `healed` now reflects a reset that actually happened on that message.
+
 ### 🆕 What's new in 1.0.45 / Baru di 1.0.45
 
 - 📞 **VOIP call support (from plogme, original implementation)** — one combined release from an 8-package sweep (raiden-baileys, @neoxr/wb, @zervonex/baileys, @itsliaaa/starseal, alya-baileys, @ryuu-reinzz/baileys, @cogitator-ai/channels, plogme — all audited clean). New socket methods: `offerCall(jid, isVideo?)` and `groupCall(groupJid, participants, isVideo?)` build the `<offer>` with a per-device encrypted call-key envelope, `cancelGroupCall(groupJid, callId)`, and `acceptCall(callId, callFrom)` / `terminateCall(callId, callFrom, reason?)` join the existing `rejectCall`. Pure stanza builders are exported from `lib/Utils/call-utils.js` so the wire shapes are unit-testable. The stanza shapes follow the WhatsApp call protocol; the code is an original AunuBaileys implementation (plogme's license forbids copying its code). This is the signalling layer — two-way VOIP media is out of scope. plogme's voip-rekey decoder was **not** ported: the 6.7.24 proto has no `E2eRekeyPayload`.

package/lib/Socket/messages-recv.js

@@ -5,7 +5,7 @@ import Long from 'long';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, KEY_BUNDLE_TYPE, MIN_PREKEY_COUNT } from '../Defaults/index.js';
 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, buildCallControlStanza, parseRetryReceiptSession, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
+import { aesDecryptCTR, aesEncryptGCM, cleanMessage, Curve, decodeMediaRetryNode, decodeMessageNode, decryptMessageNode, delay, derivePairingCodeKey, encodeBigEndian, encodeSignedDeviceIdentity, getCallStatusFromNode, getHistoryMsg, getNextPreKeys, getStatusFromReceiptType, hkdf, isUnrecoverableSessionError, MISSING_KEYS_ERROR_TEXT, NACK_REASONS, NO_MESSAGE_FOUND_ERROR_TEXT, buildCallControlStanza, parseRetryReceiptSession, unixTimestampSeconds, xmppPreKey, xmppSignedPreKey } from '../Utils/index.js';
 import { makeMutex } from '../Utils/make-mutex.js';
 import { sentMessageCacheFor } from '../Utils/sent-message-cache.js';
 import { areJidsSameUser, getAllBinaryNodeChildren, getBinaryNodeChild, getBinaryNodeChildBuffer, getBinaryNodeChildren, getBinaryNodeChildString, isJidGroup, isJidStatusBroadcast, isJidUser, isLidUser, jidDecode, jidNormalizedUser, S_WHATSAPP_NET } from '../WABinary/index.js';
@@ -758,17 +758,47 @@ export const makeMessagesRecvSocket = (config) => {
                                         const addr = signalRepository.jidToSignalProtocolAddress(author);
                                         const failKey = isGroupMsg ? `sk:${msg.key.remoteJid}:${addr}` : addr;
                                         const fails = (decryptFailCounts.get(failKey) || 0) + 1;
-                                        if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
+                                        // AunuBaileys (1.0.46): kegagalan lapis sesi — record
+                                        // sesi tersimpan tidak dapat mendekripsi pesan ini
+                                        // sama sekali (termasuk jurang "Over 2000 messages
+                                        // into the future" akibat state sesi yang mundur).
+                                        // Jurang itu tidak bisa diisi ulang, jadi menunggu
+                                        // 3x hanya membanjiri log; dan di grup, menghapus
+                                        // sender key saja tidak menyentuh sesi E2E yang
+                                        // rusak. Kelas ini direset SEKETIKA.
+                                        const sessionLayerFailure = isUnrecoverableSessionError(msg?.messageStubParameters?.[0]);
+                                        let healed = false;
+                                        const resetE2ESession = async () => {
+                                            await signalRepository.deleteSession(author);
+                                            // sesi yang sama bisa tersimpan di bawah bentuk
+                                            // alamat alternatifnya (PN <-> LID)
+                                            const alt = sock.aunuLid?.getAltJid?.(author);
+                                            if (alt && alt !== author) {
+                                                await signalRepository.deleteSession(alt);
+                                            }
+                                        };
+                                        if (sessionLayerFailure) {
+                                            await resetE2ESession();
+                                            if (isGroupMsg) {
+                                                await signalRepository.deleteSenderKey(msg.key.remoteJid, author);
+                                            }
+                                            decryptFailCounts.delete(failKey);
+                                            forceIncludeKeys = true;
+                                            healed = true;
+                                            logger.warn({ author, addr, group: isGroupMsg ? msg.key.remoteJid : undefined }, 'aunu: reset E2E session after an unrecoverable session-layer decrypt failure (stored session cannot decrypt, e.g. regressed state); retry receipt carries fresh keys');
+                                        }
+                                        else if (fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT) {
                                             if (isGroupMsg) {
                                                 await signalRepository.deleteSenderKey(msg.key.remoteJid, author);
                                                 logger.warn({ author, group: msg.key.remoteJid }, 'aunu: deleted stale sender-key record after repeated group decrypt failures; retry request asks the author to resend with a fresh distribution message');
                                             }
                                             else {
-                                                await signalRepository.deleteSession(author);
+                                                await resetE2ESession();
                                                 logger.warn({ author, addr }, 'aunu: deleted stale E2E session after repeated decrypt failures (Bad MAC self-heal); retry receipt carries fresh keys');
                                             }
                                             decryptFailCounts.delete(failKey);
                                             forceIncludeKeys = true;
+                                            healed = true;
                                         }
                                         else {
                                             decryptFailCounts.set(failKey, fails);
@@ -782,7 +812,8 @@ export const makeMessagesRecvSocket = (config) => {
                                             address: addr,
                                             isGroup: isGroupMsg,
                                             failures: fails,
-                                            healed: fails >= DECRYPT_FAIL_SESSION_RESET_LIMIT,
+                                            healed,
+                                            errorClass: sessionLayerFailure ? 'session' : 'other',
                                             messageId: node.attrs.id,
                                             timestamp: Date.now()
                                         });

package/lib/Utils/decode-wa-message.d.ts

@@ -2,6 +2,7 @@ import type { SignalRepository, WAMessage } from '../Types/index.js';
 import { type BinaryNode } from '../WABinary/index.js';
 import type { ILogger } from './logger.js';
 export declare const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node";
+export declare const isUnrecoverableSessionError: (text: unknown) => boolean;
 export declare const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled";
 export declare const NACK_REASONS: {
     ParsingError: number;

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

@@ -216,4 +216,15 @@ export const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
         }
     };
 };
+/**
+ * AunuBaileys: true when a decrypt failure text is libsignal's session-layer
+ * aggregate — the stored session record(s) could not decrypt the message at
+ * all ("No matching sessions found for message", "No session record",
+ * "No sessions available"). This class includes the unfillable counter gap
+ * ("Over 2000 messages into the future!") thrown when the stored session
+ * state has regressed behind the sender's ratchet, e.g. after a backup
+ * restore; such a session can never decrypt again and must be reset.
+ */
+export const isUnrecoverableSessionError = (text) => typeof text === 'string' &&
+    /no matching sessions found|no session record|no sessions available/i.test(text);
 //# sourceMappingURL=decode-wa-message.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.45",
+  "version": "1.0.46",
   "description": "AunuBaileys \u2014 a WhatsApp Web API for bots that never sleep. Full upstream power with the beloved in-memory store restored and pairing that just works. Forged by AunuCore.",
   "keywords": [
     "whatsapp",