aunubaileys 1.0.27 → 1.0.29

package/README.md

@@ -64,6 +64,14 @@ Everything else is pure upstream. When upstream moves, we rebase the patch layer
 
 
 
+### 🆕 What's new in 1.0.29 / Baru di 1.0.29
+
+- 🧹 **Resend counters are now cleared when the retry limit is reached** — every message a peer asked us to resend left a permanent counter entry in the retry cache, removed only by the cache TTL (1h on the default cache — nothing at all on a consumer store without TTL), so entries accumulated without bound in a long-lived bot. The entry is now deleted when its count hits the limit, exactly like `sendRetryRequest` already does on the decrypt-retry path.
+
+### 🆕 What's new in 1.0.28 / Baru di 1.0.28
+
+- 📱 **Device lists no longer go stale after a device is linked or unlinked** — the server pushes a `devices` notification on such changes, but upstream only logged its own list and ignored everyone else's, so sends kept encrypting for the cached device set until the 5-minute TTL expired: a newly linked device received nothing and a removed device kept getting ciphertext. The notification now invalidates that user's cached entry, so the next send re-queries USync for the fresh list. The cache is also exposed as `sock.userDevicesCache` for explicit invalidation.
+
 ### 🆕 What's new in 1.0.27 / Baru di 1.0.27
 
 - ⏱️ **New `getReconnectDelay(attempt, reason)` helper** — the companion to AunuAntiBan's `classifyDisconnect`: it turns a disconnect reason (Boom error, status code, or a classification result) into a suggested wait in milliseconds, or `null` when the connection must NOT be re-established automatically (logged out, replaced, bad session, 403). Server-requested restarts return 0; transient failures back off exponentially with Gaussian jitter (1s base, 60s cap); rate limits back off much longer (30s base, 15 min cap). `baseDelayMs` / `maxDelayMs` overrides available.

package/lib/Socket/messages-recv.js

@@ -14,7 +14,7 @@ import { makeMessagesSocket } from './messages-send.js';
 export const makeMessagesRecvSocket = (config) => {
     const { logger, retryRequestDelayMs, maxMsgRetryCount, getMessage, shouldIgnoreJid } = config;
     const sock = makeMessagesSocket(config);
-    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage } = sock;
+    const { ev, authState, ws, processingMutex, signalRepository, query, upsertMessage, resyncAppState, onUnexpectedError, assertSessions, sendNode, relayMessage, sendReceipt, uploadPreKeys, sendPeerDataOperationMessage, userDevicesCache } = sock;
     /** AunuBaileys: consecutive decrypt failures per signal address.
      * WhatsApp clients heal a rotten (Bad MAC) session by dropping it and
      * letting the peer re-initiate from the key bundle in our retry receipt;
@@ -331,13 +331,27 @@ export const makeMessagesRecvSocket = (config) => {
             case 'encrypt':
                 await handleEncryptNotification(node);
                 break;
-            case 'devices':
+            case 'devices': {
                 const devices = getBinaryNodeChildren(child, 'device');
                 if (areJidsSameUser(child.attrs.jid, authState.creds.me.id)) {
                     const deviceJids = devices.map(d => d.attrs.jid);
                     logger.info({ deviceJids }, 'got my own devices');
                 }
+                // AunuBaileys: this notification means a device list
+                // CHANGED (device linked or unlinked). Upstream logged
+                // its own list and ignored everyone else's, so the send
+                // path kept encrypting for the cached device set until
+                // the cache TTL (5 min) expired — a newly linked device
+                // received nothing meanwhile and a removed device kept
+                // getting ciphertext. Drop the cached entry so the next
+                // send re-queries USync for the fresh list.
+                const changedUser = jidDecode(child.attrs.jid)?.user;
+                if (changedUser) {
+                    userDevicesCache?.del(changedUser);
+                    logger.debug({ changedUser }, 'aunu: device cache invalidated on devices notification');
+                }
                 break;
+            }
             case 'server_sync':
                 const update = getBinaryNodeChild(node, 'collection');
                 if (update) {
@@ -479,7 +493,19 @@ export const makeMessagesRecvSocket = (config) => {
     const updateSendMessageAgainCount = (id, participant) => {
         const key = `${id}:${participant}`;
         const newValue = (msgRetryCache.get(key) || 0) + 1;
-        msgRetryCache.set(key, newValue);
+        // AunuBaileys: clear the entry when the limit is reached, exactly
+        // like sendRetryRequest already does on its path. This path never
+        // deleted anything, so every message a peer ever asked us to
+        // resend left a permanent counter entry that only the cache TTL
+        // (1h on the default cache — and nothing at all on a consumer
+        // store without TTL) ever removed: unbounded growth in a
+        // long-lived bot process.
+        if (newValue >= maxMsgRetryCount) {
+            msgRetryCache.del(key);
+        }
+        else {
+            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).get(key.remoteJid, id)));

package/lib/Socket/messages-send.js

@@ -616,6 +616,11 @@ export const makeMessagesSocket = (config) => {
         sendPeerDataOperationMessage,
         createParticipantNodes,
         getUSyncDevices,
+        // AunuBaileys: exposed so the notification layer can invalidate a
+        // user's entry when the server pushes a device-list change
+        // (upstream kept the cache private to this closure, so nothing
+        // could ever invalidate it before its TTL expired).
+        userDevicesCache,
         updateMediaMessage: async (message) => {
             const content = assertMediaContent(message.message);
             const mediaKey = content.mediaKey;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aunubaileys",
   "type": "module",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "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",