aunubaileys 1.0.25 → 1.0.27

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.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.
+
 ### 🆕 What's new in 1.0.25 / Baru di 1.0.25
 
 - 🪪 **DM receipt status no longer gets stuck on LID addressing** — receipts increasingly arrive addressed to the peer's LID while consumers keyed the sent message by its phone-number JID (or the reverse), so the status update never matched and the message looked forever "sent". When the LID store knows the pair, DM `messages.update` events now carry the alternate form as `key.remoteJidAlt` (purely additive; `remoteJid` unchanged). Under the hood the LID store is now created once in the base socket layer, so the single instance the public `sock.aunuLid` learns into is the same one inner layers read — and the store gains a `getAltJid(jid)` helper.

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/lib/Utils/generics.js

@@ -188,13 +188,31 @@ export const bindWaitForConnectionUpdate = (ev) => bindWaitForEvent(ev, 'connect
  * utility that fetches latest baileys version from the master branch.
  * Use to ensure your WA connection is always on the latest version
  */
+// AunuBaileys: last-good cache for the fetched WA version. The endpoint's
+// value is the server-accepted truth (a bundled version can be a rejected
+// beta build — see 1.0.13), so once a fetch succeeds in this process, a
+// later network failure must fall back to that fetched value, not silently
+// downgrade to the bundled one. Repeated calls within the TTL also skip
+// the network entirely; consumers typically call this on every reconnect.
+const BAILEYS_VERSION_CACHE_TTL_MS = 10 * 60 * 1000;
+let lastGoodBaileysVersion = null;
+let lastGoodBaileysVersionAt = 0;
 export const fetchLatestBaileysVersion = async (options = {}) => {
     const URL = 'https://raw.githubusercontent.com/WhiskeySockets/Baileys/master/src/Defaults/baileys-version.json';
+    const { cacheTtlMs = BAILEYS_VERSION_CACHE_TTL_MS, forceRefresh = false, ...axiosOptions } = options;
+    if (!forceRefresh && lastGoodBaileysVersion && (Date.now() - lastGoodBaileysVersionAt) < cacheTtlMs) {
+        return {
+            version: lastGoodBaileysVersion,
+            isLatest: true
+        };
+    }
     try {
         const result = await axios.get(URL, {
-            ...options,
+            ...axiosOptions,
             responseType: 'json'
         });
+        lastGoodBaileysVersion = result.data.version;
+        lastGoodBaileysVersionAt = Date.now();
         return {
             version: result.data.version,
             isLatest: true
@@ -202,7 +220,7 @@ export const fetchLatestBaileysVersion = async (options = {}) => {
     }
     catch (error) {
         return {
-            version: baileysVersion,
+            version: lastGoodBaileysVersion ?? baileysVersion,
             isLatest: false,
             error
         };

package/package.json

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