baileys-antiban 3.8.6 → 3.8.7

package/CHANGELOG.md

@@ -5,6 +5,31 @@ 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).
 
+## [3.8.7] - 2026-05-14
+
+### Added
+- **`baileys-antiban patch` CLI command** — for frameworks that create the Baileys socket internally (OpenClaw `@openclaw/whatsapp`, custom ESM loaders) and don't expose a `socket:ready` hook. Automatically locates the Baileys install, detects CJS vs ESM output format, backs up the original file, and injects a `wrapSocket()` call around `makeWASocket`. Idempotent — safe to re-run after plugin updates. Pairs with a `postinstall` npm script for zero-maintenance re-patching.
+  - Auto-discovers Baileys in `node_modules/@openclaw/whatsapp/node_modules/baileys`, `node_modules/baileys`, `node_modules/@whiskeysockets/baileys`, and parent directories.
+  - `--path <dir>` — explicit Baileys directory override.
+  - `--preset conservative|moderate|aggressive` — antiban profile (default: `conservative`).
+  - `--min-delay` / `--max-delay` — override delay range in ms (default 1500–4000).
+  - `--no-typing` — disable typing indicators.
+  - `--dry-run` — preview without writing files.
+  - `--force` — re-patch even if already patched.
+  - Runtime config via env: `ANTIBAN_PRESET`, `ANTIBAN_MIN_DELAY`, `ANTIBAN_MAX_DELAY`, `ANTIBAN_TYPING`.
+- **`baileys-antiban unpatch` CLI command** — restores a patched file from its `.antiban-backup` or strips the patch block in-place if backup is missing.
+
+## [3.8.6] - 2026-05-14
+
+### Fixed
+- **CJS build for NestJS / CommonJS consumers.** Adds `dist/cjs/` output compiled with `module: CommonJS`, a `{"type":"commonjs"}` package marker injected at build time, and an `exports["require"]` condition so `require('baileys-antiban')` now resolves cleanly. Previously CommonJS callers hit `ERR_PACKAGE_PATH_NOT_EXPORTED` or `ERR_REQUIRE_ESM`.
+- **`messageRecovery` persistence load in ESM context.** `loadPersistence()` previously called `require('fs')` which is not defined in native ESM scope, throwing `ReferenceError` at runtime whenever `persistPath` was configured. Fixed by using static `import { existsSync, readFileSync } from 'node:fs'` at module top level.
+- **`messageRecovery` doc comment.** Placeholder `issues/XXX` issue reference updated to `issues/2491` (deaf-session / silent message loss tracker).
+
+### Changed
+- Removed unused `jest`, `@types/jest`, and `ts-jest` devDependencies (test runner uses `tsx` directly; `vitest` retained as future framework).
+- **Docs: ESM plugin-framework integration.** Added troubleshooting section to README covering `wrapSocket()` as the correct integration point for OpenClaw, custom ESM loaders, and other plugin frameworks that use native ESM. Documents why `Module._load` interception does not work with ESM and how to set up `ev.process` + `ev.on` fallback correctly.
+
 ## [3.8.5] - 2026-05-09
 
 ### Added

package/README.md

