@prototypevip/baileys 0.0.5 → 0.0.7

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(),
+    };
+}

package/lib/AntiBan/index.js

@@ -0,0 +1,77 @@
+/**
+ * baileys-antiban — Anti-ban middleware for Baileys
+ *
+ * Wraps a Baileys socket with human-like messaging patterns
+ * to minimize the risk of WhatsApp banning your number.
+ *
+ * @author Kobus Wentzel <kobie@pop.co.za>
+ * @license MIT
+ */
+// Core
+export { AntiBan } from './antiban.js';
+export { RateLimiter } from './rateLimiter.js';
+export { WarmUp } from './warmup.js';
+export { HealthMonitor } from './health.js';
+export { TimelockGuard } from './timelockGuard.js';
+// v1.3 new modules
+export { ReplyRatioGuard } from './replyRatio.js';
+export { ContactGraphWarmer } from './contactGraph.js';
+export { PresenceChoreographer, getCircadianMultiplier, } from './presenceChoreographer.js';
+// v1.5 new modules
+export { RetryReasonTracker } from './retryTracker.js';
+export { PostReconnectThrottle } from './reconnectThrottle.js';
+// v1.6 new modules
+export { LidResolver } from './lidResolver.js';
+export { JidCanonicalizer } from './jidCanonicalizer.js';
+// v2.0 new modules
+export { SessionHealthMonitor, wrapWithSessionStability, classifyDisconnect, DeafSessionDetector, } from './sessionStability.js';
+// v2.1 new modules
+export { LidFirstResolver, createLidFirstResolver, } from './lidFirstResolver.js';
+export { MessageRetryReason, MAC_ERROR_CODES, parseRetryReason, isMacError, getRetryReasonDescription, } from './retryReason.js';
+// Socket wrapper
+export { wrapSocket, wrapSocketWithFingerprint } from './wrapper.js';
+// Optional features
+export { MessageQueue } from './messageQueue.js';
+export { ContentVariator } from './contentVariator.js';
+export { WebhookAlerts } from './webhooks.js';
+export { Scheduler } from './scheduler.js';
+// State persistence
+export { FileStateAdapter } from './stateAdapter.js';
+// v3.0 new modules
+export { resolveConfig, PRESETS } from './presets.js';
+export { StateManager } from './persist.js';
+export { isGroup, isNewsletter, isBroadcast, shouldUseGroupProfile, applyGroupMultiplier } from './profiles.js';
+// v3.1 new modules
+export { messageRecovery } from './messageRecovery.js';
+// v3.2 new modules
+export { generateFingerprint, applyFingerprint, } from './deviceFingerprint.js';
+export { credsSnapshot, } from './credsSnapshot.js';
+export { readReceiptVariance, } from './readReceiptVariance.js';
+// v3.5 new modules
+export { proxyRotator, } from './proxyRotator.js';
+// v3.6 new modules (Obscura-inspired)
+export { generateSessionFingerprint, applySessionFingerprint, getMessageSendJitter, getTypingJitter, getRetryJitter, getVoiceNoteMetadata, getBatteryState, createStealthFingerprint, } from './sessionFingerprint.js';
+// v3.8 new modules
+export { getStealthSocketConfig, rampPresenceAfterConnect, STEALTH_BROWSER_POOL, AbortError, } from './stealthConnect.js';
+// v4.0 new modules
+export { GroupOperationGuard, classifyGroupOpError, extractPrivacyBlock, GROUP_OP_ERRORS, } from './groupOperationGuard.js';
+// v4.1 new modules
+export { LegitimacySignalInjector, } from './legitimacySignalInjector.js';
+// v4.2 new modules
+export { BanRecoveryOrchestrator, } from './banRecoveryOrchestrator.js';
+// v4.3 new modules
+export { DeliveryTracker } from './deliveryTracker.js';
+// v4.4 new modules
+export { InstanceCoordinator } from './instanceCoordinator.js';
+// v4.7 new modules
+export { JidCircuitBreaker, createJidCircuitBreaker } from './jidCircuitBreaker.js';
+export { createFleetEventStore, createMySQLEventStoreBackend, createInMemoryEventStoreBackend } from './fleetEventStore.js';
+export { HumanEntropyService, createHumanEntropyService } from './humanEntropy.js';
+// v4.8 new modules
+export { MessageTypeRegistry } from './messageTypeRegistry.js';
+export { exportAntibanState, importAntibanState } from './stateExport.js';
+export { TopologyThrottler } from './topologyThrottler.js';
+// v4.9 new modules
+export { ReputationVoucher } from './reputationVoucher.js';
+// Observability
+export { createConsoleLogger, exportPrometheusMetrics, createMetricsHandler, createPeriodicExporter, } from './observability.js';