@prototypevip/baileys 0.0.8 → 0.0.9

package/lib/AntiBan/groupOperationGuard.js

@@ -0,0 +1,116 @@
+/**
+ * GroupOperationGuard — Rate limiting for WhatsApp group operations
+ *
+ * Prevents account_reachout_restricted and rate-overlimit errors
+ * by enforcing per-operation windows on group adds, removes, and creates.
+ *
+ * WA unofficial limits (observed):
+ *   - groupParticipantsUpdate (add): ~3 new contacts per 10 min
+ *   - groupCreate: ~2 per 10 min
+ *   - Rapid retries after 403: triggers account_reachout_restricted
+ */
+const DEFAULT_LIMITS = {
+    add: { max: 3, windowMs: 10 * 60 * 1000 }, // 3 adds / 10 min
+    remove: { max: 5, windowMs: 10 * 60 * 1000 }, // 5 removes / 10 min
+    create: { max: 2, windowMs: 10 * 60 * 1000 }, // 2 creates / 10 min
+    invite: { max: 10, windowMs: 10 * 60 * 1000 }, // 10 invite fetches / 10 min
+};
+/**
+ * Known WA error patterns for group operations.
+ * Use with classifyGroupOpError() to classify errors before retrying.
+ */
+export const GROUP_OP_ERRORS = {
+    REACHOUT_RESTRICTED: 'account_reachout_restricted',
+    RATE_OVERLIMIT: 'rate-overlimit',
+    PRIVACY_BLOCK: '403', // groupParticipantsUpdate returned status '403'
+    INVITE_EXPIRED: 'gone', // groupInviteCode returned 'gone' — code expired
+    GROUP_LOCKED: 'locked', // groupRevokeInvite returned 'locked'
+};
+/**
+ * Classify a caught error from a group operation.
+ */
+export function classifyGroupOpError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes('account_reachout_restricted') || msg.includes('reachout'))
+        return GROUP_OP_ERRORS.REACHOUT_RESTRICTED;
+    if (msg.includes('rate-overlimit') || msg.includes('429'))
+        return GROUP_OP_ERRORS.RATE_OVERLIMIT;
+    if (msg.includes('locked'))
+        return GROUP_OP_ERRORS.GROUP_LOCKED;
+    if (msg.includes('gone'))
+        return GROUP_OP_ERRORS.INVITE_EXPIRED;
+    return null;
+}
+export function extractPrivacyBlock(result) {
+    if (!Array.isArray(result))
+        return { blocked: false };
+    for (const r of result) {
+        const entry = r;
+        if (entry.status !== '403')
+            continue;
+        // Traverse content to find add_request with code
+        const content = Array.isArray(entry.content) ? entry.content : [];
+        for (const c of content) {
+            if (c.tag === 'add_request' && typeof c.attrs === 'object') {
+                const attrs = c.attrs;
+                if (attrs.code) {
+                    return {
+                        blocked: true,
+                        inviteCode: attrs.code,
+                        inviteLink: `https://chat.whatsapp.com/${attrs.code}`,
+                    };
+                }
+            }
+        }
+        // 403 without invite code — privacy block but WA didn't provide link
+        return { blocked: true };
+    }
+    return { blocked: false };
+}
+export class GroupOperationGuard {
+    limits;
+    windows = new Map();
+    constructor(config = {}) {
+        this.limits = { ...DEFAULT_LIMITS, ...config.limits };
+    }
+    /**
+     * Check whether an operation is allowed under the current rate limits.
+     * @param op   Operation type
+     * @param key  Unique key scoping the limit (e.g. groupJid, clientId, or composite)
+     */
+    check(op, key) {
+        const limit = this.limits[op];
+        const windowKey = `${op}:${key}`;
+        const now = Date.now();
+        const entry = this.windows.get(windowKey);
+        if (!entry || now > entry.resetAt) {
+            this.windows.set(windowKey, { count: 1, resetAt: now + limit.windowMs });
+            return { allowed: true };
+        }
+        if (entry.count >= limit.max) {
+            const retryAfterSec = Math.ceil((entry.resetAt - now) / 1000);
+            return {
+                allowed: false,
+                reason: `Too many ${op} attempts. WhatsApp rate-limits group operations — wait ${Math.ceil(retryAfterSec / 60)} min before trying again.`,
+                retryAfterSec,
+            };
+        }
+        entry.count++;
+        return { allowed: true };
+    }
+    /**
+     * Reset the counter for a specific operation + key.
+     * Call this if you want to allow immediate retry after a successful operation.
+     */
+    reset(op, key) {
+        this.windows.delete(`${op}:${key}`);
+    }
+    /** Snapshot of all active windows (for observability). */
+    getStats() {
+        const stats = {};
+        for (const [key, val] of this.windows) {
+            stats[key] = { ...val };
+        }
+        return stats;
+    }
+}

