@prototypevip/baileys 0.1.0 → 0.1.2

package/lib/AntiBan/groupOperationGuard.js

@@ -1,116 +0,0 @@
-/**
- * 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

@@ -1,207 +0,0 @@
-/**
- * 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

@@ -1,337 +0,0 @@
-/**
- * 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(),
-    };
-}