aunubaileys 1.0.10 → 1.0.12

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.12 / Baru di 1.0.12
+
+- 🔑 **Pairing waits for the socket — and explains itself when it can't.** Field report from a real VPS deploy: `requestPairingCode` threw a bare Boom 428 "Connection Closed" every time, leaving consumers unable to tell an unready socket from a server rejection. Now `requestPairingCode` **waits internally (up to 30s) for the transport to open** before sending the pairing IQ, fails fast if the connection dies while waiting, and **every pairing failure carries the last disconnect reason** (status code + message) instead of the generic text. The 1.0.10 single-flight guard is kept and covers the wait.
+
+### 🆕 What's new in 1.0.11 / Baru di 1.0.11
+
+- 🚑 **Hotfix for broken 1.0.9 / 1.0.10 tarballs** — the published packages exported `./Utils/antiban.js` from `lib/index.js` but the file itself was never committed to the repository, so every install crashed on import with `ERR_MODULE_NOT_FOUND`. The AntiBan module (and its types) is now in the repo, and this release's tarball was verified with a clean install + import test. Also in: RafaelPivots' `INITIAL_PREKEY_COUNT` type correction (30 → 812, matching the runtime) and repository URLs updated to the repo's new home, **AunuCore/AunuBaileys-lib**. If you are on 1.0.9 or 1.0.10, upgrade to 1.0.11.
+
 ### 🆕 What's new in 1.0.10 / Baru di 1.0.10
 
 - 🛠️ **Reliability hardening against classic upstream weaknesses** — (1) **Retry receipts now get answered even without a custom `getMessage` store:** a built-in per-socket sent-message cache (last 256 relayed messages, whatsmeow-style) backs up your store, ending the silent "message not available" failures behind stuck unreadable/undelivered messages. Disable with `sentMessagesCacheSize: 0`. (2) **Pairing is now single-flight:** `requestPairingCode` refuses to double-fire (double requests invalidate the first code) and refuses outright on already-registered sessions, with clear errors instead of silent corruption. (3) **Handshake timeout raised:** default `connectTimeoutMs` goes 20s → 60s so pairing no longer times out on slow networks.

package/lib/Defaults/index.d.ts

@@ -42,7 +42,7 @@ export declare const MEDIA_HKDF_KEY_MAPPING: {
 };
 export declare const MEDIA_KEYS: MediaType[];
 export declare const MIN_PREKEY_COUNT = 5;
