@prototypevip/baileys 0.0.8 → 0.1.0

package/lib/AntiBan/contentVariator.js

@@ -0,0 +1,150 @@
+/**
+ * Content Variator — Auto-vary messages to avoid spam detection
+ *
+ * WhatsApp flags identical messages sent to multiple recipients.
+ * This module adds invisible variations so each message is technically unique.
+ */
+const DEFAULT_CONFIG = {
+    zeroWidthChars: true,
+    punctuationVariation: true,
+    emojiPadding: false,
+    synonyms: false,
+};
+// Zero-width characters invisible to users
+const ZERO_WIDTH = [
+    '\u200B', // zero-width space
+    '\u200C', // zero-width non-joiner
+    '\u200D', // zero-width joiner
+    '\uFEFF', // zero-width no-break space
+];
+const SYNONYMS = {
+    'hello': ['hi', 'hey', 'howdy'],
+    'hi': ['hello', 'hey', 'howdy'],
+    'thanks': ['thank you', 'thx', 'cheers'],
+    'please': ['kindly', 'pls'],
+    'great': ['awesome', 'excellent', 'wonderful'],
+    'good': ['great', 'nice', 'fine'],
+    'buy': ['purchase', 'get', 'grab'],
+    'sell': ['offer', 'list'],
+    'price': ['cost', 'amount', 'value'],
+    'available': ['in stock', 'on offer'],
+    'check': ['look at', 'see', 'view'],
+    'join': ['participate', 'enter', 'come to'],
+    'start': ['begin', 'kick off', 'commence'],
+    'end': ['finish', 'close', 'conclude'],
+    'bid': ['offer', 'place a bid'],
+    'win': ['secure', 'take home'],
+    'item': ['lot', 'piece', 'product'],
+};
+export class ContentVariator {
+    config;
+    counter = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Create a unique variation of a message
+     * Each call produces a slightly different version
+     */
+    vary(text) {
+        let result = text;
+        this.counter++;
+        if (this.config.customVariator) {
+            return this.config.customVariator(result, this.counter);
+        }
+        if (this.config.synonyms) {
+            result = this.applySynonyms(result);
+        }
+        if (this.config.zeroWidthChars) {
+            result = this.addZeroWidth(result);
+        }
+        if (this.config.punctuationVariation) {
+            result = this.varyPunctuation(result);
+        }
+        if (this.config.emojiPadding) {
+            result = this.addEmojiPadding(result);
+        }
+        return result;
+    }
+    /**
+     * Create N unique variations of a message
+     */
+    varyBulk(text, count) {
+        const results = [];
+        const seen = new Set();
+        for (let i = 0; i < count; i++) {
+            let variation = this.vary(text);
+            // Ensure uniqueness
+            let attempts = 0;
+            while (seen.has(variation) && attempts < 10) {
+                variation = this.vary(text);
+                attempts++;
+            }
+            seen.add(variation);
+            results.push(variation);
+        }
+        return results;
+    }
+    addZeroWidth(text) {
+        const words = text.split(' ');
+        if (words.length < 2)
+            return text;
+        // Insert 1-2 zero-width chars at random positions between words
+        const positions = this.randomPositions(words.length - 1, Math.min(2, words.length - 1));
+        return words.map((word, i) => {
+            if (positions.includes(i)) {
+                const zwc = ZERO_WIDTH[Math.floor(Math.random() * ZERO_WIDTH.length)];
+                return word + zwc;
+            }
+            return word;
+        }).join(' ');
+    }
+    varyPunctuation(text) {
+        const variations = [
+            // Trailing space variations
+            () => text + ' ',
+            () => text + '  ',
+            // Period variations
+            () => text.endsWith('.') ? text.slice(0, -1) : text + '.',
+            // Nothing
+            () => text,
+            // Capitalize first letter variation
+            () => text.charAt(0) === text.charAt(0).toUpperCase()
+                ? text.charAt(0).toLowerCase() + text.slice(1)
+                : text,
+        ];
+        return variations[this.counter % variations.length]();
+    }
+    addEmojiPadding(text) {
+        const emojis = ['', ' 👍', ' ✅', ' 📌', ' 💬', ' 📢'];
+        return text + emojis[this.counter % emojis.length];
+    }
+    applySynonyms(text) {
+        const words = text.split(/\b/);
+        let replaced = false;
+        return words.map(word => {
+            if (replaced)
+                return word;
+            const lower = word.toLowerCase();
+            const synonymList = SYNONYMS[lower];
+            if (synonymList && Math.random() > 0.5) {
+                replaced = true; // Only replace one word per message
+                const synonym = synonymList[Math.floor(Math.random() * synonymList.length)];
+                // Preserve original casing
+                return word[0] === word[0].toUpperCase()
+                    ? synonym.charAt(0).toUpperCase() + synonym.slice(1)
+                    : synonym;
+            }
+            return word;
+        }).join('');
+    }
+    randomPositions(max, count) {
+        const positions = [];
+        while (positions.length < count) {
+            const pos = Math.floor(Math.random() * max);
+            if (!positions.includes(pos))
+                positions.push(pos);
+        }
+        return positions;
+    }
+}

