baileys-antiban 1.3.0 → 1.4.0

package/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.4.0] - 2026-04-18
+
+### Added
+- **Transport-agnostic support** — works with both `baileys` and `@oxidezap/baileyrs` (Rust/WASM WhatsApp library)
+- Both transports now listed as optional peer dependencies
+- GitHub Actions CI workflow with dual-transport matrix testing (Node 18.x + 20.x × baileys + baileyrs)
+- New test suite: `tests/transport-agnostic.test.ts` for duck-typed socket validation
+- Updated JSDoc examples showing usage with both transports
+
+### Changed
+- `peerDependencies` now includes both `baileys` and `@oxidezap/baileyrs` as optional
+- Package description updated to mention transport-agnostic support
+- Wrapper comments clarify baileyrs timelock behavior (no `reachoutTimeLock` events in v0.0.8 — operates in detection-only mode)
+
+### Why
+Positions baileys-antiban as "Switzerland" of WhatsApp anti-ban — works with any Baileys-compatible transport layer. No breaking changes for existing baileys users.
+
+## [1.3.1] - 2026-04-16
+
+### Changed
+- Refactor wrapper to use Baileys' `ev.process()` API — single batched event handler reduces listener leaks and cleans up the integration surface
+- Graceful fallback to `ev.on()` for older Baileys versions
+
+### Why
+Scattered `ev.on()` registrations are a known leak vector. Consolidating into `process()` shrinks the attack surface for listener-lifecycle bugs and future-proofs for backend-agnostic support.
+
 ## [1.3.0] - 2026-04-16
 
 ### Added

package/README.md

