@prototypevip/baileys 0.0.9 → 0.1.1

package/lib/AntiBan/stateAdapter.js

@@ -1,73 +0,0 @@
-/**
- * State Adapter — Interface for persisting anti-ban state to disk/DB
- *
- * Implement this interface to save/load state between restarts.
- * Without persistence, warm-up progress is lost on every restart.
- *
- * Example implementations:
- * - File-based: JSON files in a directory
- * - Database: SQLite, PostgreSQL, MongoDB
- * - Redis: For distributed systems
- *
- * Usage:
- *   const adapter = new FileStateAdapter('./state');
- *   const antiban = new AntiBan({ stateAdapter: adapter });
- *   await antiban.loadState(); // On startup
- *   await antiban.saveState(); // Periodically or on shutdown
- */
-/**
- * Example file-based adapter using JSON files
- */
-export class FileStateAdapter {
-    basePath;
-    constructor(basePath) {
-        this.basePath = basePath;
-    }
-    async save(key, state) {
-        const fs = await import('fs/promises');
-        const path = await import('path');
-        const filePath = path.join(this.basePath, `${key}.json`);
-        await fs.mkdir(this.basePath, { recursive: true });
-        await fs.writeFile(filePath, JSON.stringify(state, null, 2), 'utf-8');
-    }
-    async load(key) {
-        const fs = await import('fs/promises');
-        const path = await import('path');
-        const filePath = path.join(this.basePath, `${key}.json`);
-        try {
-            const data = await fs.readFile(filePath, 'utf-8');
-            return JSON.parse(data);
-        }
-        catch (err) {
-            if (err.code === 'ENOENT')
-                return null;
-            throw err;
-        }
-    }
-    async delete(key) {
-        const fs = await import('fs/promises');
-        const path = await import('path');
-        const filePath = path.join(this.basePath, `${key}.json`);
-        try {
-            await fs.unlink(filePath);
-        }
-        catch (err) {
-            if (err.code !== 'ENOENT')
-                throw err;
-        }
-    }
-    async list() {
-        const fs = await import('fs/promises');
-        try {
-            const files = await fs.readdir(this.basePath);
-            return files
-                .filter(f => f.endsWith('.json'))
-                .map(f => f.replace(/\.json$/, ''));
-        }
-        catch (err) {
-            if (err.code === 'ENOENT')
-                return [];
-            throw err;
-        }
-    }
-}

package/lib/AntiBan/stateExport.js

