aunubaileys 1.0.26 → 1.0.28

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.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.
+
 ### 🆕 What's new in 1.0.26 / Baru di 1.0.26
 
 - 📡 **`fetchLatestBaileysVersion` now remembers the last-good fetched version** — it is called on every reconnect and used to hit the network every time; a mid-session fetch failure silently downgraded to the bundled version, even though the endpoint value is the only server-accepted truth (see 1.0.13). Successful fetches are now cached for 10 minutes, and a later failure returns the last fetched version instead of the bundled one. New `forceRefresh` / `cacheTtlMs` options.

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) {

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/lib/Utils/antiban.d.ts

@@ -7,6 +7,9 @@ export declare class RateLimiter {
 }
 export interface DisconnectClassification { category: string; action: 'stop' | 'restart' | 'reconnect' | 'backoff'; detail: string; }
 export declare const classifyDisconnect: (error: unknown) => DisconnectClassification;
+export interface ReconnectDelayOptions { baseDelayMs?: number; maxDelayMs?: number; }
+/** Suggested reconnect delay in ms for a disconnect reason (error, status code, or a classifyDisconnect result); null when the connection must NOT be re-established automatically. */
+export declare const getReconnectDelay: (attempt: number, reason: unknown, options?: ReconnectDelayOptions) => number | null;
 export interface AunuAntiBanOptions {
     perChatPerMinute?: number; globalPerMinute?: number; minDelayMs?: number; jitterMs?: number;
     warmupDays?: number; warmupStart?: number; typingSimulation?: boolean;

package/lib/Utils/antiban.js

@@ -166,5 +166,40 @@ export class AunuAntiBan {
     }
 }
 
+/**
+ * Jeda reconnect yang disarankan, pendamping classifyDisconnect.
+ * Mengembalikan milidetik untuk menunggu sebelum reconnect, atau null
+ * bila koneksi TIDAK boleh disambung ulang otomatis (sesi logout,
+ * digantikan, rusak, atau 403). `reason` boleh berupa error Boom,
+ * kode status numerik, atau hasil classifyDisconnect ({ action } /
+ * { category }). Backoff eksponensial + jitter Gaussian; kategori
+ * rate_limited memakai basis dan plafon jauh lebih besar karena
+ * reconnect terlalu cepat pada 429 memperburuk pembatasan.
+ */
+export const getReconnectDelay = (attempt, reason, options = {}) => {
+    const a = Math.max(0, Math.floor(+attempt) || 0);
+    let action;
+    if (reason && typeof reason === 'object' && typeof reason.action === 'string') {
+        action = reason.action;
+    }
+    else if (reason && typeof reason === 'object' && typeof reason.category === 'string') {
+        action = { logged_out: 'stop', replaced: 'stop', bad_session: 'stop', mismatch: 'stop', forbidden: 'stop', restart_required: 'restart', rate_limited: 'backoff', transient: 'reconnect' }[reason.category] ?? 'reconnect';
+    }
+    else {
+        action = classifyDisconnect(reason).action;
+    }
+    if (action === 'stop') {
+        return null;
+    }
+    if (action === 'restart') {
+        return 0;
+    }
+    const isRateLimited = action === 'backoff';
+    const base = options.baseDelayMs ?? (isRateLimited ? 30000 : 1000);
+    const cap = options.maxDelayMs ?? (isRateLimited ? 900000 : 60000);
+    const grown = Math.min(cap, base * 2 ** a);
+    return Math.round(grown + gaussianJitter(0, grown * 0.1));
+};
+
 /** Bungkus socket dengan AunuAntiBan (jalan pintas). */
 export const wrapAntiBan = (sock, options) => new AunuAntiBan(options).wrap(sock);

package/package.json

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