@@ -4,7 +4,7 @@
 [![Node.js Version](https://img.shields.io/node/v/baileys-antiban.svg)](https://nodejs.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Anti-ban middleware for [Baileys](https://github.com/WhiskeySockets/Baileys) — protect your WhatsApp number with human-like messaging patterns.
+**Transport-agnostic** anti-ban middleware — protect your WhatsApp number with human-like messaging patterns. Works with both [Baileys](https://github.com/WhiskeySockets/Baileys) and [@oxidezap/baileyrs](https://github.com/oxidezap/baileyrs) (Rust/WASM).
 
 ## v1.3 New Features
 
@@ -93,20 +93,43 @@ WhatsApp bans numbers that behave like bots. This library makes your Baileys bot
 - **Contact graph enforcement** (v1.3) — requires handshakes before bulk/group sends
 - **Circadian rhythm** (v1.3) — realistic time-of-day activity patterns
 
+## Supported Transports
+
+**v1.4+** is transport-agnostic and works with any Baileys-compatible WhatsApp library:
+
+- **[Baileys](https://github.com/WhiskeySockets/Baileys)** (Node.js, JavaScript/TypeScript)
+- **[@oxidezap/baileyrs](https://github.com/oxidezap/baileyrs)** (Rust/WASM, Baileys-compatible API)
+
+Both use the same `wrapSocket()` integration. Zero code changes needed.
+
 ## Installation
 
+### With Baileys (Node.js)
+
 ```bash
-npm install baileys-antiban
+npm install baileys baileys-antiban
 ```
 
-Requires Node.js ≥16 and Baileys ≥6.0.0.
+### With baileyrs (Rust/WASM)
+
+```bash
+npm install @oxidezap/baileyrs baileys-antiban
+```
+
+Requires Node.js ≥16.
 
 ## Quick Start
 
 ### Option 1: Wrap Your Socket (Easiest)
 
+Works with both baileys and baileyrs — same code:
+
 ```typescript
+// With baileys:
 import makeWASocket from 'baileys';
+// OR with baileyrs:
+// import { makeWASocket } from '@oxidezap/baileyrs';
+
 import { wrapSocket } from 'baileys-antiban';
 
 const sock = makeWASocket({ /* your config */ });

package/dist/wrapper.d.ts

@@ -1,18 +1,31 @@
 /**
  * Socket Wrapper — Drop-in replacement that wraps sendMessage with anti-ban protection
  *
- * Usage:
+ * Works with both baileys and @oxidezap/baileyrs transports.
+ *
+ * Usage with baileys:
  *   import makeWASocket from 'baileys';
  *   import { wrapSocket } from 'baileys-antiban';
  *
  *   const sock = makeWASocket({ ... });
  *   const safeSock = wrapSocket(sock);
  *
+ * Usage with baileyrs:
+ *   import { makeWASocket } from '@oxidezap/baileyrs';
+ *   import { wrapSocket } from 'baileys-antiban';
+ *
+ *   const sock = makeWASocket({ ... });
+ *   const safeSock = wrapSocket(sock);
+ *
  *   // Use safeSock.sendMessage() — automatically rate-limited and monitored
  *   await safeSock.sendMessage(jid, { text: 'Hello!' });
  *
  *   // Check health anytime
  *   console.log(safeSock.antiban.getStats());
+ *
+ * Note: reachoutTimeLock timelock module silently noops on baileyrs until upstream
+ * emits reachoutTimeLock events — confirmed NOT present in baileyrs v0.0.8.
+ * Timelock guard will operate in detection-only mode (relies on 463 errors only).
  */
 import { AntiBan, type AntiBanConfig } from './antiban.js';
 import type { WarmUpState } from './warmup.js';

package/dist/wrapper.js

@@ -1,18 +1,31 @@
 /**
  * Socket Wrapper — Drop-in replacement that wraps sendMessage with anti-ban protection
  *
- * Usage:
+ * Works with both baileys and @oxidezap/baileyrs transports.
+ *
+ * Usage with baileys:
  *   import makeWASocket from 'baileys';
  *   import { wrapSocket } from 'baileys-antiban';
  *
  *   const sock = makeWASocket({ ... });
  *   const safeSock = wrapSocket(sock);
  *
+ * Usage with baileyrs:
+ *   import { makeWASocket } from '@oxidezap/baileyrs';
+ *   import { wrapSocket } from 'baileys-antiban';
+ *
+ *   const sock = makeWASocket({ ... });
+ *   const safeSock = wrapSocket(sock);
+ *
  *   // Use safeSock.sendMessage() — automatically rate-limited and monitored
  *   await safeSock.sendMessage(jid, { text: 'Hello!' });
  *
  *   // Check health anytime
  *   console.log(safeSock.antiban.getStats());
+ *
+ * Note: reachoutTimeLock timelock module silently noops on baileyrs until upstream
+ * emits reachoutTimeLock events — confirmed NOT present in baileyrs v0.0.8.
+ * Timelock guard will operate in detection-only mode (relies on 463 errors only).
  */
 import { AntiBan } from './antiban.js';
 /**
@@ -25,71 +38,148 @@ export function wrapSocket(sock, config, warmUpState, wrapOptions) {
         autoRespondToIncoming: false,
         ...wrapOptions,
     };
-    // Hook into connection events for health monitoring
-    sock.ev.on('connection.update', (update) => {
-        if (update.connection === 'close') {
-            const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
-            antiban.onDisconnect(reason);
-            antiban.destroy(); // Clean up all timers
-        }
-        if (update.connection === 'open') {
-            antiban.onReconnect();
-        }
-        // Reachout timelock detection
-        if (update.reachoutTimeLock) {
-            antiban.timelock.onTimelockUpdate({
-                isActive: update.reachoutTimeLock.isActive,
-                timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
-                enforcementType: update.reachoutTimeLock.enforcementType,
-            });
-        }
-    });
-    // Catch 463 errors from message updates
-    sock.ev.on('messages.update', (updates) => {
-        for (const update of updates) {
-            if (update?.update?.messageStubParameters) {
-                const params = update.update.messageStubParameters;
-                if (params.includes(463) || params.includes('463')) {
-                    antiban.timelock.record463Error();
+    // Hook into Baileys events for health monitoring
+    // Prefer ev.process() (Baileys ≥ late 2022) for batched event handling
+    // Fall back to ev.on() for older versions
+    if (typeof sock.ev.process === 'function') {
+        sock.ev.process(async (events) => {
+            // Handle connection updates
+            if (events['connection.update']) {
+                const update = events['connection.update'];
+                if (update.connection === 'close') {
+                    const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
+                    antiban.onDisconnect(reason);
+                    antiban.destroy(); // Clean up all timers
+                }
+                if (update.connection === 'open') {
+                    antiban.onReconnect();
+                }
+                // Reachout timelock detection
+                if (update.reachoutTimeLock) {
+                    antiban.timelock.onTimelockUpdate({
+                        isActive: update.reachoutTimeLock.isActive,
+                        timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
+                        enforcementType: update.reachoutTimeLock.enforcementType,
+                    });
                 }
             }
-        }
-    });
-    // Register known chats from incoming messages + handle reply suggestions
-    sock.ev.on('messages.upsert', ({ messages }) => {
-        for (const msg of messages || []) {
-            const jid = msg.key?.remoteJid;
-            if (!jid)
-                continue;
-            // Register known chat
-            antiban.timelock.registerKnownChat(jid);
-            // Skip self messages
-            const isSelf = msg.key?.fromMe || false;
-            if (isSelf)
-                continue;
-            // Extract message text
-            const msgText = msg.message?.conversation ||
-                msg.message?.extendedTextMessage?.text ||
-                msg.message?.imageMessage?.caption ||
-                msg.message?.videoMessage?.caption ||
-                '';
-            // Handle incoming message (updates reply ratio + contact graph)
-            const replySuggestion = antiban.onIncomingMessage(jid, msgText);
-            // Auto-respond if enabled and suggested
-            if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
-                // Random delay 3-15s
-                const replyDelay = Math.floor(Math.random() * 12000) + 3000;
-                setTimeout(async () => {
-                    try {
-                        await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+            // Catch 463 errors from message updates
+            if (events['messages.update']) {
+                const updates = events['messages.update'];
+                for (const update of updates) {
+                    if (update?.update?.messageStubParameters) {
+                        const params = update.update.messageStubParameters;
+                        if (params.includes(463) || params.includes('463')) {
+                            antiban.timelock.record463Error();
+                        }
                     }
-                    catch (error) {
-                        // Silently fail — auto-reply is best-effort
+                }
+            }
+            // Register known chats from incoming messages + handle reply suggestions
+            if (events['messages.upsert']) {
+                const { messages } = events['messages.upsert'];
+                for (const msg of messages || []) {
+                    const jid = msg.key?.remoteJid;
+                    if (!jid)
+                        continue;
+                    // Register known chat
+                    antiban.timelock.registerKnownChat(jid);
+                    // Skip self messages
+                    const isSelf = msg.key?.fromMe || false;
+                    if (isSelf)
+                        continue;
+                    // Extract message text
+                    const msgText = msg.message?.conversation ||
+                        msg.message?.extendedTextMessage?.text ||
+                        msg.message?.imageMessage?.caption ||
+                        msg.message?.videoMessage?.caption ||
+                        '';
+                    // Handle incoming message (updates reply ratio + contact graph)
+                    const replySuggestion = antiban.onIncomingMessage(jid, msgText);
+                    // Auto-respond if enabled and suggested
+                    if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
+                        // Random delay 3-15s
+                        const replyDelay = Math.floor(Math.random() * 12000) + 3000;
+                        setTimeout(async () => {
+                            try {
+                                await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+                            }
+                            catch (error) {
+                                // Silently fail — auto-reply is best-effort
+                            }
+                        }, replyDelay);
                     }
-                }, replyDelay);
+                }
             }
-        }
-    });
+        });
+    }
+    else {
+        // Fallback to ev.on() for older Baileys versions
+        sock.ev.on('connection.update', (update) => {
+            if (update.connection === 'close') {
+                const reason = update.lastDisconnect?.error?.output?.statusCode || 'unknown';
+                antiban.onDisconnect(reason);
+                antiban.destroy(); // Clean up all timers
+            }
+            if (update.connection === 'open') {
+                antiban.onReconnect();
+            }
+            // Reachout timelock detection
+            if (update.reachoutTimeLock) {
+                antiban.timelock.onTimelockUpdate({
+                    isActive: update.reachoutTimeLock.isActive,
+                    timeEnforcementEnds: update.reachoutTimeLock.timeEnforcementEnds,
+                    enforcementType: update.reachoutTimeLock.enforcementType,
+                });
+            }
+        });
+        // Catch 463 errors from message updates
+        sock.ev.on('messages.update', (updates) => {
+            for (const update of updates) {
+                if (update?.update?.messageStubParameters) {
+                    const params = update.update.messageStubParameters;
+                    if (params.includes(463) || params.includes('463')) {
+                        antiban.timelock.record463Error();
+                    }
+                }
+            }
+        });
+        // Register known chats from incoming messages + handle reply suggestions
+        sock.ev.on('messages.upsert', ({ messages }) => {
+            for (const msg of messages || []) {
+                const jid = msg.key?.remoteJid;
+                if (!jid)
+                    continue;
+                // Register known chat
+                antiban.timelock.registerKnownChat(jid);
+                // Skip self messages
+                const isSelf = msg.key?.fromMe || false;
+                if (isSelf)
+                    continue;
+                // Extract message text
+                const msgText = msg.message?.conversation ||
+                    msg.message?.extendedTextMessage?.text ||
+                    msg.message?.imageMessage?.caption ||
+                    msg.message?.videoMessage?.caption ||
+                    '';
+                // Handle incoming message (updates reply ratio + contact graph)
+                const replySuggestion = antiban.onIncomingMessage(jid, msgText);
+                // Auto-respond if enabled and suggested
+                if (options.autoRespondToIncoming && replySuggestion.shouldReply && replySuggestion.suggestedText) {
+                    // Random delay 3-15s
+                    const replyDelay = Math.floor(Math.random() * 12000) + 3000;
+                    setTimeout(async () => {
+                        try {
+                            await sock.sendMessage(jid, { text: replySuggestion.suggestedText });
+                        }
+                        catch (error) {
+                            // Silently fail — auto-reply is best-effort
+                        }
+                    }, replyDelay);
+                }
+            }
+        });
+    }
     // Create proxy that intercepts sendMessage
     const originalSendMessage = sock.sendMessage.bind(sock);
     const wrappedSendMessage = async (jid, content, options) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "baileys-antiban",
-  "version": "1.3.0",
-  "description": "Anti-ban middleware for Baileys — human-like messaging patterns to protect your WhatsApp number",
+  "version": "1.4.0",
+  "description": "Transport-agnostic anti-ban middleware for Baileys and baileyrs — human-like messaging patterns to protect your WhatsApp number",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -29,6 +29,7 @@
   },
   "keywords": [
     "baileys",
+    "baileyrs",
     "whatsapp",
     "anti-ban",
     "rate-limit",
@@ -36,7 +37,8 @@
     "whatsapp-bot",
     "bot-protection",
     "whatsapp-api",
-    "nodejs"
+    "nodejs",
+    "transport-agnostic"
   ],
   "author": "Kobus Wentzel <kobie@pop.co.za>",
   "license": "MIT",
@@ -49,13 +51,22 @@
   },
   "homepage": "https://github.com/kobie3717/baileys-antiban#readme",
   "peerDependencies": {
+    "@oxidezap/baileyrs": ">=0.0.8",
     "baileys": ">=6.0.0"
   },
+  "peerDependenciesMeta": {
+    "baileys": {
+      "optional": true
+    },
+    "@oxidezap/baileyrs": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/node": "^20.0.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.4.6",
+    "ts-jest": "^29.4.9",
     "tsx": "^4.21.0",
     "typescript": "^5.0.0"
   }