@@ -1045,6 +1045,84 @@ const antiban = new AntiBan({
 });
 ```
 
+### Using inside a plugin framework (OpenClaw, custom ESM loaders, etc.)
+
+`baileys-antiban` is a **pure ESM package**. `wrapSocket()` is the correct integration point — it works in any ESM or CJS context without patching Baileys directly.
+
+If your framework (e.g. OpenClaw's WhatsApp plugin) uses native ESM, **do not attempt `Module._load` interception** — it only intercepts CJS modules and silently does nothing for ESM imports.
+
+Correct approach — wrap the socket after it's created, regardless of how it was imported:
+
+```typescript
+import { makeWASocket } from 'baileys';        // or however your framework exposes it
+import { wrapSocket } from 'baileys-antiban';
+
+const rawSock = makeWASocket({ ... });
+const sock = wrapSocket(rawSock);              // drop-in — use sock everywhere
+```
+
+If your framework creates the socket internally and only exposes it via a callback or event, wrap it at that point:
+
+```typescript
+// OpenClaw / plugin pattern
+framework.on('socket', (rawSock) => {
+  const sock = wrapSocket(rawSock);
+  // use sock from here on
+});
+```
+
+**If your framework creates the socket with no event or callback exposed** (common in tightly-integrated plugins), use the `patch` CLI command — see [CLI: patch command](#cli-patch-command) below.
+
+> **Note:** If you install/update the Baileys package or plugin via a package manager, `wrapSocket()` survives the update untouched. Patching Baileys source directly (as a workaround) will be reset by any reinstall — use the `patch` command to automate re-patching.
+
+---
+
+### CLI: patch command
+
+For plugin frameworks where `makeWASocket` is called internally and no socket hook is exposed (e.g. OpenClaw `@openclaw/whatsapp`), the `patch` command modifies the installed Baileys package to inject `wrapSocket()` automatically.
+
+```bash
+# Auto-detect Baileys location + apply patch
+npx baileys-antiban patch
+
+# OpenClaw: Baileys is nested inside the plugin
+npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys
+
+# Custom profile
+npx baileys-antiban patch --preset moderate --min-delay 1000 --max-delay 3000
+
+# Preview without writing (dry run)
+npx baileys-antiban patch --dry-run
+
+# Restore original
+npx baileys-antiban unpatch --file ./node_modules/baileys/lib/socket/index.js
+```
+
+The patch is **idempotent** — re-running it on an already-patched file is a no-op. A `.antiban-backup` file is kept alongside the patched file for safe restoration.
+
+**Auto re-patch after plugin updates** — add a `postinstall` script to your project's `package.json`:
+
+```json
+{
+  "scripts": {
+    "postinstall": "npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys"
+  }
+}
+```
+
+Now every `npm install` / `openclaw plugins install @openclaw/whatsapp` automatically re-applies the patch.
+
+**Runtime config via environment variables** (no re-patch needed to change settings):
+
+| Variable | Default | Description |
+|---|---|---|
+| `ANTIBAN_PRESET` | `conservative` | `conservative`, `moderate`, or `aggressive` |
+| `ANTIBAN_MIN_DELAY` | `1500` | Minimum delay between messages (ms) |
+| `ANTIBAN_MAX_DELAY` | `4000` | Maximum delay between messages (ms) |
+| `ANTIBAN_TYPING` | `true` | Enable typing indicators (`false` to disable) |
+
+---
+
 ### State not persisting across restarts
 
 Use the FileStateAdapter:

package/dist/cjs/cli.js

@@ -41,6 +41,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const persist_js_1 = require("./persist.js");
 const presets_js_1 = require("./presets.js");
+const patch_js_1 = require("./patch.js");
 const args = process.argv.slice(2);
 const command = args[0];
 function parseArgs(argv) {
@@ -127,6 +128,45 @@ function cmdWarmupSimulate(opts) {
     console.log('─'.repeat(50));
     console.log(`Day ${days + 1}+: graduated (unlimited by warmup)\n`);
 }
+function cmdPatch(opts) {
+    const searchPaths = opts['path'] ? [opts['path']] : undefined;
+    const preset = opts['preset'] || 'conservative';
+    const minDelay = opts['min-delay'] ? parseInt(opts['min-delay']) : 1500;
+    const maxDelay = opts['max-delay'] ? parseInt(opts['max-delay']) : 4000;
+    const typingIndicator = opts['no-typing'] ? false : true;
+    const dryRun = !!opts['dry-run'];
+    const force = !!opts['force'];
+    const result = (0, patch_js_1.applyPatch)({
+        baileysPaths: searchPaths,
+        preset,
+        minDelay,
+        maxDelay,
+        typingIndicator,
+        dryRun,
+    });
+    if (result.alreadyPatched && !force) {
+        console.log(result.message);
+        process.exit(0);
+    }
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
+function cmdUnpatch(opts) {
+    const targetFile = opts['file'];
+    if (!targetFile) {
+        console.error('Usage: npx baileys-antiban unpatch --file <path-to-patched-file>');
+        process.exit(1);
+    }
+    const result = (0, patch_js_1.unpatchFile)(targetFile);
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
 // Main
 const opts = parseArgs(args);
 switch (command) {
@@ -145,6 +185,12 @@ switch (command) {
             process.exit(1);
         }
         break;
+    case 'patch':
+        cmdPatch(opts);
+        break;
+    case 'unpatch':
+        cmdUnpatch(opts);
+        break;
     default:
         console.log('baileys-antiban v3.0');
         console.log('');
@@ -152,9 +198,15 @@ switch (command) {
         console.log('  status [--state <path>] [--json]     Show warmup and health status');
         console.log('  reset --state <path>                  Delete state file');
         console.log('  warmup --simulate <days> [--preset]  Show warmup schedule');
+        console.log('  patch [--path <baileys-dir>] [--preset] [--min-delay] [--max-delay] [--no-typing] [--dry-run]');
+        console.log('  unpatch --file <patched-file>         Restore file from backup');
         console.log('');
         console.log('Examples:');
         console.log('  npx baileys-antiban status --state ./antiban-state.json');
         console.log('  npx baileys-antiban warmup --simulate 7 --preset moderate');
         console.log('  npx baileys-antiban reset --state ./antiban-state.json');
+        console.log('  npx baileys-antiban patch');
+        console.log('  npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys');
+        console.log('  npx baileys-antiban patch --preset moderate --min-delay 1000 --max-delay 3000');
+        console.log('  npx baileys-antiban unpatch --file ./node_modules/baileys/lib/socket/index.js');
 }

package/dist/cjs/messageRecovery.js

@@ -1,20 +1,4 @@
 "use strict";
-/**
- * Message Recovery — Solves Baileys' silent message loss on 408 reconnect
- *
- * After a 408 disconnect (and other clean reconnect paths), offline messages
- * arrive on the server side but never fire `messages.upsert` events in Baileys.
- * Bots silently lose messages from the disconnect window.
- *
- * This module:
- * 1. Tracks the last message ID seen per chat while connected
- * 2. Detects disconnect/reconnect cycles via connection.update events
- * 3. On reconnect, queries Baileys' message store for messages newer than lastSeen
- * 4. Re-emits gap messages through user callback (wired to messages.upsert handler)
- * 5. Fires onGapTooLarge if disconnect > maxGapMs instead of partial recovery
- *
- * @see https://github.com/WhiskeySockets/Baileys/issues/XXX (47+ upvotes)
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -50,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.messageRecovery = messageRecovery;
+const node_fs_1 = require("node:fs");
 const DEFAULT_CONFIG = {
     maxTrackedChats: 1000,
     maxGapMs: 30 * 60_000, // 30 minutes
@@ -73,7 +58,7 @@ function messageRecovery(sock, config) {
     // Persistence
     let persistTimer = null;
     let loggedFetchWarning = false;
-    // Load persisted state on startup
+    // Load persisted state on startup (synchronous — seeds lastSeen before first event)
     if (cfg.persistPath) {
         loadPersistence();
     }
@@ -281,10 +266,9 @@ function messageRecovery(sock, config) {
         if (!cfg.persistPath)
             return;
         try {
-            const fs = require('fs');
-            if (!fs.existsSync(cfg.persistPath))
+            if (!(0, node_fs_1.existsSync)(cfg.persistPath))
                 return;
-            const raw = fs.readFileSync(cfg.persistPath, 'utf-8');
+            const raw = (0, node_fs_1.readFileSync)(cfg.persistPath, 'utf-8');
             const data = JSON.parse(raw);
             for (const [jid, entry] of Object.entries(data)) {
                 lastSeen.set(jid, {

package/dist/cjs/patch.js

@@ -0,0 +1,339 @@
+"use strict";
+/**
+ * baileys-antiban patch command
+ *
+ * Patches an installed Baileys package to wrap makeWASocket with antiban middleware.
+ * Designed for frameworks (OpenClaw, etc.) that create the socket internally and
+ * don't expose a socket:ready hook.
+ *
+ * Idempotent: safe to re-run after plugin updates. Keeps a .antiban-backup file.
+ *
+ * Usage:
+ *   npx baileys-antiban patch [--path <baileys-dir>] [--dry-run] [--preset conservative|moderate|aggressive]
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPatch = applyPatch;
+exports.unpatchFile = unpatchFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const PATCH_MARKER_START = '// [BAILEYS-ANTIBAN-PATCH-START]';
+const PATCH_MARKER_END = '// [BAILEYS-ANTIBAN-PATCH-END]';
+function findBaileysDir(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const pkgPath = path.join(candidate, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'baileys' || pkg.name === '@whiskeysockets/baileys' || pkg.name === '@oxidezap/baileyrs') {
+                    return path.resolve(candidate);
+                }
+            }
+            catch {
+                // not a valid package.json, skip
+            }
+        }
+    }
+    return null;
+}
+function findMakeWASocketFile(baileyDir) {
+    // Ordered by likelihood of containing the actual makeWASocket definition
+    const candidates = [
+        'lib/socket/index.js',
+        'lib/index.js',
+        'lib/socket.js',
+        'src/socket/index.js',
+        'dist/socket/index.js',
+        'dist/index.js',
+    ];
+    for (const rel of candidates) {
+        const full = path.join(baileyDir, rel);
+        if (!fs.existsSync(full))
+            continue;
+        const source = fs.readFileSync(full, 'utf-8');
+        // Look for makeWASocket being defined (not just re-exported via export *)
+        if (source.includes('function makeWASocket') ||
+            source.includes('const makeWASocket') ||
+            source.includes('exports.makeWASocket') ||
+            source.includes('makeWASocket =')) {
+            const isEsm = source.includes('export function makeWASocket') ||
+                source.includes('export const makeWASocket') ||
+                source.includes('export {') ||
+                source.includes('export default');
+            return { file: full, format: isEsm ? 'esm' : 'cjs' };
+        }
+    }
+    // Fallback: search lib/ directory for the defining file
+    const libDir = path.join(baileyDir, 'lib');
+    if (fs.existsSync(libDir)) {
+        const jsFiles = fs
+            .readdirSync(libDir, { recursive: true })
+            .filter((f) => typeof f === 'string' && f.endsWith('.js'))
+            .map((f) => path.join(libDir, f));
+        for (const full of jsFiles) {
+            try {
+                const source = fs.readFileSync(full, 'utf-8');
+                if (source.includes('function makeWASocket') && source.includes('makeWASocket')) {
+                    const isEsm = source.includes('export');
+                    return { file: full, format: isEsm ? 'esm' : 'cjs' };
+                }
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    return null;
+}
+function buildCjsPatch(opts) {
+    return `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+(function() {
+  try {
+    const { wrapSocket } = require('baileys-antiban');
+    const _orig = module.exports.makeWASocket;
+    if (typeof _orig === 'function') {
+      module.exports.makeWASocket = function(...args) {
+        return wrapSocket(_orig.apply(this, args), {
+          preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+          delayBetweenMessages: {
+            min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+            max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+          },
+          typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+        });
+      };
+    }
+  } catch(e) {
+    console.warn('[baileys-antiban] patch inactive:', e.message);
+  }
+})();
+${PATCH_MARKER_END}
+`;
+}
+function buildEsmPatch(source, opts) {
+    // Strategy A: function declaration — rename and re-export wrapped version
+    if (source.includes('export function makeWASocket')) {
+        const patched = source.replace(/export function makeWASocket\b/, 'function _antiban_makeWASocket_orig');
+        return (patched +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+export const makeWASocket = (...args) => _antibanWrap(_antiban_makeWASocket_orig(...args), {
+  preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+  delayBetweenMessages: {
+    min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+    max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+  },
+  typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+});
+${PATCH_MARKER_END}
+`);
+    }
+    // Strategy B: const/let declaration — rename and re-export
+    if (source.match(/export\s+(const|let)\s+makeWASocket\s*=/)) {
+        const patched = source.replace(/export\s+(const|let)\s+makeWASocket\s*=/, 'const _antiban_makeWASocket_orig =');
+        return (patched +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+export const makeWASocket = (...args) => _antibanWrap(_antiban_makeWASocket_orig(...args), {
+  preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+  delayBetweenMessages: {
+    min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+    max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+  },
+  typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+});
+${PATCH_MARKER_END}
+`);
+    }
+    // Strategy C: named re-export — intercept at this boundary
+    if (source.includes('makeWASocket')) {
+        // Append import + re-export override at end of file
+        return (source +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+// NOTE: Strategy C (named export intercept) — less precise than A/B.
+// If this breaks, use --path to target the file where makeWASocket is defined.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+const _antiban_raw = makeWASocket;
+export { makeWASocket };  // shadowed below if engine supports block-level export rebind
+// Fallback: log advisory if strategy C can't reassign
+if (typeof makeWASocket === 'function') {
+  // eslint-disable-next-line no-global-assign
+  try { makeWASocket = (...a) => _antibanWrap(_antiban_raw(...a), { preset: '${opts.preset}', delayBetweenMessages: { min: ${opts.minDelay}, max: ${opts.maxDelay} }, typingIndicator: ${opts.typing} }); } catch {}
+}
+${PATCH_MARKER_END}
+`);
+    }
+    throw new Error('Could not locate makeWASocket in this file. Try --path to a different Baileys file.');
+}
+function applyPatch(opts) {
+    const { preset = 'conservative', minDelay = 1500, maxDelay = 4000, typingIndicator = true, dryRun = false, } = opts;
+    // 1. Locate Baileys
+    const defaultSearchPaths = [
+        // OC-style nested location
+        './node_modules/@openclaw/whatsapp/node_modules/baileys',
+        './node_modules/@openclaw/whatsapp/node_modules/@whiskeysockets/baileys',
+        // Standard locations
+        './node_modules/baileys',
+        './node_modules/@whiskeysockets/baileys',
+        // Walk up
+        '../node_modules/baileys',
+        '../../node_modules/baileys',
+    ];
+    const searchPaths = opts.baileysPaths?.length ? opts.baileysPaths : defaultSearchPaths;
+    const baileyDir = findBaileysDir(searchPaths);
+    if (!baileyDir) {
+        return {
+            success: false,
+            baileyDir: '(not found)',
+            targetFile: '(not found)',
+            alreadyPatched: false,
+            format: 'cjs',
+            message: 'Could not find Baileys package. Use --path <dir> to specify its location.\n' +
+                'Example: npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys',
+        };
+    }
+    // 2. Find file containing makeWASocket
+    const found = findMakeWASocketFile(baileyDir);
+    if (!found) {
+        return {
+            success: false,
+            baileyDir,
+            targetFile: '(not found)',
+            alreadyPatched: false,
+            format: 'cjs',
+            message: `Found Baileys at ${baileyDir} but could not locate makeWASocket definition.\n` +
+                'The package structure may have changed. Please open an issue.',
+        };
+    }
+    const { file: targetFile, format } = found;
+    const source = fs.readFileSync(targetFile, 'utf-8');
+    // 3. Check idempotency
+    if (source.includes(PATCH_MARKER_START)) {
+        return {
+            success: true,
+            baileyDir,
+            targetFile,
+            alreadyPatched: true,
+            format,
+            message: `Already patched: ${targetFile}\nRe-run with --force to re-apply.`,
+        };
+    }
+    if (dryRun) {
+        return {
+            success: true,
+            baileyDir,
+            targetFile,
+            alreadyPatched: false,
+            format,
+            message: `[dry-run] Would patch ${targetFile} (format: ${format})`,
+        };
+    }
+    // 4. Backup
+    const backupPath = targetFile + '.antiban-backup';
+    if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(targetFile, backupPath);
+    }
+    // 5. Build and apply patch
+    const patchOpts = { preset, minDelay, maxDelay, typing: typingIndicator };
+    let patched;
+    try {
+        if (format === 'cjs') {
+            patched = source + buildCjsPatch(patchOpts);
+        }
+        else {
+            patched = buildEsmPatch(source, patchOpts);
+        }
+    }
+    catch (e) {
+        return {
+            success: false,
+            baileyDir,
+            targetFile,
+            alreadyPatched: false,
+            format,
+            message: `Patch generation failed: ${e.message}`,
+        };
+    }
+    fs.writeFileSync(targetFile, patched, 'utf-8');
+    return {
+        success: true,
+        baileyDir,
+        targetFile,
+        alreadyPatched: false,
+        format,
+        backupPath,
+        message: `✅ Patched: ${targetFile}\n` +
+            `   Format:  ${format}\n` +
+            `   Backup:  ${backupPath}\n` +
+            `   Preset:  ${preset} (${minDelay}–${maxDelay}ms delays, typing=${typingIndicator})\n` +
+            `\nTo auto-re-patch after plugin updates, add to your package.json:\n` +
+            `  "scripts": { "postinstall": "npx baileys-antiban patch" }\n\n` +
+            `Env overrides: ANTIBAN_PRESET, ANTIBAN_MIN_DELAY, ANTIBAN_MAX_DELAY, ANTIBAN_TYPING`,
+    };
+}
+function unpatchFile(targetFile) {
+    if (!fs.existsSync(targetFile)) {
+        return { success: false, message: `File not found: ${targetFile}` };
+    }
+    const backupPath = targetFile + '.antiban-backup';
+    if (!fs.existsSync(backupPath)) {
+        // Try removing the patch block from source
+        const source = fs.readFileSync(targetFile, 'utf-8');
+        if (!source.includes(PATCH_MARKER_START)) {
+            return { success: true, message: 'File is not patched.' };
+        }
+        const startIdx = source.indexOf(PATCH_MARKER_START);
+        const endIdx = source.indexOf(PATCH_MARKER_END);
+        if (startIdx === -1 || endIdx === -1) {
+            return { success: false, message: 'Patch markers found but malformed. Restore manually from backup.' };
+        }
+        const cleaned = source.slice(0, startIdx) + source.slice(endIdx + PATCH_MARKER_END.length);
+        fs.writeFileSync(targetFile, cleaned, 'utf-8');
+        return { success: true, message: `Patch removed from ${targetFile}` };
+    }
+    fs.copyFileSync(backupPath, targetFile);
+    fs.unlinkSync(backupPath);
+    return { success: true, message: `Restored from backup: ${backupPath}` };
+}