package/lib/AntiBan/credsSnapshot.js

@@ -0,0 +1,121 @@
+/**
+ * Atomic Credentials Snapshot
+ *
+ * Pre-reconnect backup to kill code-500 corruption loop.
+ * Take snapshots before risky operations, restore on corruption.
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+const noop = () => { };
+export function credsSnapshot(config) {
+    const { credsPath, snapshotDir = path.join(path.dirname(credsPath), '.snapshots'), keep = 3, logger = {}, } = config;
+    const log = {
+        info: logger.info || noop,
+        warn: logger.warn || noop,
+        error: logger.error || noop,
+    };
+    async function take() {
+        try {
+            // Check if creds file exists
+            try {
+                await fs.access(credsPath);
+            }
+            catch {
+                log.warn(`[credsSnapshot] Creds file not found: ${credsPath}`);
+                return null;
+            }
+            // Ensure snapshot dir exists
+            await fs.mkdir(snapshotDir, { recursive: true });
+            // Generate snapshot path
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const snapshotPath = path.join(snapshotDir, `creds-${timestamp}.json`);
+            const tmpPath = `${snapshotPath}.tmp`;
+            // Atomic copy: write to .tmp, then rename
+            await fs.copyFile(credsPath, tmpPath);
+            await fs.rename(tmpPath, snapshotPath);
+            log.info(`[credsSnapshot] Snapshot taken: ${snapshotPath}`);
+            // Rotate old snapshots
+            await rotate();
+            return snapshotPath;
+        }
+        catch (err) {
+            log.error(`[credsSnapshot] Failed to take snapshot: ${err}`);
+            return null;
+        }
+    }
+    async function rotate() {
+        try {
+            const snapshots = await list();
+            const toDelete = snapshots.slice(keep);
+            for (const snap of toDelete) {
+                await fs.unlink(snap.path);
+                log.info(`[credsSnapshot] Rotated out: ${snap.path}`);
+            }
+        }
+        catch (err) {
+            log.error(`[credsSnapshot] Rotation failed: ${err}`);
+        }
+    }
+    async function list() {
+        try {
+            await fs.access(snapshotDir);
+        }
+        catch {
+            return [];
+        }
+        try {
+            const files = await fs.readdir(snapshotDir);
+            const snapshots = await Promise.all(files
+                .filter((f) => f.startsWith('creds-') && f.endsWith('.json'))
+                .map(async (f) => {
+                const fullPath = path.join(snapshotDir, f);
+                const stat = await fs.stat(fullPath);
+                // Use file mtime for timestamp (simpler than parsing filename)
+                return {
+                    path: fullPath,
+                    takenAt: stat.mtime,
+                    size: stat.size,
+                };
+            }));
+            // Sort newest first
+            return snapshots.sort((a, b) => b.takenAt.getTime() - a.takenAt.getTime());
+        }
+        catch (err) {
+            log.error(`[credsSnapshot] Failed to list snapshots: ${err}`);
+            return [];
+        }
+    }
+    async function restoreLatest() {
+        const snapshots = await list();
+        if (snapshots.length === 0) {
+            log.warn('[credsSnapshot] No snapshots available to restore');
+            return false;
+        }
+        return restore(snapshots[0].path);
+    }
+    async function restore(snapshotPath) {
+        try {
+            // Verify snapshot exists
+            await fs.access(snapshotPath);
+            // Atomic restore: copy to .tmp, then rename
+            const tmpPath = `${credsPath}.tmp`;
+            await fs.copyFile(snapshotPath, tmpPath);
+            await fs.rename(tmpPath, credsPath);
+            log.info(`[credsSnapshot] Restored from: ${snapshotPath}`);
+            return true;
+        }
+        catch (err) {
+            log.error(`[credsSnapshot] Failed to restore from ${snapshotPath}: ${err}`);
+            return false;
+        }
+    }
+    return {
+        take,
+        restoreLatest,
+        restore,
+        list,
+    };
+}

package/lib/AntiBan/deliveryTracker.js

@@ -0,0 +1,107 @@
+/**
+ * DeliveryTracker — tracks actual delivery rate vs sent
+ *
+ * WhatsApp delivery receipts arrive via messages.update events as
+ * update.update.status = 3 (DELIVERY_ACK) or 4 (READ).
+ *
+ * Low delivery rate (< 60%) = strong soft-ban signal.
+ * Exposes deliveryRate for health monitoring and stats.
+ */
+const DEFAULT_CONFIG = {
+    windowMs: 3600000, // 1 hour
+    minSampleSize: 10,
+    onLowDeliveryRate: () => { },
+    lowRateThreshold: 0.6,
+};
+export class DeliveryTracker {
+    config;
+    messages = new Map();
+    lastLowRateAlert = 0;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Register a sent message.
+     */
+    onMessageSent(msgId) {
+        this.messages.set(msgId, {
+            sentAt: Date.now(),
+            delivered: false,
+        });
+        this.pruneOldMessages();
+    }
+    /**
+     * Mark a message as delivered (status 3 or 4).
+     */
+    onDeliveryReceipt(msgId) {
+        const record = this.messages.get(msgId);
+        if (record) {
+            record.delivered = true;
+        }
+        this.pruneOldMessages();
+        this.checkDeliveryRate();
+    }
+    /**
+     * Get current delivery statistics.
+     */
+    getStats() {
+        this.pruneOldMessages();
+        const now = Date.now();
+        const cutoff = now - this.config.windowMs;
+        let sentInWindow = 0;
+        let deliveredInWindow = 0;
+        for (const record of this.messages.values()) {
+            if (record.sentAt >= cutoff) {
+                sentInWindow++;
+                if (record.delivered) {
+                    deliveredInWindow++;
+                }
+            }
+        }
+        const deliveryRate = sentInWindow >= this.config.minSampleSize
+            ? deliveredInWindow / sentInWindow
+            : null;
+        return {
+            sentInWindow,
+            deliveredInWindow,
+            deliveryRate,
+            windowMs: this.config.windowMs,
+        };
+    }
+    /**
+     * Prune messages older than the window.
+     */
+    pruneOldMessages() {
+        const now = Date.now();
+        const cutoff = now - this.config.windowMs;
+        for (const [msgId, record] of this.messages.entries()) {
+            if (record.sentAt < cutoff) {
+                this.messages.delete(msgId);
+            }
+        }
+    }
+    /**
+     * Check delivery rate and trigger callback if below threshold.
+     */
+    checkDeliveryRate() {
+        const stats = this.getStats();
+        // Only alert if we have enough samples
+        if (stats.deliveryRate === null)
+            return;
+        // Only alert once per hour to avoid spam
+        const now = Date.now();
+        if (now - this.lastLowRateAlert < 3600000)
+            return;
+        if (stats.deliveryRate < this.config.lowRateThreshold) {
+            this.lastLowRateAlert = now;
+            this.config.onLowDeliveryRate(stats.deliveryRate);
+        }
+    }
+    /**
+     * Reset all tracked messages.
+     */
+    reset() {
+        this.messages.clear();
+        this.lastLowRateAlert = 0;
+    }
+}