@@ -1,152 +0,0 @@
-/**
- * Unified State Export — Single-call export/import of ALL antiban state
- *
- * Enables Redis failover and cross-instance state migration.
- * CRDT-safe rate limit counters using increment-only approach.
- *
- * Features:
- * - Single snapshot of all module states
- * - CRDT-safe rate limiter state (never overwrites higher counts)
- * - Version tracking for migration
- * - Instance tracking for debugging
- */
-/**
- * Export antiban state from individual modules.
- * Call with references to active module instances.
- */
-export function exportAntibanState(modules) {
-    const snapshot = {
-        version: 1,
-        exportedAt: Date.now(),
-        instanceId: modules.instanceId || `instance-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-    };
-    // Export warmup state
-    if (modules.warmup) {
-        snapshot.warmup = modules.warmup.exportState();
-    }
-    // Export health state
-    if (modules.health) {
-        const status = modules.health.getStatus();
-        snapshot.health = {
-            riskScore: status.score,
-            disconnectEvents: [], // Health module doesn't expose raw events, only aggregate stats
-        };
-    }
-    // Export rate limiter state (CRDT-safe)
-    if (modules.rateLimiter) {
-        const stats = modules.rateLimiter.getStats();
-        snapshot.rateLimiter = {
-            messages: [], // We don't expose raw messages, rely on knownChats + counters
-            knownChats: Array.from(modules.rateLimiter.getKnownChats()),
-            identicalCount: {},
-            burstCount: 0,
-            lastMessageTime: Date.now(),
-            currentFactor: modules.rateLimiter.getCurrentFactor(),
-            sentSinceExport: stats.lastDay, // Use last day count as increment baseline
-        };
-    }
-    // Export circuit breaker states (BUG FIX 2)
-    if (modules.circuits?.exportState) {
-        snapshot.circuits = modules.circuits.exportState();
-    }
-    // Export timelock guard state
-    if (modules.timelockGuard) {
-        const state = modules.timelockGuard.getState();
-        const knownChats = modules.timelockGuard.getKnownChats ? Array.from(modules.timelockGuard.getKnownChats()) : [];
-        snapshot.timelockGuard = {
-            active: state.isActive,
-            expiresAt: state.expiresAt ? state.expiresAt.getTime() : undefined,
-            affectedJids: knownChats,
-            enforcementType: state.enforcementType,
-        };
-    }
-    // Export message registry state
-    if (modules.messageRegistry) {
-        snapshot.messageRegistry = modules.messageRegistry.exportState();
-    }
-    // Export topology throttler state
-    if (modules.topologyThrottler) {
-        snapshot.topologyThrottler = modules.topologyThrottler.exportState();
-    }
-    // Export reputation voucher state
-    if (modules.reputationVoucher) {
-        snapshot.reputationVoucher = modules.reputationVoucher.exportState();
-    }
-    // Export engagement scores
-    if (modules.engagementScores) {
-        snapshot.engagementScores = Object.fromEntries(modules.engagementScores.entries());
-    }
-    return snapshot;
-}
-/**
- * Import antiban state into modules.
- * CRDT-safe for rate limiters (never overwrites higher counts).
- */
-export function importAntibanState(snapshot, modules) {
-    // Import warmup state
-    if (snapshot.warmup && modules.warmup?.importState) {
-        modules.warmup.importState(snapshot.warmup);
-    }
-    // Import health state (reset to clean state, can't import raw events)
-    if (snapshot.health && modules.health?.reset) {
-        modules.health.reset();
-    }
-    // Import rate limiter state (CRDT-safe)
-    if (snapshot.rateLimiter && modules.rateLimiter) {
-        // Restore known chats
-        if (snapshot.rateLimiter.knownChats) {
-            modules.rateLimiter.restoreKnownChats(snapshot.rateLimiter.knownChats);
-        }
-        // CRDT-safe merge: only restore factor if not already higher
-        const currentStats = modules.rateLimiter.getStats();
-        const currentCount = currentStats.lastDay;
-        const snapshotCount = snapshot.rateLimiter.sentSinceExport;
-        // If current count is lower, we're likely a fresh instance, so restore factor
-        if (currentCount < snapshotCount) {
-            modules.rateLimiter.adaptLimits(snapshot.rateLimiter.currentFactor);
-        }
-        // If current count is higher, keep current state (concurrent instance ahead)
-    }
-    // Import circuit breaker states (BUG FIX 2)
-    if (snapshot.circuits && modules.circuits?.importState) {
-        modules.circuits.importState(snapshot.circuits);
-    }
-    // Import timelock guard state
-    if (snapshot.timelockGuard && modules.timelockGuard) {
-        if (snapshot.timelockGuard.active && modules.timelockGuard.onTimelockUpdate) {
-            const expiresAt = snapshot.timelockGuard.expiresAt
-                ? new Date(snapshot.timelockGuard.expiresAt)
-                : undefined;
-            modules.timelockGuard.onTimelockUpdate({
-                isActive: snapshot.timelockGuard.active,
-                timeEnforcementEnds: expiresAt,
-                enforcementType: snapshot.timelockGuard.enforcementType,
-            });
-            // Restore known chats
-            if (snapshot.timelockGuard.affectedJids && modules.timelockGuard.registerKnownChats) {
-                modules.timelockGuard.registerKnownChats(snapshot.timelockGuard.affectedJids);
-            }
-        }
-        else {
-            modules.timelockGuard.reset();
-        }
-    }
-    // Import message registry state
-    if (snapshot.messageRegistry && modules.messageRegistry) {
-        modules.messageRegistry.importState(snapshot.messageRegistry);
-    }
-    // Import topology throttler state
-    if (snapshot.topologyThrottler && modules.topologyThrottler) {
-        modules.topologyThrottler.importState(snapshot.topologyThrottler);
-    }
-    // Import reputation voucher state
-    if (snapshot.reputationVoucher && modules.reputationVoucher) {
-        modules.reputationVoucher.importState(snapshot.reputationVoucher);
-    }
-    // Import engagement scores
-    if (snapshot.engagementScores && modules.engagementScores) {
-        for (const [jid, score] of Object.entries(snapshot.engagementScores)) {
-            modules.engagementScores.set(jid, score);
-        }
-    }
-}

package/lib/AntiBan/stealthConnect.js

@@ -1,130 +0,0 @@
-/**
- * Stealth Connect — Reduce ban signal on socket connect + presence ramp
- *
- * Inspired by GOWA's --presence-on-connect=unavailable flag. Bots that
- * snap online immediately and start blasting messages look suspicious to
- * WhatsApp's anti-spam classifier. This module ships two helpers:
- *
- *   - `getStealthSocketConfig()` returns a partial Baileys socket config
- *     that disables `markOnlineOnConnect` and provides a non-default
- *     browser fingerprint (random pick from a small pool unless overridden).
- *
- *   - `rampPresenceAfterConnect()` waits a randomized delay, then issues
- *     `sendPresenceUpdate('available')`. Supports `AbortSignal` so the
- *     caller can cancel if the socket dies before the timer fires.
- *
- * Usage:
- *   const config = getStealthSocketConfig({ os: 'MyApp' });
- *   const sock = makeWASocket({ ...config, auth: state });
- *
- *   const ac = new AbortController();
- *   sock.ev.on('connection.update', u => {
- *     if (u.connection === 'close') ac.abort();
- *   });
- *   await rampPresenceAfterConnect(sock, { signal: ac.signal });
- */
-/**
- * Pool of realistic browser fingerprints.
- *
- * Values match formats actually emitted by WhatsApp Web clients in the wild.
- * `getStealthSocketConfig()` picks one at random when caller does not supply
- * an explicit `browser` or `os` option, so multiple consumers of the library
- * do not all advertise an identical fingerprint (which would be trivially
- * cluster-able by WhatsApp).
- *
- * Exported so callers can extend or override the pool if desired.
- */
-export const STEALTH_BROWSER_POOL = Object.freeze([
-    ['Mac OS', 'Chrome', '120.0.6099.109'],
-    ['Mac OS', 'Safari', '17.2.1'],
-    ['Windows', 'Chrome', '121.0.6167.85'],
-    ['Windows', 'Firefox', '122.0'],
-    ['Windows', 'Edge', '120.0.2210.144'],
-    ['Linux', 'Chrome', '120.0.6099.109'],
-    ['Linux', 'Firefox', '122.0'],
-    ['Ubuntu', 'Chrome', '121.0.6167.85'],
-]);
-/**
- * Returns a partial Baileys socket config tuned for stealth connect.
- *
- * - `markOnlineOnConnect` set to `false` so the socket joins without
- *   broadcasting `available` (matches GOWA's `presence-on-connect=unavailable`).
- * - `browser` is a randomized realistic tuple from `STEALTH_BROWSER_POOL`
- *   unless overridden via `opts.browser` or `opts.os`.
- *
- * Merge the result into your `makeWASocket` options:
- *
- *   const sock = makeWASocket({ ...getStealthSocketConfig(), auth: state });
- */
-export function getStealthSocketConfig(opts) {
-    const random = opts?.random ?? Math.random;
-    let browser;
-    if (opts?.browser) {
-        browser = opts.browser;
-    }
-    else {
-        const pick = STEALTH_BROWSER_POOL[Math.floor(random() * STEALTH_BROWSER_POOL.length)];
-        // pick is guaranteed defined — pool is non-empty and frozen.
-        const tuple = pick;
-        if (opts?.os) {
-            browser = [opts.os, tuple[1], tuple[2]];
-        }
-        else {
-            browser = [tuple[0], tuple[1], tuple[2]];
-        }
-    }
-    return {
-        markOnlineOnConnect: false,
-        browser,
-    };
-}
-/**
- * Custom error thrown when `rampPresenceAfterConnect` is aborted via signal.
- * Mirrors DOM `AbortError` semantics so consumers can `instanceof` check.
- */
-export class AbortError extends Error {
-    name = 'AbortError';
-    constructor(message = 'rampPresenceAfterConnect aborted') {
-        super(message);
-    }
-}
-/**
- * Waits a randomized delay then calls `sock.sendPresenceUpdate(targetState)`.
- *
- * Supports `AbortSignal` — abort during the delay window cancels the timer
- * and rejects the returned promise with `AbortError`. Aborting after the
- * presence update has already been sent is a no-op.
- *
- * Caller is responsible for invoking abort when the socket disconnects;
- * otherwise the post-delay `sendPresenceUpdate` may run against a dead
- * socket.
- */
-export async function rampPresenceAfterConnect(sock, opts) {
-    const minDelayMs = opts?.minDelayMs ?? 30000;
-    const maxDelayMs = opts?.maxDelayMs ?? 90000;
-    const targetState = opts?.targetState ?? 'available';
-    const random = opts?.random ?? Math.random;
-    const signal = opts?.signal;
-    if (signal?.aborted) {
-        throw new AbortError();
-    }
-    const range = Math.max(0, maxDelayMs - minDelayMs);
-    const delayMs = Math.floor(random() * (range + 1)) + minDelayMs;
-    await new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
-            if (signal) {
-                signal.removeEventListener('abort', onAbort);
-            }
-            resolve();
-        }, delayMs);
-        const onAbort = () => {
-            clearTimeout(timer);
-            reject(new AbortError());
-        };
-        if (signal) {
-            signal.addEventListener('abort', onAbort, { once: true });
-        }
-    });
-    // jid undefined => broadcast presence to all conversations
-    await sock.sendPresenceUpdate(targetState, undefined);
-}

package/lib/AntiBan/timelockGuard.js

@@ -1,181 +0,0 @@
-/**
- * Timelock Guard — Manages reachout timelock state and routing decisions
- *
- * When WhatsApp timelocks an account (463 error), this guard:
- * - Tracks the timelock state (active, expiry, enforcement type)
- * - Blocks messages to NEW contacts (no tctoken / no prior chat)
- * - Allows messages to EXISTING contacts (have tctoken / prior chat history)
- * - Auto-resumes when the timelock expires
- * - Fires callbacks for alerting (Telegram/Discord/webhook)
- */
-const DEFAULT_CONFIG = {
-    resumeBufferMs: 10_000,
-};
-export class TimelockGuard {
-    config;
-    state = {
-        isActive: false,
-        errorCount: 0,
-    };
-    knownChats = new Set();
-    resumeTimer = null;
-    timerGeneration = 0; // BUG FIX 4: Track timer validity to prevent race conditions
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Update timelock state from Baileys connection.update event
-     */
-    onTimelockUpdate(data) {
-        const wasActive = this.state.isActive;
-        this.state.isActive = !!data.isActive;
-        this.state.enforcementType = data.enforcementType;
-        this.state.expiresAt = data.timeEnforcementEnds;
-        if (this.state.isActive && !wasActive) {
-            this.state.detectedAt = new Date();
-            this.state.errorCount = 0;
-            this.config.onTimelockDetected?.(this.getState());
-            this.scheduleResume();
-        }
-        else if (this.state.isActive && wasActive) {
-            // Already locked but expiry updated — reschedule timer with new expiry
-            this.scheduleResume();
-        }
-        if (!this.state.isActive && wasActive) {
-            this.clearResumeTimer();
-            this.config.onTimelockLifted?.(this.getState());
-        }
-    }
-    /**
-     * Record a 463 error from a failed send
-     */
-    record463Error() {
-        this.state.errorCount++;
-        if (!this.state.isActive) {
-            // First 463 before MEX query returns — assume locked for 60s
-            this.state.isActive = true;
-            this.state.detectedAt = new Date();
-            this.state.expiresAt = new Date(Date.now() + 60_000);
-            this.config.onTimelockDetected?.(this.getState());
-            this.scheduleResume();
-        }
-    }
-    /**
-     * Register a JID as a known/existing chat (has tctoken / prior history)
-     */
-    registerKnownChat(jid) {
-        this.knownChats.add(jid);
-    }
-    /**
-     * Register multiple known chats at once (e.g. from chat list on connect)
-     */
-    registerKnownChats(jids) {
-        for (const jid of jids) {
-            this.knownChats.add(jid);
-        }
-    }
-    /**
-     * Check if a message to this recipient should be allowed
-     */
-    canSend(jid) {
-        if (!this.state.isActive) {
-            return { allowed: true };
-        }
-        // Check if expiry has passed (with buffer)
-        if (this.state.expiresAt) {
-            const expiryWithBuffer = this.state.expiresAt.getTime() + this.config.resumeBufferMs;
-            if (Date.now() >= expiryWithBuffer) {
-                this.lift();
-                return { allowed: true };
-            }
-        }
-        // Groups always flow (tctokens not required for group msgs)
-        if (jid.endsWith('@g.us') || jid.endsWith('@newsletter')) {
-            return { allowed: true };
-        }
-        // Known chats (have tctoken) can proceed
-        if (this.knownChats.has(jid)) {
-            return { allowed: true };
-        }
-        // New contact while timelocked — block
-        const expiresIn = this.state.expiresAt
-            ? Math.max(0, this.state.expiresAt.getTime() - Date.now())
-            : 60_000;
-        return {
-            allowed: false,
-            reason: `Reachout timelocked (${this.state.enforcementType || 'unknown'}). `
-                + `New contacts blocked. Expires in ${Math.ceil(expiresIn / 1000)}s.`,
-        };
-    }
-    /**
-     * Get current timelock state
-     */
-    getState() {
-        return { ...this.state };
-    }
-    /**
-     * Check if currently timelocked
-     */
-    isTimelocked() {
-        if (!this.state.isActive)
-            return false;
-        // Auto-lift if expired
-        if (this.state.expiresAt) {
-            const expiryWithBuffer = this.state.expiresAt.getTime() + this.config.resumeBufferMs;
-            if (Date.now() >= expiryWithBuffer) {
-                this.lift();
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Get the set of known chat JIDs
-     */
-    getKnownChats() {
-        return new Set(this.knownChats);
-    }
-    /**
-     * Manually lift the timelock
-     */
-    lift() {
-        if (this.state.isActive) {
-            this.state.isActive = false;
-            this.clearResumeTimer();
-            this.config.onTimelockLifted?.(this.getState());
-        }
-    }
-    /**
-     * Reset all state
-     */
-    reset() {
-        this.state = { isActive: false, errorCount: 0 };
-        this.knownChats.clear();
-        this.clearResumeTimer();
-    }
-    scheduleResume() {
-        this.clearResumeTimer();
-        if (this.state.expiresAt) {
-            const delay = this.state.expiresAt.getTime() - Date.now() + this.config.resumeBufferMs;
-            if (delay > 0) {
-                // BUG FIX 4: Increment generation to invalidate any pending timers
-                this.timerGeneration++;
-                const currentGeneration = this.timerGeneration;
-                this.resumeTimer = setTimeout(() => {
-                    // Only lift if this timer is still valid (not superseded by a newer scheduleResume call)
-                    if (currentGeneration === this.timerGeneration) {
-                        this.lift();
-                    }
-                }, delay);
-            }
-        }
-    }
-    clearResumeTimer() {
-        if (this.resumeTimer) {
-            clearTimeout(this.resumeTimer);
-            this.resumeTimer = null;
-            // Increment generation to invalidate any pending timer callbacks
-            this.timerGeneration++;
-        }
-    }
-}