package/dist/cli.js

@@ -6,6 +6,7 @@
 import * as fs from 'fs';
 import { StateManager } from './persist.js';
 import { resolveConfig } from './presets.js';
+import { applyPatch, unpatchFile } from './patch.js';
 const args = process.argv.slice(2);
 const command = args[0];
 function parseArgs(argv) {
@@ -92,6 +93,45 @@ function cmdWarmupSimulate(opts) {
     console.log('─'.repeat(50));
     console.log(`Day ${days + 1}+: graduated (unlimited by warmup)\n`);
 }
+function cmdPatch(opts) {
+    const searchPaths = opts['path'] ? [opts['path']] : undefined;
+    const preset = opts['preset'] || 'conservative';
+    const minDelay = opts['min-delay'] ? parseInt(opts['min-delay']) : 1500;
+    const maxDelay = opts['max-delay'] ? parseInt(opts['max-delay']) : 4000;
+    const typingIndicator = opts['no-typing'] ? false : true;
+    const dryRun = !!opts['dry-run'];
+    const force = !!opts['force'];
+    const result = applyPatch({
+        baileysPaths: searchPaths,
+        preset,
+        minDelay,
+        maxDelay,
+        typingIndicator,
+        dryRun,
+    });
+    if (result.alreadyPatched && !force) {
+        console.log(result.message);
+        process.exit(0);
+    }
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
+function cmdUnpatch(opts) {
+    const targetFile = opts['file'];
+    if (!targetFile) {
+        console.error('Usage: npx baileys-antiban unpatch --file <path-to-patched-file>');
+        process.exit(1);
+    }
+    const result = unpatchFile(targetFile);
+    if (!result.success) {
+        console.error('✗ ' + result.message);
+        process.exit(1);
+    }
+    console.log(result.message);
+}
 // Main
 const opts = parseArgs(args);
 switch (command) {
@@ -110,6 +150,12 @@ switch (command) {
             process.exit(1);
         }
         break;
+    case 'patch':
+        cmdPatch(opts);
+        break;
+    case 'unpatch':
+        cmdUnpatch(opts);
+        break;
     default:
         console.log('baileys-antiban v3.0');
         console.log('');
@@ -117,9 +163,15 @@ switch (command) {
         console.log('  status [--state <path>] [--json]     Show warmup and health status');
         console.log('  reset --state <path>                  Delete state file');
         console.log('  warmup --simulate <days> [--preset]  Show warmup schedule');
+        console.log('  patch [--path <baileys-dir>] [--preset] [--min-delay] [--max-delay] [--no-typing] [--dry-run]');
+        console.log('  unpatch --file <patched-file>         Restore file from backup');
         console.log('');
         console.log('Examples:');
         console.log('  npx baileys-antiban status --state ./antiban-state.json');
         console.log('  npx baileys-antiban warmup --simulate 7 --preset moderate');
         console.log('  npx baileys-antiban reset --state ./antiban-state.json');
+        console.log('  npx baileys-antiban patch');
+        console.log('  npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys');
+        console.log('  npx baileys-antiban patch --preset moderate --min-delay 1000 --max-delay 3000');
+        console.log('  npx baileys-antiban unpatch --file ./node_modules/baileys/lib/socket/index.js');
 }

package/dist/messageRecovery.d.ts

@@ -12,7 +12,7 @@
  * 4. Re-emits gap messages through user callback (wired to messages.upsert handler)
  * 5. Fires onGapTooLarge if disconnect > maxGapMs instead of partial recovery
  *
- * @see https://github.com/WhiskeySockets/Baileys/issues/XXX (47+ upvotes)
+ * @see https://github.com/WhiskeySockets/Baileys/issues/2491
  */
 export interface MessageRecoveryConfig {
     /** Max messages to track in flight (in-memory cap on lastSeen tracking) */

package/dist/messageRecovery.js

@@ -1,19 +1,4 @@
-/**
- * Message Recovery — Solves Baileys' silent message loss on 408 reconnect
- *
- * After a 408 disconnect (and other clean reconnect paths), offline messages
- * arrive on the server side but never fire `messages.upsert` events in Baileys.
- * Bots silently lose messages from the disconnect window.
- *
- * This module:
- * 1. Tracks the last message ID seen per chat while connected
- * 2. Detects disconnect/reconnect cycles via connection.update events
- * 3. On reconnect, queries Baileys' message store for messages newer than lastSeen
- * 4. Re-emits gap messages through user callback (wired to messages.upsert handler)
- * 5. Fires onGapTooLarge if disconnect > maxGapMs instead of partial recovery
- *
- * @see https://github.com/WhiskeySockets/Baileys/issues/XXX (47+ upvotes)
- */
+import { existsSync, readFileSync } from 'node:fs';
 const DEFAULT_CONFIG = {
     maxTrackedChats: 1000,
     maxGapMs: 30 * 60_000, // 30 minutes
@@ -37,7 +22,7 @@ export function messageRecovery(sock, config) {
     // Persistence
     let persistTimer = null;
     let loggedFetchWarning = false;
-    // Load persisted state on startup
+    // Load persisted state on startup (synchronous — seeds lastSeen before first event)
     if (cfg.persistPath) {
         loadPersistence();
     }
@@ -245,10 +230,9 @@ export function messageRecovery(sock, config) {
         if (!cfg.persistPath)
             return;
         try {
-            const fs = require('fs');
-            if (!fs.existsSync(cfg.persistPath))
+            if (!existsSync(cfg.persistPath))
                 return;
-            const raw = fs.readFileSync(cfg.persistPath, 'utf-8');
+            const raw = readFileSync(cfg.persistPath, 'utf-8');
             const data = JSON.parse(raw);
             for (const [jid, entry] of Object.entries(data)) {
                 lastSeen.set(jid, {

package/dist/patch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * baileys-antiban patch command
+ *
+ * Patches an installed Baileys package to wrap makeWASocket with antiban middleware.
+ * Designed for frameworks (OpenClaw, etc.) that create the socket internally and
+ * don't expose a socket:ready hook.
+ *
+ * Idempotent: safe to re-run after plugin updates. Keeps a .antiban-backup file.
+ *
+ * Usage:
+ *   npx baileys-antiban patch [--path <baileys-dir>] [--dry-run] [--preset conservative|moderate|aggressive]
+ */
+export interface PatchOptions {
+    baileysPaths?: string[];
+    preset?: string;
+    minDelay?: number;
+    maxDelay?: number;
+    typingIndicator?: boolean;
+    dryRun?: boolean;
+}
+export interface PatchResult {
+    success: boolean;
+    baileyDir: string;
+    targetFile: string;
+    alreadyPatched: boolean;
+    format: 'esm' | 'cjs';
+    backupPath?: string;
+    message: string;
+}
+export declare function applyPatch(opts: PatchOptions): PatchResult;
+export declare function unpatchFile(targetFile: string): {
+    success: boolean;
+    message: string;
+};

package/dist/patch.js

@@ -0,0 +1,302 @@
+/**
+ * baileys-antiban patch command
+ *
+ * Patches an installed Baileys package to wrap makeWASocket with antiban middleware.
+ * Designed for frameworks (OpenClaw, etc.) that create the socket internally and
+ * don't expose a socket:ready hook.
+ *
+ * Idempotent: safe to re-run after plugin updates. Keeps a .antiban-backup file.
+ *
+ * Usage:
+ *   npx baileys-antiban patch [--path <baileys-dir>] [--dry-run] [--preset conservative|moderate|aggressive]
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const PATCH_MARKER_START = '// [BAILEYS-ANTIBAN-PATCH-START]';
+const PATCH_MARKER_END = '// [BAILEYS-ANTIBAN-PATCH-END]';
+function findBaileysDir(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const pkgPath = path.join(candidate, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'baileys' || pkg.name === '@whiskeysockets/baileys' || pkg.name === '@oxidezap/baileyrs') {
+                    return path.resolve(candidate);
+                }
+            }
+            catch {
+                // not a valid package.json, skip
+            }
+        }
+    }
+    return null;
+}
+function findMakeWASocketFile(baileyDir) {
+    // Ordered by likelihood of containing the actual makeWASocket definition
+    const candidates = [
+        'lib/socket/index.js',
+        'lib/index.js',
+        'lib/socket.js',
+        'src/socket/index.js',
+        'dist/socket/index.js',
+        'dist/index.js',
+    ];
+    for (const rel of candidates) {
+        const full = path.join(baileyDir, rel);
+        if (!fs.existsSync(full))
+            continue;
+        const source = fs.readFileSync(full, 'utf-8');
+        // Look for makeWASocket being defined (not just re-exported via export *)
+        if (source.includes('function makeWASocket') ||
+            source.includes('const makeWASocket') ||
+            source.includes('exports.makeWASocket') ||
+            source.includes('makeWASocket =')) {
+            const isEsm = source.includes('export function makeWASocket') ||
+                source.includes('export const makeWASocket') ||
+                source.includes('export {') ||
+                source.includes('export default');
+            return { file: full, format: isEsm ? 'esm' : 'cjs' };
+        }
+    }
+    // Fallback: search lib/ directory for the defining file
+    const libDir = path.join(baileyDir, 'lib');
+    if (fs.existsSync(libDir)) {
+        const jsFiles = fs
+            .readdirSync(libDir, { recursive: true })
+            .filter((f) => typeof f === 'string' && f.endsWith('.js'))
+            .map((f) => path.join(libDir, f));
+        for (const full of jsFiles) {
+            try {
+                const source = fs.readFileSync(full, 'utf-8');
+                if (source.includes('function makeWASocket') && source.includes('makeWASocket')) {
+                    const isEsm = source.includes('export');
+                    return { file: full, format: isEsm ? 'esm' : 'cjs' };
+                }
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    return null;
+}
+function buildCjsPatch(opts) {
+    return `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+(function() {
+  try {
+    const { wrapSocket } = require('baileys-antiban');
+    const _orig = module.exports.makeWASocket;
+    if (typeof _orig === 'function') {
+      module.exports.makeWASocket = function(...args) {
+        return wrapSocket(_orig.apply(this, args), {
+          preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+          delayBetweenMessages: {
+            min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+            max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+          },
+          typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+        });
+      };
+    }
+  } catch(e) {
+    console.warn('[baileys-antiban] patch inactive:', e.message);
+  }
+})();
+${PATCH_MARKER_END}
+`;
+}
+function buildEsmPatch(source, opts) {
+    // Strategy A: function declaration — rename and re-export wrapped version
+    if (source.includes('export function makeWASocket')) {
+        const patched = source.replace(/export function makeWASocket\b/, 'function _antiban_makeWASocket_orig');
+        return (patched +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+export const makeWASocket = (...args) => _antibanWrap(_antiban_makeWASocket_orig(...args), {
+  preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+  delayBetweenMessages: {
+    min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+    max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+  },
+  typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+});
+${PATCH_MARKER_END}
+`);
+    }
+    // Strategy B: const/let declaration — rename and re-export
+    if (source.match(/export\s+(const|let)\s+makeWASocket\s*=/)) {
+        const patched = source.replace(/export\s+(const|let)\s+makeWASocket\s*=/, 'const _antiban_makeWASocket_orig =');
+        return (patched +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+export const makeWASocket = (...args) => _antibanWrap(_antiban_makeWASocket_orig(...args), {
+  preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+  delayBetweenMessages: {
+    min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+    max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+  },
+  typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+});
+${PATCH_MARKER_END}
+`);
+    }
+    // Strategy C: named re-export — intercept at this boundary
+    if (source.includes('makeWASocket')) {
+        // Append import + re-export override at end of file
+        return (source +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+// NOTE: Strategy C (named export intercept) — less precise than A/B.
+// If this breaks, use --path to target the file where makeWASocket is defined.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+const _antiban_raw = makeWASocket;
+export { makeWASocket };  // shadowed below if engine supports block-level export rebind
+// Fallback: log advisory if strategy C can't reassign
+if (typeof makeWASocket === 'function') {
+  // eslint-disable-next-line no-global-assign
+  try { makeWASocket = (...a) => _antibanWrap(_antiban_raw(...a), { preset: '${opts.preset}', delayBetweenMessages: { min: ${opts.minDelay}, max: ${opts.maxDelay} }, typingIndicator: ${opts.typing} }); } catch {}
+}
+${PATCH_MARKER_END}
+`);
+    }
+    throw new Error('Could not locate makeWASocket in this file. Try --path to a different Baileys file.');
+}
+export function applyPatch(opts) {
+    const { preset = 'conservative', minDelay = 1500, maxDelay = 4000, typingIndicator = true, dryRun = false, } = opts;
+    // 1. Locate Baileys
+    const defaultSearchPaths = [
+        // OC-style nested location
+        './node_modules/@openclaw/whatsapp/node_modules/baileys',
+        './node_modules/@openclaw/whatsapp/node_modules/@whiskeysockets/baileys',
+        // Standard locations
+        './node_modules/baileys',
+        './node_modules/@whiskeysockets/baileys',
+        // Walk up
+        '../node_modules/baileys',
+        '../../node_modules/baileys',
+    ];
+    const searchPaths = opts.baileysPaths?.length ? opts.baileysPaths : defaultSearchPaths;
+    const baileyDir = findBaileysDir(searchPaths);
+    if (!baileyDir) {
+        return {
+            success: false,
+            baileyDir: '(not found)',
+            targetFile: '(not found)',
+            alreadyPatched: false,
+            format: 'cjs',
+            message: 'Could not find Baileys package. Use --path <dir> to specify its location.\n' +
+                'Example: npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys',
+        };
+    }
+    // 2. Find file containing makeWASocket
+    const found = findMakeWASocketFile(baileyDir);
+    if (!found) {
+        return {
+            success: false,
+            baileyDir,
+            targetFile: '(not found)',
+            alreadyPatched: false,
+            format: 'cjs',
+            message: `Found Baileys at ${baileyDir} but could not locate makeWASocket definition.\n` +
+                'The package structure may have changed. Please open an issue.',
+        };
+    }
+    const { file: targetFile, format } = found;
+    const source = fs.readFileSync(targetFile, 'utf-8');
+    // 3. Check idempotency
+    if (source.includes(PATCH_MARKER_START)) {
+        return {
+            success: true,
+            baileyDir,
+            targetFile,
+            alreadyPatched: true,
+            format,
+            message: `Already patched: ${targetFile}\nRe-run with --force to re-apply.`,
+        };
+    }
+    if (dryRun) {
+        return {
+            success: true,
+            baileyDir,
+            targetFile,
+            alreadyPatched: false,
+            format,
+            message: `[dry-run] Would patch ${targetFile} (format: ${format})`,
+        };
+    }
+    // 4. Backup
+    const backupPath = targetFile + '.antiban-backup';
+    if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(targetFile, backupPath);
+    }
+    // 5. Build and apply patch
+    const patchOpts = { preset, minDelay, maxDelay, typing: typingIndicator };
+    let patched;
+    try {
+        if (format === 'cjs') {
+            patched = source + buildCjsPatch(patchOpts);
+        }
+        else {
+            patched = buildEsmPatch(source, patchOpts);
+        }
+    }
+    catch (e) {
+        return {
+            success: false,
+            baileyDir,
+            targetFile,
+            alreadyPatched: false,
+            format,
+            message: `Patch generation failed: ${e.message}`,
+        };
+    }
+    fs.writeFileSync(targetFile, patched, 'utf-8');
+    return {
+        success: true,
+        baileyDir,
+        targetFile,
+        alreadyPatched: false,
+        format,
+        backupPath,
+        message: `✅ Patched: ${targetFile}\n` +
+            `   Format:  ${format}\n` +
+            `   Backup:  ${backupPath}\n` +
+            `   Preset:  ${preset} (${minDelay}–${maxDelay}ms delays, typing=${typingIndicator})\n` +
+            `\nTo auto-re-patch after plugin updates, add to your package.json:\n` +
+            `  "scripts": { "postinstall": "npx baileys-antiban patch" }\n\n` +
+            `Env overrides: ANTIBAN_PRESET, ANTIBAN_MIN_DELAY, ANTIBAN_MAX_DELAY, ANTIBAN_TYPING`,
+    };
+}
+export function unpatchFile(targetFile) {
+    if (!fs.existsSync(targetFile)) {
+        return { success: false, message: `File not found: ${targetFile}` };
+    }
+    const backupPath = targetFile + '.antiban-backup';
+    if (!fs.existsSync(backupPath)) {
+        // Try removing the patch block from source
+        const source = fs.readFileSync(targetFile, 'utf-8');
+        if (!source.includes(PATCH_MARKER_START)) {
+            return { success: true, message: 'File is not patched.' };
+        }
+        const startIdx = source.indexOf(PATCH_MARKER_START);
+        const endIdx = source.indexOf(PATCH_MARKER_END);
+        if (startIdx === -1 || endIdx === -1) {
+            return { success: false, message: 'Patch markers found but malformed. Restore manually from backup.' };
+        }
+        const cleaned = source.slice(0, startIdx) + source.slice(endIdx + PATCH_MARKER_END.length);
+        fs.writeFileSync(targetFile, cleaned, 'utf-8');
+        return { success: true, message: `Patch removed from ${targetFile}` };
+    }
+    fs.copyFileSync(backupPath, targetFile);
+    fs.unlinkSync(backupPath);
+    return { success: true, message: `Restored from backup: ${backupPath}` };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baileys-antiban",
-  "version": "3.8.6",
+  "version": "3.8.7",
   "description": "Anti-ban middleware for Baileys WhatsApp bots. Rate limiting, warmup, health monitor, LID resolver, disconnect classifier. Free Whapi.Cloud alternative.",
   "main": "dist/cjs/index.js",
   "types": "dist/index.d.ts",
@@ -89,11 +89,8 @@
     }
   },
   "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",
     "typescript": "^5.0.0",
     "vitest": "^4.1.5"