-export declare const INITIAL_PREKEY_COUNT = 30;
+export declare const INITIAL_PREKEY_COUNT = 812;
 export declare const DEFAULT_CACHE_TTLS: {
     SIGNAL_STORE: number;
     MSG_RETRY: number;

package/lib/Socket/socket.js

@@ -49,6 +49,7 @@ export const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    let lastDisconnectError;
     const uqTagId = generateMdTagPrefix();
     const generateMessageTag = () => `${uqTagId}${epoch++}`;
     const sendPromise = promisify(ws.send);
@@ -255,6 +256,7 @@ export const makeSocket = (config) => {
             return;
         }
         closed = true;
+        lastDisconnectError = error;
         logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
         clearInterval(keepAliveReq);
         clearTimeout(qrTimer);
@@ -371,6 +373,59 @@ export const makeSocket = (config) => {
         end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
     let pairingCodeRequestInFlight = false;
+    const PAIRING_READY_TIMEOUT_MS = 30000;
+    const describeLastDisconnect = () => {
+        if (!lastDisconnectError) {
+            return 'no disconnect recorded yet';
+        }
+        const code = lastDisconnectError?.data?.statusCode ?? lastDisconnectError?.output?.statusCode;
+        return `${code ? `status ${code} — ` : ''}${lastDisconnectError?.message || String(lastDisconnectError)}`;
+    };
+    // AunuBaileys: pairing must not fire its IQ into a socket that is not
+    // open yet (upstream throws a bare 428 'Connection Closed'). Wait for
+    // the transport to open, fail fast when the connection dies meanwhile,
+    // and always surface WHY via the last disconnect reason.
+    const waitForPairingReady = async () => {
+        if (ws.isOpen) {
+            return;
+        }
+        if (closed || ws.isClosed || ws.isClosing) {
+            throw new Boom(`requestPairingCode: connection is already closed (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed });
+        }
+        let onUpdate;
+        const closedWhileWaiting = new Promise((_, reject) => {
+            onUpdate = (update) => {
+                if (update.connection === 'close') {
+                    reject(new Boom(`requestPairingCode: connection closed while waiting for the socket to open (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed }));
+                }
+            };
+            ev.on('connection.update', onUpdate);
+        });
+        let timer;
+        const timedOut = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                reject(new Boom(`requestPairingCode: socket did not open within ${PAIRING_READY_TIMEOUT_MS / 1000}s (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.timedOut }));
+            }, PAIRING_READY_TIMEOUT_MS);
+        });
+        try {
+            await Promise.race([
+                waitForSocketOpen().catch(() => {
+                    throw new Boom(`requestPairingCode: connection closed while waiting for the socket to open (last disconnect: ${describeLastDisconnect()})`, { statusCode: DisconnectReason.connectionClosed });
+                }),
+                closedWhileWaiting,
+                timedOut
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+            if (onUpdate) {
+                try {
+                    ev.off('connection.update', onUpdate);
+                }
+                catch { }
+            }
+        }
+    };
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
         if (authState.creds.registered) {
             throw new Error('requestPairingCode: this session is already registered — pairing codes are only for new logins');
@@ -384,6 +439,7 @@ export const makeSocket = (config) => {
         }
         pairingCodeRequestInFlight = true;
         try {
+        await waitForPairingReady();
         authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
             id: jidEncode(phoneNumber, 's.whatsapp.net'),
@@ -438,6 +494,14 @@ export const makeSocket = (config) => {
         });
         return authState.creds.pairingCode;
         }
+        catch (err) {
+            const msg = err?.message || '';
+            const isClosedErr = err?.output?.statusCode === DisconnectReason.connectionClosed || /connection closed/i.test(msg);
+            if (isClosedErr && !msg.startsWith('requestPairingCode')) {
+                throw new Boom(`requestPairingCode failed: connection closed before the pairing request could be delivered (last disconnect: ${describeLastDisconnect()}). Original error: ${msg}`, { statusCode: DisconnectReason.connectionClosed });
+            }
+            throw err;
+        }
         finally {
             pairingCodeRequestInFlight = false;
         }

package/lib/Utils/antiban.d.ts

@@ -0,0 +1,21 @@
+import type { WASocket } from '../Types';
+export declare const gaussianJitter: (mean?: number, sigma?: number) => number;
+export declare class RateLimiter {
+    constructor(max: number, windowMs: number);
+    acquire(key: string): Promise<number>;
+    tryAcquire(key: string): boolean;
+}
+export interface DisconnectClassification { category: string; action: 'stop' | 'restart' | 'reconnect' | 'backoff'; detail: string; }
+export declare const classifyDisconnect: (error: unknown) => DisconnectClassification;
+export interface AunuAntiBanOptions {
+    perChatPerMinute?: number; globalPerMinute?: number; minDelayMs?: number; jitterMs?: number;
+    warmupDays?: number; warmupStart?: number; typingSimulation?: boolean;
+    groupAddMax?: number; groupAddWindowMs?: number; groupCreateMax?: number; groupCreateWindowMs?: number;
+}
+export declare class AunuAntiBan {
+    constructor(options?: AunuAntiBanOptions);
+    warmupFactor(): number;
+    effectiveLimit(base: number): number;
+    wrap<T extends WASocket>(sock: T): T;
+}
+export declare const wrapAntiBan: (sock: WASocket, options?: AunuAntiBanOptions) => WASocket;

package/lib/Utils/antiban.js

@@ -0,0 +1,170 @@
+/**
+ * AunuAntiBan — lapisan perlindungan akun bawaan AunuBaileys.
+ * Konsep terinspirasi baileys-antiban (kobie3717), diimplementasikan ulang
+ * secara bersih di dalam paket: rate limiting dengan jitter Gaussian,
+ * jadwal warmup akun baru, penjaga operasi grup, simulasi mengetik,
+ * dan klasifikasi disconnect. Tanpa telemetri, tanpa jaringan tambahan.
+ */
+import { Boom } from '@hapi/boom';
+import { DisconnectReason } from '../Types/index.js';
+import { delay } from './generics.js';
+
+/** Jitter Gaussian (Box-Muller), hasil dibatasi >= 0. */
+export const gaussianJitter = (mean = 0, sigma = 1) => {
+    let u = 0;
+    let v = 0;
+    while (u === 0)
+        u = Math.random();
+    while (v === 0)
+        v = Math.random();
+    const n = Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
+    return Math.max(0, mean + n * sigma);
+};
+
+/** Rate limiter jendela geser per kunci. */
+export class RateLimiter {
+    constructor(max, windowMs) {
+        this.max = max;
+        this.windowMs = windowMs;
+        this.hits = new Map();
+    }
+    /** Tunggu sampai ada slot untuk key; kembalikan waktu tunggu (ms). */
+    async acquire(key) {
+        const now = Date.now();
+        let arr = this.hits.get(key);
+        if (!arr) {
+            arr = [];
+            this.hits.set(key, arr);
+        }
+        while (arr.length && now - arr[0] >= this.windowMs)
+            arr.shift();
+        if (arr.length >= this.max) {
+            const wait = this.windowMs - (now - arr[0]) + 5;
+            await delay(wait);
+            return this.acquire(key);
+        }
+        arr.push(Date.now());
+        return 0;
+    }
+    /** Cek tanpa menunggu; true bila masih boleh. */
+    tryAcquire(key) {
+        const now = Date.now();
+        let arr = this.hits.get(key);
+        if (!arr) {
+            arr = [];
+            this.hits.set(key, arr);
+        }
+        while (arr.length && now - arr[0] >= this.windowMs)
+            arr.shift();
+        if (arr.length >= this.max) {
+            return false;
+        }
+        arr.push(now);
+        return true;
+    }
+}
+
+/** Klasifikasi error disconnect -> kategori + tindakan yang disarankan. */
+export const classifyDisconnect = (error) => {
+    const code = error?.output?.statusCode ?? error?.statusCode ?? error;
+    switch (code) {
+        case DisconnectReason.loggedOut:
+            return { category: 'logged_out', action: 'stop', detail: 'Sesi logout — perlu pairing ulang. Jangan auto-reconnect.' };
+        case DisconnectReason.restartRequired:
+            return { category: 'restart_required', action: 'restart', detail: 'Server meminta restart — hubungkan ulang sekali.' };
+        case DisconnectReason.connectionReplaced:
+            return { category: 'replaced', action: 'stop', detail: 'Sesi digantikan koneksi lain — periksa perangkat tertaut.' };
+        case DisconnectReason.badSession:
+            return { category: 'bad_session', action: 'stop', detail: 'Sesi rusak — hapus auth state dan pairing ulang.' };
+        case DisconnectReason.multideviceMismatch:
+            return { category: 'mismatch', action: 'stop', detail: 'Ketidakcocokan multidevice — pairing ulang.' };
+        case 403:
+            return { category: 'forbidden', action: 'stop', detail: '403 — kemungkinan dibatasi/diblokir. Berhenti dan periksa akun.' };
+        case 429:
+            return { category: 'rate_limited', action: 'backoff', detail: '429 — terlalu cepat. Mundur dan turunkan laju kirim.' };
+        case DisconnectReason.timedOut:
+        case DisconnectReason.connectionLost:
+        case DisconnectReason.connectionClosed:
+        default:
+            return { category: 'transient', action: 'reconnect', detail: 'Gangguan jaringan/server sementara — aman reconnect dengan jeda.' };
+    }
+};
+
+export class AunuAntiBan {
+    constructor(options = {}) {
+        this.options = {
+            perChatPerMinute: 12,
+            globalPerMinute: 60,
+            minDelayMs: 700,
+            jitterMs: 900,
+            warmupDays: 7,
+            warmupStart: Date.now(),
+            typingSimulation: true,
+            groupAddMax: 3,
+            groupAddWindowMs: 600000,
+            groupCreateMax: 2,
+            groupCreateWindowMs: 600000,
+            ...options
+        };
+        const o = this.options;
+        this.perChat = new RateLimiter(o.perChatPerMinute, 60000);
+        this.global = new RateLimiter(o.globalPerMinute, 60000);
+        this.groupAdd = new RateLimiter(o.groupAddMax, o.groupAddWindowMs);
+        this.groupCreate = new RateLimiter(o.groupCreateMax, o.groupCreateWindowMs);
+    }
+    /** Faktor warmup 0.3 -> 1.0 selama warmupDays sejak warmupStart. */
+    warmupFactor() {
+        const days = (Date.now() - this.options.warmupStart) / 86400000;
+        if (days >= this.options.warmupDays) {
+            return 1;
+        }
+        return 0.3 + 0.7 * Math.max(0, days / this.options.warmupDays);
+    }
+    /** Batasi laju efektif mengikuti warmup. */
+    effectiveLimit(base) {
+        return Math.max(1, Math.floor(base * this.warmupFactor()));
+    }
+    /** Terapkan perlindungan ke socket; socket yang sama dikembalikan. */
+    wrap(sock) {
+        const self = this;
+        const origSend = sock.sendMessage.bind(sock);
+        sock.sendMessage = async (jid, content, options) => {
+            await self.global.acquire('__global__');
+            await self.perChat.acquire(jid);
+            if (self.options.typingSimulation && (content?.text || content?.caption) && typeof sock.sendPresenceUpdate === 'function') {
+                try {
+                    await sock.sendPresenceUpdate('composing', jid);
+                }
+                catch { }
+            }
+            const wait = self.options.minDelayMs * self.warmupFactor() + gaussianJitter(0, self.options.jitterMs / 2);
+            if (wait > 0) {
+                await delay(wait);
+            }
+            return origSend(jid, content, options);
+        };
+        if (typeof sock.groupParticipantsUpdate === 'function') {
+            const orig = sock.groupParticipantsUpdate.bind(sock);
+            sock.groupParticipantsUpdate = async (jid, participants, action, inviteMessage) => {
+                if (action === 'add' && !self.groupAdd.tryAcquire(jid)) {
+                    throw new Boom('AunuAntiBan: batas tambah anggota grup tercapai — jeda dulu agar akun aman', { statusCode: 429 });
+                }
+                return orig(jid, participants, action, inviteMessage);
+            };
+        }
+        if (typeof sock.groupCreate === 'function') {
+            const origCreate = sock.groupCreate.bind(sock);
+            sock.groupCreate = async (subject, participants) => {
+                if (!self.groupCreate.tryAcquire('__create__')) {
+                    throw new Boom('AunuAntiBan: batas buat grup tercapai — jeda dulu agar akun aman', { statusCode: 429 });
+                }
+                return origCreate(subject, participants);
+            };
+        }
+        sock.aunuAntiBan = self;
+        return sock;
+    }
+}
+
+/** 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.10",
+  "version": "1.0.12",
   "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",
@@ -22,7 +22,7 @@
   "homepage": "https://docsjs.aunucore.eu.cc",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/AunuHost/AunuBaileys-lib.git"
+    "url": "git+https://github.com/AunuCore/AunuBaileys-lib.git"
   },
   "license": "MIT",
   "author": "AunuCore Creative Network",
@@ -101,7 +101,7 @@
     "node": ">=20.0.0"
   },
   "bugs": {
-    "url": "https://github.com/AunuHost/AunuBaileys-lib/issues"
+    "url": "https://github.com/AunuCore/AunuBaileys-lib/issues"
   },
   "publishConfig": {
     "access": "public"