package/lib/AntiBan/deviceFingerprint.js

@@ -0,0 +1,106 @@
+/**
+ * Device Fingerprint Randomization
+ *
+ * Randomizes appVersion, osVersion, and deviceModel to prevent Meta's
+ * clientPayload fingerprinting. Addresses the #1 gap in anti-ban coverage.
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+// Default pools - real-world values observed in the wild
+const DEFAULT_APP_VERSION_POOL = [
+    [2, 24, 5, 18],
+    [2, 24, 5, 17],
+    [2, 24, 4, 77],
+    [2, 24, 5, 15],
+    [2, 24, 3, 91],
+    [2, 24, 5, 20],
+];
+const DEFAULT_OS_VERSION_POOL = ['10', '11', '12', '13', '14'];
+const DEFAULT_DEVICE_MODEL_POOL = [
+    'Pixel 6',
+    'Pixel 7',
+    'Galaxy S22',
+    'Galaxy S23',
+    'Xiaomi 13',
+    'Xiaomi 12',
+    'OnePlus 11',
+    'Moto G84',
+    'Moto G54',
+    'Realme 11',
+    'Vivo V29',
+    'Oppo Find X6',
+];
+/**
+ * Simple deterministic PRNG using mulberry32
+ * Seeded from string hash for consistent results per session
+ */
+class SeededRandom {
+    state;
+    constructor(seed) {
+        // Hash string to 32-bit seed
+        let hash = 0;
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i);
+            hash = hash & hash; // Convert to 32-bit int
+        }
+        this.state = Math.abs(hash) || 1;
+    }
+    next() {
+        let t = (this.state += 0x6d2b79f5);
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    }
+    pick(array) {
+        return array[Math.floor(this.next() * array.length)];
+    }
+}
+/**
+ * Generate a randomized fingerprint for one session.
+ * Stable for the same sessionId — call once per socket init.
+ */
+export function generateFingerprint(config = {}, sessionId) {
+    const { enabled = true, randomizeAppVersion = true, randomizeOsVersion = true, randomizeDeviceModel = true, seed, appVersionPool = DEFAULT_APP_VERSION_POOL, osVersionPool = DEFAULT_OS_VERSION_POOL, deviceModelPool = DEFAULT_DEVICE_MODEL_POOL, } = config;
+    const finalSessionId = sessionId || `session-${Date.now()}-${Math.random()}`;
+    const rng = new SeededRandom(seed || finalSessionId);
+    // Pick random values if enabled, otherwise use first pool item
+    const appVersion = enabled && randomizeAppVersion
+        ? rng.pick(appVersionPool)
+        : appVersionPool[0];
+    const osVersion = enabled && randomizeOsVersion ? rng.pick(osVersionPool) : osVersionPool[0];
+    const deviceModel = enabled && randomizeDeviceModel
+        ? rng.pick(deviceModelPool)
+        : deviceModelPool[0];
+    return {
+        appVersion: [...appVersion], // Copy to avoid mutation
+        osVersion,
+        deviceModel,
+        sessionId: finalSessionId,
+    };
+}
+/**
+ * Apply fingerprint to a Baileys SocketConfig before makeWASocket().
+ *
+ * Example:
+ *   const fp = generateFingerprint({});
+ *   const sock = makeWASocket(applyFingerprint(socketConfig, fp));
+ */
+export function applyFingerprint(socketConfig, fp) {
+    // Create defensive copy
+    const config = { ...socketConfig };
+    // Apply version if field exists
+    if (config.version !== undefined || 'version' in config || true) {
+        config.version = fp.appVersion;
+    }
+    // Apply browser tuple if field exists
+    // Baileys browser format: [deviceName, osVersion, appVersion]
+    if (config.browser !== undefined || 'browser' in config || true) {
+        config.browser = [
+            fp.deviceModel,
+            fp.osVersion,
+            `WhatsApp/${fp.appVersion.join('.')}`,
+        ];
+    }
+    return config;
+}

