baileys-antiban 3.8.1 → 3.8.2

package/dist/messageRecovery.js

@@ -152,12 +152,20 @@ export function messageRecovery(sock, config) {
         }
         for (const [jid, lastSeenEntry] of chatsToRecover) {
             try {
-                // Fetch messages newer than lastSeen timestamp
-                // fetchMessageHistory typically: (jid, count, cursor) => Promise<messages[]>
-                // We'll fetch up to 50 messages and filter by timestamp
-                const messages = await sock.fetchMessageHistory(jid, 50, {
-                    before: undefined, // Get latest
-                });
+                // Fetch messages newer than lastSeen timestamp.
+                // Baileys v7 may have changed this signature — fall back gracefully on any error.
+                let messages;
+                try {
+                    const result = await sock.fetchMessageHistory(jid, 50, { before: undefined });
+                    messages = Array.isArray(result) ? result : [];
+                }
+                catch {
+                    if (!loggedFetchWarning) {
+                        logger.warn?.(`[messageRecovery] sock.fetchMessageHistory failed — signature may have changed in this Baileys version. Recovery skipped for this reconnect.`);
+                        loggedFetchWarning = true;
+                    }
+                    continue;
+                }
                 if (!messages || !Array.isArray(messages))
                     continue;
                 // Filter to messages newer than lastSeen

package/dist/retryTracker.d.ts

@@ -54,6 +54,7 @@ export declare class RetryReasonTracker {
             id?: string;
         };
         status?: number;
+        update?: any;
         error?: any;
     }): void;
     /**

package/dist/retryTracker.js

@@ -61,10 +61,11 @@ export class RetryReasonTracker {
         const msgId = update.key?.id;
         if (!msgId)
             return;
-        // Only track error statuses
+        // Only track error statuses (status 0 = error in Baileys WAMessageStatus)
         if (update.status !== 0 && !update.error)
             return;
-        const reason = this.classify(update.error || update);
+        // rc10 may surface error info in update.update (wrapped message); check all forms
+        const reason = this.classify(update.error || update.update || update);
         this.recordRetry(msgId, reason);
     }
     /**

package/dist/wrapper.js

@@ -69,7 +69,9 @@ export function wrapSocket(sock, config, warmUpState, wrapOptions) {
                 for (const update of updates) {
                     // 463 error detection
                     if (update?.update?.messageStubParameters) {
-                        const params = update.update.messageStubParameters;
+                        const params = Array.isArray(update.update.messageStubParameters)
+                            ? update.update.messageStubParameters
+                            : [];
                         if (params.includes(463) || params.includes('463')) {
                             antiban.timelock.record463Error();
                         }
@@ -197,6 +199,10 @@ export function wrapSocket(sock, config, warmUpState, wrapOptions) {
     }
     // Create proxy that intercepts sendMessage
     const originalSendMessage = sock.sendMessage.bind(sock);
+    // Serializes beforeSend→afterSend so rate limiter accounting is accurate
+    // under concurrent sends. Without this, all concurrent callers read the same
+    // committed state before any afterSend records, bypassing per-minute limits.
+    let sendLock = Promise.resolve();
     const wrappedSendMessage = async (jid, content, options) => {
         /**
          * LID/PN Canonicalization — Normalize JID to canonical form
@@ -211,29 +217,36 @@ export function wrapSocket(sock, config, warmUpState, wrapOptions) {
         const canonicalJid = antiban.jidCanonicalizer?.canonicalizeTarget(jid) || jid;
         // Extract text content for rate limiter analysis
         const text = content?.text || content?.caption || content?.image?.caption || '';
-        const decision = await antiban.beforeSend(canonicalJid, text);
-        if (!decision.allowed) {
-            throw new Error(`[baileys-antiban] Message blocked: ${decision.reason}`);
-        }
-        // Apply delay
-        if (decision.delayMs > 0) {
-            await new Promise(resolve => setTimeout(resolve, decision.delayMs));
-        }
-        // Send message (using canonical JID)
-        try {
-            const result = await originalSendMessage(canonicalJid, content, options);
-            antiban.afterSend(canonicalJid, text);
-            antiban.timelock.registerKnownChat(canonicalJid);
-            // Clear retry tracking on successful send
-            if (result?.key?.id) {
-                antiban.retryTracker.clear(result.key.id);
+        // Chain this send onto the previous — each waits for the prior send's
+        // afterSend to commit before running its own beforeSend check.
+        const sendResult = sendLock.then(async () => {
+            const decision = await antiban.beforeSend(canonicalJid, text);
+            if (!decision.allowed) {
+                throw new Error(`[baileys-antiban] Message blocked: ${decision.reason}`);
             }
-            return result;
-        }
-        catch (error) {
-            antiban.afterSendFailed(error instanceof Error ? error.message : String(error));
-            throw error;
-        }
+            // Apply delay
+            if (decision.delayMs > 0) {
+                await new Promise(resolve => setTimeout(resolve, decision.delayMs));
+            }
+            // Send message (using canonical JID)
+            try {
+                const result = await originalSendMessage(canonicalJid, content, options);
+                antiban.afterSend(canonicalJid, text);
+                antiban.timelock.registerKnownChat(canonicalJid);
+                // Clear retry tracking on successful send
+                if (result?.key?.id) {
+                    antiban.retryTracker.clear(result.key.id);
+                }
+                return result;
+            }
+            catch (error) {
+                antiban.afterSendFailed(error instanceof Error ? error.message : String(error));
+                throw error;
+            }
+        });
+        // Advance the lock regardless of success/failure so the chain never stalls
+        sendLock = sendResult.then(() => { }, () => { });
+        return sendResult;
     };
     // Return enhanced socket
     const wrapped = Object.create(sock);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baileys-antiban",
-  "version": "3.8.1",
+  "version": "3.8.2",
   "description": "Anti-ban middleware for Baileys WhatsApp bots. Rate limiting, warmup, health monitor, LID resolver, disconnect classifier. Free Whapi.Cloud alternative.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -90,6 +90,7 @@
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/node": "^20.0.0",
+    "baileys": "github:WhiskeySockets/Baileys#dfad98f815feb771cc561f32707a00c6e085b1f1",
     "jest": "^29.7.0",
     "ts-jest": "^29.4.9",
     "tsx": "^4.21.0",