package/lib/AntiBan/health.js

@@ -0,0 +1,207 @@
+/**
+ * Health Monitor — Detect ban warning signs early
+ *
+ * Tracks connection patterns to identify when WhatsApp is
+ * getting suspicious. Gives you time to back off before a ban.
+ *
+ * Warning signs:
+ * - Frequent disconnections (connection.update → close)
+ * - 403 Forbidden errors
+ * - 401 Logged Out (possible temp ban)
+ * - Messages failing silently (sent but not delivered)
+ * - QR re-request loops
+ * - Rate limit responses (429-like behavior)
+ */
+const DEFAULT_CONFIG = {
+    disconnectWarningThreshold: 3,
+    disconnectCriticalThreshold: 5,
+    failedMessageThreshold: 5,
+    autoPauseAt: 'high',
+};
+export class HealthMonitor {
+    config;
+    events = [];
+    startTime = Date.now();
+    paused = false;
+    lastRisk = 'low';
+    lastBadEventTime = Date.now();
+    lastEventWasSevere = false;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Record a disconnection event
+     */
+    recordDisconnect(reason) {
+        const reasonStr = String(reason);
+        if (reasonStr === '403' || reasonStr === 'forbidden') {
+            this.events.push({ type: 'forbidden', timestamp: Date.now(), detail: reasonStr });
+            this.lastBadEventTime = Date.now();
+            this.lastEventWasSevere = true;
+        }
+        else if (reasonStr === '401' || reasonStr === 'loggedOut') {
+            this.events.push({ type: 'loggedOut', timestamp: Date.now(), detail: reasonStr });
+            this.lastBadEventTime = Date.now();
+            this.lastEventWasSevere = true;
+        }
+        else {
+            this.events.push({ type: 'disconnect', timestamp: Date.now(), detail: reasonStr });
+            this.lastBadEventTime = Date.now();
+            this.lastEventWasSevere = false;
+        }
+        this.checkAndNotify();
+    }
+    /**
+     * Record a successful reconnection
+     */
+    recordReconnect() {
+        this.events.push({ type: 'reconnect', timestamp: Date.now() });
+    }
+    /**
+     * Record a failed message send
+     */
+    recordMessageFailed(error) {
+        this.events.push({ type: 'messageFailed', timestamp: Date.now(), detail: error });
+        this.lastBadEventTime = Date.now();
+        this.lastEventWasSevere = false;
+        this.checkAndNotify();
+    }
+    /**
+     * Record a 463 reachout timelock error
+     */
+    recordReachoutTimelock(detail) {
+        this.events.push({ type: 'reachoutTimelocked', timestamp: Date.now(), detail });
+        this.lastBadEventTime = Date.now();
+        this.lastEventWasSevere = false;
+        this.checkAndNotify();
+    }
+    /**
+     * Get current health status
+     */
+    getStatus() {
+        const now = Date.now();
+        this.cleanup(now);
+        const hourEvents = this.events.filter(e => now - e.timestamp < 3600000);
+        const disconnects = hourEvents.filter(e => e.type === 'disconnect').length;
+        const forbidden = hourEvents.filter(e => e.type === 'forbidden').length;
+        const loggedOut = hourEvents.filter(e => e.type === 'loggedOut').length;
+        const failedMessages = hourEvents.filter(e => e.type === 'messageFailed').length;
+        let score = 0;
+        const reasons = [];
+        // Forbidden errors are serious
+        if (forbidden > 0) {
+            score += 40 * forbidden;
+            reasons.push(`${forbidden} forbidden (403) error${forbidden > 1 ? 's' : ''} in last hour`);
+        }
+        // Logged out is very serious
+        if (loggedOut > 0) {
+            score += 60;
+            reasons.push('Logged out by WhatsApp — possible temporary ban');
+        }
+        // Reachout timelocked (463)
+        const timelocked = hourEvents.filter(e => e.type === 'reachoutTimelocked').length;
+        if (timelocked > 0) {
+            score += 25;
+            reasons.push(`${timelocked} reachout timelock (463) error${timelocked > 1 ? 's' : ''} in last hour`);
+        }
+        // Frequent disconnects
+        if (disconnects >= this.config.disconnectCriticalThreshold) {
+            score += 30;
+            reasons.push(`${disconnects} disconnects in last hour (critical threshold)`);
+        }
+        else if (disconnects >= this.config.disconnectWarningThreshold) {
+            score += 30;
+            reasons.push(`${disconnects} disconnects in last hour`);
+        }
+        // Failed messages
+        if (failedMessages >= this.config.failedMessageThreshold) {
+            score += 20;
+            reasons.push(`${failedMessages} failed messages in last hour`);
+        }
+        // Determine risk level
+        score = Math.min(100, score);
+        // Tiered decay: recover based on time since last bad event
+        // Severe (403/401): 2pts/min — ~50min to clear 100pts
+        // Normal: 5pts/min — ~20min to clear 100pts
+        const minutesSinceLastBad = (now - this.lastBadEventTime) / 60000;
+        const decayRate = this.lastEventWasSevere ? 2 : 5;
+        score = Math.max(0, score - Math.floor(minutesSinceLastBad * decayRate));
+        let risk;
+        if (score >= 80)
+            risk = 'critical';
+        else if (score >= 40)
+            risk = 'high';
+        else if (score >= 15)
+            risk = 'medium';
+        else
+            risk = 'low';
+        // Determine recommendation
+        let recommendation;
+        switch (risk) {
+            case 'critical':
+                recommendation = 'STOP ALL MESSAGING IMMEDIATELY. Disconnect and wait 24-48 hours before reconnecting.';
+                break;
+            case 'high':
+                recommendation = 'Reduce messaging rate by 80%. Consider pausing for 1-2 hours.';
+                break;
+            case 'medium':
+                recommendation = 'Reduce messaging rate by 50%. Increase delays between messages.';
+                break;
+            default:
+                recommendation = 'Operating normally. Continue monitoring.';
+        }
+        const lastDisconnect = [...this.events].reverse().find(e => e.type === 'disconnect' || e.type === 'forbidden' || e.type === 'loggedOut');
+        return {
+            risk,
+            score,
+            reasons: reasons.length ? reasons : ['No issues detected'],
+            recommendation,
+            stats: {
+                disconnectsLastHour: disconnects,
+                failedMessagesLastHour: failedMessages,
+                forbiddenErrors: forbidden,
+                timelockErrors: timelocked,
+                uptimeMs: now - this.startTime,
+                lastDisconnectReason: lastDisconnect?.detail,
+            },
+        };
+    }
+    /**
+     * Check if sending should be paused
+     */
+    isPaused() {
+        if (this.paused)
+            return true;
+        const status = this.getStatus();
+        const riskOrder = ['low', 'medium', 'high', 'critical'];
+        return riskOrder.indexOf(status.risk) >= riskOrder.indexOf(this.config.autoPauseAt);
+    }
+    /**
+     * Manually pause/resume
+     */
+    setPaused(paused) {
+        this.paused = paused;
+    }
+    /**
+     * Reset all tracked events
+     */
+    reset() {
+        this.events = [];
+        this.startTime = Date.now();
+        this.paused = false;
+        this.lastRisk = 'low';
+        this.lastBadEventTime = Date.now();
+        this.lastEventWasSevere = false;
+    }
+    cleanup(now) {
+        // Keep last 6 hours of events
+        this.events = this.events.filter(e => now - e.timestamp < 21600000);
+    }
+    checkAndNotify() {
+        const status = this.getStatus();
+        if (status.risk !== this.lastRisk) {
+            this.lastRisk = status.risk;
+            this.config.onRiskChange?.(status);
+        }
+    }
+}