package/lib/AntiBan/fleetEventStore.js

@@ -0,0 +1,157 @@
+/**
+ * Fleet Event Store — Multi-instance coordination via shared event log
+ *
+ * Enables multiple WhatsApp instances to share ban/warn/recovery signals
+ * via a pluggable backend (MySQL, in-memory, etc).
+ *
+ * Architecture:
+ * - EventStoreBackend interface — caller provides storage
+ * - Two built-in backends:
+ *   1. MySQLEventStoreBackend — persistent, multi-instance (peer dep)
+ *   2. InMemoryEventStoreBackend — ephemeral, single-instance, testing
+ *
+ * Usage with MySQL:
+ *   import mysql from 'mysql2/promise';
+ *   const pool = mysql.createPool({ ... });
+ *   const backend = createMySQLEventStoreBackend(pool);
+ *   const store = createFleetEventStore({
+ *     connectionId: 'wa-instance-1',
+ *     backend,
+ *     pollIntervalMs: 10_000
+ *   });
+ *   store.emit('warn', { risk: 'medium' });
+ *   store.startPolling((events) => console.log('New events:', events));
+ *
+ * Usage in-memory (testing):
+ *   const backend = createInMemoryEventStoreBackend();
+ *   const store = createFleetEventStore({ connectionId: 'test', backend });
+ */
+export function createFleetEventStore(config) {
+    const { connectionId, backend, logger } = config;
+    const pollIntervalMs = config.pollIntervalMs ?? 10_000;
+    let lastSeenEpoch = Date.now();
+    let pollTimer = null;
+    const emit = async (eventType, payload) => {
+        const epoch = Date.now();
+        await backend.emit(connectionId, eventType, epoch, payload);
+        logger?.info('[fleet-events] emitted', { connectionId, eventType, epoch });
+    };
+    const startPolling = (onNewEvents) => {
+        if (pollTimer)
+            return;
+        pollTimer = setInterval(() => {
+            void (async () => {
+                try {
+                    const events = await backend.poll(connectionId, lastSeenEpoch);
+                    if (events.length > 0) {
+                        // Update cursor
+                        const maxEpoch = Math.max(...events.map((e) => e.epoch));
+                        lastSeenEpoch = maxEpoch;
+                        onNewEvents(events);
+                    }
+                }
+                catch (error) {
+                    logger?.warn('[fleet-events] poll failed', { connectionId, err: error });
+                }
+            })();
+        }, pollIntervalMs);
+        // @ts-ignore — unref exists on NodeJS.Timeout
+        pollTimer.unref?.();
+        logger?.info('[fleet-events] polling started', { connectionId, pollIntervalMs });
+    };
+    const stop = () => {
+        if (pollTimer) {
+            clearInterval(pollTimer);
+            pollTimer = null;
+            logger?.info('[fleet-events] polling stopped', { connectionId });
+        }
+    };
+    return { emit, startPolling, stop };
+}
+export function createMySQLEventStoreBackend(pool) {
+    // Ensure table exists on first emit (idempotent)
+    let tableEnsured = false;
+    const ensureTable = async () => {
+        if (tableEnsured)
+            return;
+        const createTableSQL = `
+      CREATE TABLE IF NOT EXISTS antiban_events (
+        id BIGINT AUTO_INCREMENT PRIMARY KEY,
+        connection_id VARCHAR(255) NOT NULL,
+        event_type VARCHAR(50) NOT NULL,
+        epoch BIGINT NOT NULL,
+        payload JSON,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        INDEX idx_conn (connection_id),
+        INDEX idx_epoch (epoch)
+      ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
+    `;
+        try {
+            await pool.query(createTableSQL);
+            tableEnsured = true;
+        }
+        catch (error) {
+            // Log but don't throw — table might already exist
+            console.warn('[mysql-backend] table creation failed (may already exist)', error);
+            tableEnsured = true; // Assume it exists
+        }
+    };
+    const emit = async (connectionId, eventType, epoch, payload) => {
+        try {
+            await ensureTable();
+            await pool.execute('INSERT INTO antiban_events (connection_id, event_type, epoch, payload) VALUES (?, ?, ?, ?)', [connectionId, eventType, epoch, payload ? JSON.stringify(payload) : null]);
+        }
+        catch (error) {
+            // Never throw — event emission is non-critical
+            console.warn('[mysql-backend] emit failed', { connectionId, eventType, error });
+        }
+    };
+    const poll = async (connectionId, sinceEpoch) => {
+        try {
+            await ensureTable();
+            const [rows] = (await pool.execute('SELECT id, connection_id, event_type, epoch, payload, created_at FROM antiban_events WHERE connection_id = ? AND epoch > ? ORDER BY epoch ASC LIMIT 50', [connectionId, sinceEpoch]));
+            return rows.map((row) => ({
+                id: row.id,
+                connectionId: row.connection_id,
+                eventType: row.event_type,
+                epoch: row.epoch,
+                payload: row.payload ? JSON.parse(row.payload) : null,
+                createdAt: row.created_at,
+            }));
+        }
+        catch (error) {
+            console.warn('[mysql-backend] poll failed', { connectionId, error });
+            return [];
+        }
+    };
+    return { emit, poll };
+}
+// ===============================
+// Built-in Backend: In-Memory
+// ===============================
+export function createInMemoryEventStoreBackend() {
+    const events = [];
+    let nextId = 1;
+    const emit = async (connectionId, eventType, epoch, payload) => {
+        const event = {
+            id: nextId++,
+            connectionId,
+            eventType,
+            epoch,
+            payload: payload || null,
+            createdAt: new Date(),
+        };
+        events.push(event);
+        // Evict oldest if over 1000 entries
+        if (events.length > 1000) {
+            events.shift();
+        }
+    };
+    const poll = async (connectionId, sinceEpoch) => {
+        return events
+            .filter((e) => e.connectionId === connectionId && e.epoch > sinceEpoch)
+            .sort((a, b) => a.epoch - b.epoch)
+            .slice(0, 50);
+    };
+    return { emit, poll };
+}