package/lib/AntiBan/humanEntropy.js

@@ -0,0 +1,337 @@
+/**
+ * HumanEntropyService — Background noise for WA sessions
+ *
+ * Runs periodic human-like actions to make idle sessions appear more realistic:
+ * - Random typing presence to recent contacts
+ * - Delayed read receipts
+ * - Availability status toggles
+ *
+ * Design:
+ * - Works ONLY with WaSP's public API (no direct socket access)
+ * - Fail-silent (never crashes wa-pa)
+ * - Configurable intervals and probabilities
+ * - Only interacts with contacts who messaged first (never strangers)
+ */
+const DEFAULT_CONFIG = {
+    enabled: true,
+    minIntervalMs: 2 * 60 * 60 * 1000, // 2 hours
+    maxIntervalMs: 6 * 60 * 60 * 1000, // 6 hours
+    maxRecentContacts: 30,
+    typingProbability: 0.3,
+    typingMinMs: 3000,
+    typingMaxMs: 8000,
+    readReceiptProbability: 0.2,
+    readReceiptMinDelayMs: 10 * 60 * 1000, // 10 min
+    readReceiptMaxDelayMs: 60 * 60 * 1000, // 60 min
+    presenceToggleProbability: 0.15,
+    presenceToggleMinMs: 30 * 1000, // 30 sec
+    presenceToggleMaxMs: 2 * 60 * 1000, // 2 min
+};
+/**
+ * Human entropy service
+ *
+ * Adds realistic background noise to WhatsApp sessions by performing
+ * random human-like actions periodically.
+ */
+export class HumanEntropyService {
+    config;
+    wasp; // WaSP instance
+    sessionId;
+    recentContacts = [];
+    unreadMessages = [];
+    cycleTimer = null;
+    isRunning = false;
+    stats = {
+        cyclesExecuted: 0,
+        typingActionsPerformed: 0,
+        readReceiptsMarked: 0,
+        presenceToggles: 0,
+        errors: 0,
+        lastCycleAt: null,
+        nextCycleAt: null,
+    };
+    constructor(wasp, sessionId, config = {}) {
+        this.wasp = wasp;
+        this.sessionId = sessionId;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        // Listen to MESSAGE_RECEIVED events to track recent contacts
+        this.wasp.on('MESSAGE_RECEIVED', (event) => {
+            if (event.sessionId === this.sessionId) {
+                this.trackIncomingMessage(event.data);
+            }
+        });
+        this.log('info', 'HumanEntropyService initialized', {
+            enabled: this.config.enabled,
+            minInterval: this.config.minIntervalMs,
+            maxInterval: this.config.maxIntervalMs,
+        });
+    }
+    /**
+     * Start the entropy service
+     */
+    start() {
+        if (!this.config.enabled) {
+            this.log('info', 'Entropy service disabled, not starting');
+            return;
+        }
+        if (this.isRunning) {
+            this.log('warn', 'Entropy service already running');
+            return;
+        }
+        this.isRunning = true;
+        this.scheduleNextCycle();
+        this.log('info', 'Entropy service started');
+    }
+    /**
+     * Stop the entropy service
+     */
+    stop() {
+        this.isRunning = false;
+        if (this.cycleTimer) {
+            clearTimeout(this.cycleTimer);
+            this.cycleTimer = null;
+        }
+        this.stats.nextCycleAt = null;
+        this.log('info', 'Entropy service stopped');
+    }
+    /**
+     * Get current statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Track incoming message to build recent contacts list
+     */
+    trackIncomingMessage(message) {
+        try {
+            // Skip outgoing messages
+            if (message.fromMe)
+                return;
+            const jid = message.from || message.chatId;
+            if (!jid)
+                return;
+            // Update or add to recent contacts
+            const existingIndex = this.recentContacts.findIndex(c => c.jid === jid);
+            if (existingIndex >= 0) {
+                this.recentContacts[existingIndex].lastMessageAt = new Date();
+            }
+            else {
+                this.recentContacts.push({
+                    jid,
+                    lastMessageAt: new Date(),
+                    isGroup: message.isGroup ?? false,
+                });
+            }
+            // Trim to max size (keep most recent)
+            if (this.recentContacts.length > this.config.maxRecentContacts) {
+                this.recentContacts.sort((a, b) => b.lastMessageAt.getTime() - a.lastMessageAt.getTime());
+                this.recentContacts = this.recentContacts.slice(0, this.config.maxRecentContacts);
+            }
+            // Track for potential read receipt
+            if (message.id && message.key) {
+                this.unreadMessages.push({
+                    jid,
+                    messageKey: message.key,
+                    receivedAt: new Date(),
+                });
+                // Trim old unread messages (keep last 50)
+                if (this.unreadMessages.length > 50) {
+                    this.unreadMessages = this.unreadMessages.slice(-50);
+                }
+            }
+        }
+        catch (error) {
+            this.log('error', 'Error tracking incoming message', { error: error.message });
+        }
+    }
+    /**
+     * Schedule next entropy cycle
+     */
+    scheduleNextCycle() {
+        if (!this.isRunning)
+            return;
+        const delay = this.randomBetween(this.config.minIntervalMs, this.config.maxIntervalMs);
+        this.stats.nextCycleAt = new Date(Date.now() + delay);
+        this.cycleTimer = setTimeout(() => {
+            this.executeCycle().catch(error => {
+                this.log('error', 'Entropy cycle failed', { error: error.message });
+                this.stats.errors++;
+            }).finally(() => {
+                this.scheduleNextCycle();
+            });
+        }, delay);
+        this.log('debug', `Next entropy cycle in ${Math.floor(delay / 1000)}s`);
+    }
+    /**
+     * Execute one entropy cycle
+     */
+    async executeCycle() {
+        if (!this.isRunning || this.recentContacts.length === 0) {
+            return;
+        }
+        this.log('info', 'Starting entropy cycle', {
+            recentContactsCount: this.recentContacts.length,
+            unreadMessagesCount: this.unreadMessages.length,
+        });
+        this.stats.cyclesExecuted++;
+        this.stats.lastCycleAt = new Date();
+        const actions = [];
+        // Action 1: Random typing presence
+        if (Math.random() < this.config.typingProbability) {
+            actions.push(this.performTypingPresence());
+        }
+        // Action 2: Mark random message as read
+        if (Math.random() < this.config.readReceiptProbability && this.unreadMessages.length > 0) {
+            actions.push(this.performReadReceipt());
+        }
+        // Action 3: Toggle presence status
+        if (Math.random() < this.config.presenceToggleProbability) {
+            actions.push(this.performPresenceToggle());
+        }
+        // Execute all actions in parallel
+        await Promise.allSettled(actions);
+    }
+    /**
+     * Send typing presence to a random recent contact
+     */
+    async performTypingPresence() {
+        try {
+            // Pick a random non-group contact
+            const eligibleContacts = this.recentContacts.filter(c => !c.isGroup);
+            if (eligibleContacts.length === 0) {
+                this.log('debug', 'No eligible contacts for typing presence');
+                return;
+            }
+            const contact = eligibleContacts[Math.floor(Math.random() * eligibleContacts.length)];
+            const duration = this.randomBetween(this.config.typingMinMs, this.config.typingMaxMs);
+            this.log('info', `Entropy action: typing to ${this.maskJid(contact.jid)} for ${duration}ms`);
+            // Get provider to access socket
+            const provider = this.wasp.getProvider(this.sessionId);
+            if (!provider || !provider.socket) {
+                throw new Error('Provider or socket not available');
+            }
+            // Send composing presence
+            await provider.socket.sendPresenceUpdate('composing', contact.jid);
+            // Wait for duration
+            await this.sleep(duration);
+            // Send paused presence
+            await provider.socket.sendPresenceUpdate('paused', contact.jid);
+            this.stats.typingActionsPerformed++;
+        }
+        catch (error) {
+            this.log('error', 'Error performing typing presence', { error: error.message });
+            this.stats.errors++;
+        }
+    }
+    /**
+     * Mark a random recent message as read with delay
+     */
+    async performReadReceipt() {
+        try {
+            const message = this.unreadMessages[Math.floor(Math.random() * this.unreadMessages.length)];
+            if (!message)
+                return;
+            const delay = this.randomBetween(this.config.readReceiptMinDelayMs, this.config.readReceiptMaxDelayMs);
+            this.log('info', `Entropy action: mark read ${this.maskJid(message.jid)} after ${Math.floor(delay / 1000)}s`);
+            // Wait for delay
+            await this.sleep(delay);
+            // Get provider to access socket
+            const provider = this.wasp.getProvider(this.sessionId);
+            if (!provider || !provider.socket) {
+                throw new Error('Provider or socket not available');
+            }
+            // Mark as read
+            await provider.socket.readMessages([message.messageKey]);
+            // Remove from unread list
+            this.unreadMessages = this.unreadMessages.filter(m => m !== message);
+            this.stats.readReceiptsMarked++;
+        }
+        catch (error) {
+            this.log('error', 'Error performing read receipt', { error: error.message });
+            this.stats.errors++;
+        }
+    }
+    /**
+     * Toggle presence status (available → unavailable)
+     */
+    async performPresenceToggle() {
+        try {
+            const duration = this.randomBetween(this.config.presenceToggleMinMs, this.config.presenceToggleMaxMs);
+            this.log('info', `Entropy action: presence toggle for ${Math.floor(duration / 1000)}s`);
+            // Get provider to access socket
+            const provider = this.wasp.getProvider(this.sessionId);
+            if (!provider || !provider.socket) {
+                throw new Error('Provider or socket not available');
+            }
+            // Set available
+            await provider.socket.sendPresenceUpdate('available');
+            // Wait for duration
+            await this.sleep(duration);
+            // Set unavailable
+            await provider.socket.sendPresenceUpdate('unavailable');
+            this.stats.presenceToggles++;
+        }
+        catch (error) {
+            this.log('error', 'Error performing presence toggle', { error: error.message });
+            this.stats.errors++;
+        }
+    }
+    /**
+     * Random value between min and max (inclusive)
+     */
+    randomBetween(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    /**
+     * Sleep for specified milliseconds
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Mask JID for logging (privacy)
+     */
+    maskJid(jid) {
+        if (jid.length < 8)
+            return '***';
+        return jid.substring(0, 4) + '***' + jid.substring(jid.length - 4);
+    }
+    /**
+     * Log message
+     */
+    log(level, message, meta) {
+        const prefix = '[entropy]';
+        const logData = meta ? `${message} ${JSON.stringify(meta)}` : message;
+        switch (level) {
+            case 'info':
+                console.log(`${prefix} ${logData}`);
+                break;
+            case 'warn':
+                console.warn(`${prefix} ${logData}`);
+                break;
+            case 'error':
+                console.error(`${prefix} ${logData}`);
+                break;
+            case 'debug':
+                // Skip debug logs in production
+                break;
+        }
+    }
+}
+/**
+ * Factory function to create HumanEntropyService
+ *
+ * @param wasp WaSP instance
+ * @param sessionId Session ID
+ * @param config Optional configuration
+ * @returns HumanEntropyService instance with start() and stop() methods
+ */
+export function createHumanEntropyService(wasp, sessionId, config) {
+    const service = new HumanEntropyService(wasp, sessionId, config);
+    return {
+        start: () => service.start(),
+        stop: () => service.stop(),
+        getStats: () => service.getStats(),
+    };
+}