@prototypevip/baileys 0.1.0 → 0.1.2

package/lib/AntiBan/topologyThrottler.js

@@ -1,339 +0,0 @@
-/**
- * Topology Throttler — Network topology-based anti-ban enforcement
- *
- * WhatsApp bans based on NETWORK TOPOLOGY, not just message timing:
- * - How fast you expand your contact graph
- * - Cold-contact ratio (strangers vs known contacts)
- * - Reply reciprocity
- * - Group-source clustering (mass-DMing group members)
- *
- * This module enforces graph expansion limits and scores contact risk
- * before each send, acting as the primary enforcement layer for high-risk
- * cold outreach.
- *
- * Key insight: A 30% reply rate is the minimum to unlock more cold sends.
- * Below that, WhatsApp's ML models flag you as a spammer.
- */
-const TIME_CONSTANTS = {
-    MS_PER_HOUR: 3600000,
-    MS_PER_DAY: 86400000,
-    MS_PER_24H: 86400000,
-    REPLY_WINDOW_DAYS: 7,
-};
-const DEFAULT_CONFIG = {
-    maxNewContactsPerHour: 5,
-    maxNewContactsPerDay: 20,
-    minReplyRatioForNewContacts: 0.3,
-    maxSameGroupContacts: 10,
-    maxContactsFromSameSource: 8,
-    blockOnLimitReached: true,
-    cooldownMs: TIME_CONSTANTS.MS_PER_HOUR,
-    riskConfig: {
-        firstContactPenalty: 40,
-        noReplyPenalty: 20,
-        noMutualGroupsPenalty: 15,
-        recentContactBonus: -20,
-        repliedBeforeBonus: -30,
-        delayThreshold: 40,
-        abortThreshold: 75,
-    },
-};
-const DEFAULT_RISK_CONFIG = {
-    firstContactPenalty: 40,
-    noReplyPenalty: 20,
-    noMutualGroupsPenalty: 15,
-    recentContactBonus: -20,
-    repliedBeforeBonus: -30,
-    delayThreshold: 40,
-    abortThreshold: 75,
-};
-export class TopologyThrottler {
-    config;
-    riskConfig;
-    contacts = new Map();
-    limits;
-    sourceGroupCounts = new Map();
-    constructor(config) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.riskConfig = { ...DEFAULT_RISK_CONFIG, ...this.config.riskConfig };
-        this.limits = {
-            newContactsThisHour: 0,
-            newContactsToday: 0,
-            lastHourResetAt: Date.now(),
-            lastDayResetAt: Date.now(),
-        };
-    }
-    /**
-     * Assess contact risk before sending.
-     * This is the main check — call before every send to a new/unknown contact.
-     */
-    assessContact(jid, context) {
-        this.resetLimitsIfNeeded();
-        const record = this.contacts.get(jid);
-        const now = Date.now();
-        let score = 0;
-        const reasons = [];
-        // First contact penalty
-        if (!record) {
-            score += this.riskConfig.firstContactPenalty;
-            reasons.push('first_contact');
-        }
-        else {
-            // Has record — check reply history
-            if (record.replyTimestamps.length === 0 && record.sendTimestamps.length > 0) {
-                score += this.riskConfig.noReplyPenalty;
-                reasons.push('no_reply_history');
-            }
-        }
-        // No mutual groups penalty
-        if (!context.knownGroups || context.knownGroups.length === 0) {
-            score += this.riskConfig.noMutualGroupsPenalty;
-            reasons.push('no_mutual_groups');
-        }
-        // Recent contact bonus
-        if (context.lastContactAt && (now - context.lastContactAt) < TIME_CONSTANTS.MS_PER_24H) {
-            score += this.riskConfig.recentContactBonus;
-            reasons.push('recent_contact');
-        }
-        // Replied before bonus
-        if (context.hasReplied || (record && record.replyTimestamps.length > 0)) {
-            score += this.riskConfig.repliedBeforeBonus;
-            reasons.push('has_replied');
-        }
-        // Clamp score to 0-100
-        score = Math.max(0, Math.min(100, score));
-        // Determine risk level
-        let risk;
-        let recommendation;
-        let suggestedDelayMs;
-        if (score >= this.riskConfig.abortThreshold) {
-            risk = 'CRITICAL';
-            recommendation = 'abort';
-            reasons.push('risk_too_high');
-        }
-        else if (score >= this.riskConfig.delayThreshold) {
-            risk = score >= 60 ? 'HIGH' : 'MEDIUM';
-            recommendation = 'delay';
-            // Exponential delay based on score
-            const delayMinutes = Math.floor((score - this.riskConfig.delayThreshold) / 10);
-            suggestedDelayMs = delayMinutes * 60000;
-            reasons.push('recommend_delay');
-        }
-        else {
-            risk = score >= 30 ? 'MEDIUM' : 'LOW';
-            recommendation = 'send';
-        }
-        return {
-            jid,
-            risk,
-            score,
-            reasons,
-            recommendation,
-            suggestedDelayMs,
-        };
-    }
-    /**
-     * Record a sent message to this contact.
-     */
-    recordSent(jid, sourceGroup) {
-        this.resetLimitsIfNeeded();
-        const now = Date.now();
-        let record = this.contacts.get(jid);
-        if (!record) {
-            // New contact — increment limits
-            record = {
-                firstContactAt: now,
-                sendTimestamps: [],
-                replyTimestamps: [],
-                blocked: false,
-                sourceGroup,
-            };
-            this.contacts.set(jid, record);
-            this.limits.newContactsThisHour++;
-            this.limits.newContactsToday++;
-            // Track source group
-            if (sourceGroup) {
-                const count = this.sourceGroupCounts.get(sourceGroup) || 0;
-                this.sourceGroupCounts.set(sourceGroup, count + 1);
-            }
-        }
-        // Add send timestamp (keep sliding window)
-        record.sendTimestamps.push(now);
-        this.cleanupTimestamps(record.sendTimestamps, TIME_CONSTANTS.REPLY_WINDOW_DAYS * TIME_CONSTANTS.MS_PER_DAY);
-    }
-    /**
-     * Record a reply from this contact.
-     */
-    recordReplied(jid) {
-        const record = this.contacts.get(jid);
-        if (!record)
-            return;
-        const now = Date.now();
-        record.replyTimestamps.push(now);
-        this.cleanupTimestamps(record.replyTimestamps, TIME_CONSTANTS.REPLY_WINDOW_DAYS * TIME_CONSTANTS.MS_PER_DAY);
-    }
-    /**
-     * Record that this contact blocked you.
-     */
-    recordBlocked(jid) {
-        const record = this.contacts.get(jid);
-        if (!record)
-            return;
-        record.blocked = true;
-    }
-    /**
-     * Check if topology limits allow sending to a new contact.
-     * Returns whether allowed and reason/retry time if blocked.
-     */
-    canSendToNewContact() {
-        this.resetLimitsIfNeeded();
-        const now = Date.now();
-        // Check cooldown
-        if (this.limits.limitHitAt) {
-            const cooldownEndsAt = this.limits.limitHitAt + this.config.cooldownMs;
-            if (now < cooldownEndsAt) {
-                const retryAfterMs = cooldownEndsAt - now;
-                return {
-                    allowed: false,
-                    reason: `Cooldown active — limit hit recently`,
-                    retryAfterMs,
-                };
-            }
-            else {
-                // Cooldown expired
-                delete this.limits.limitHitAt;
-            }
-        }
-        // Check hourly limit
-        if (this.limits.newContactsThisHour >= this.config.maxNewContactsPerHour) {
-            this.limits.limitHitAt = now;
-            const retryAfterMs = (this.limits.lastHourResetAt + TIME_CONSTANTS.MS_PER_HOUR) - now;
-            return {
-                allowed: false,
-                reason: `Hourly new contact limit reached (${this.config.maxNewContactsPerHour})`,
-                retryAfterMs: Math.max(0, retryAfterMs),
-            };
-        }
-        // Check daily limit
-        if (this.limits.newContactsToday >= this.config.maxNewContactsPerDay) {
-            this.limits.limitHitAt = now;
-            const retryAfterMs = (this.limits.lastDayResetAt + TIME_CONSTANTS.MS_PER_DAY) - now;
-            return {
-                allowed: false,
-                reason: `Daily new contact limit reached (${this.config.maxNewContactsPerDay})`,
-                retryAfterMs: Math.max(0, retryAfterMs),
-            };
-        }
-        // Check reply ratio requirement
-        const replyRatio = this.calculateReplyRatio();
-        if (replyRatio !== null && replyRatio < this.config.minReplyRatioForNewContacts) {
-            // Poor reply ratio — need to improve engagement before more cold sends
-            return {
-                allowed: false,
-                reason: `Reply ratio too low (${Math.round(replyRatio * 100)}% < ${Math.round(this.config.minReplyRatioForNewContacts * 100)}%)`,
-                retryAfterMs: TIME_CONSTANTS.MS_PER_HOUR, // arbitrary — user needs to improve engagement
-            };
-        }
-        return { allowed: true };
-    }
-    /**
-     * Get topology statistics.
-     */
-    getTopologyStats() {
-        this.resetLimitsIfNeeded();
-        const replyRatio = this.calculateReplyRatio();
-        const blockedRatio = this.calculateBlockedRatio();
-        // Get top 5 source group hotspots
-        const hotspots = Array.from(this.sourceGroupCounts.entries())
-            .map(([sourceGroup, count]) => ({ sourceGroup, count }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, 5);
-        return {
-            newContactsThisHour: this.limits.newContactsThisHour,
-            newContactsToday: this.limits.newContactsToday,
-            replyRatio,
-            blockedRatio,
-            hotspots,
-        };
-    }
-    /**
-     * Export state for persistence.
-     */
-    exportState() {
-        return {
-            contacts: Array.from(this.contacts.entries()),
-            limits: { ...this.limits },
-            sourceGroupCounts: Array.from(this.sourceGroupCounts.entries()),
-        };
-    }
-    /**
-     * Import state from persistence.
-     */
-    importState(state) {
-        if (state.contacts) {
-            this.contacts = new Map(state.contacts);
-        }
-        if (state.limits) {
-            this.limits = { ...state.limits };
-        }
-        if (state.sourceGroupCounts) {
-            this.sourceGroupCounts = new Map(state.sourceGroupCounts);
-        }
-    }
-    // Private helpers
-    resetLimitsIfNeeded() {
-        const now = Date.now();
-        // Reset hourly counter
-        if (now - this.limits.lastHourResetAt >= TIME_CONSTANTS.MS_PER_HOUR) {
-            this.limits.newContactsThisHour = 0;
-            this.limits.lastHourResetAt = now;
-        }
-        // Reset daily counter
-        if (now - this.limits.lastDayResetAt >= TIME_CONSTANTS.MS_PER_DAY) {
-            this.limits.newContactsToday = 0;
-            this.limits.lastDayResetAt = now;
-            // Clear source group counts daily
-            this.sourceGroupCounts.clear();
-        }
-    }
-    calculateReplyRatio() {
-        const now = Date.now();
-        const windowMs = TIME_CONSTANTS.REPLY_WINDOW_DAYS * TIME_CONSTANTS.MS_PER_DAY;
-        let totalSent = 0;
-        let totalReplies = 0;
-        for (const record of this.contacts.values()) {
-            // Count sends in window
-            const recentSends = record.sendTimestamps.filter(t => now - t < windowMs);
-            totalSent += recentSends.length;
-            // Count replies in window
-            const recentReplies = record.replyTimestamps.filter(t => now - t < windowMs);
-            totalReplies += recentReplies.length;
-        }
-        if (totalSent === 0)
-            return null; // No data yet
-        return totalReplies / totalSent;
-    }
-    calculateBlockedRatio() {
-        const totalContacts = this.contacts.size;
-        if (totalContacts === 0)
-            return null;
-        let blockedCount = 0;
-        for (const record of this.contacts.values()) {
-            if (record.blocked)
-                blockedCount++;
-        }
-        return blockedCount / totalContacts;
-    }
-    cleanupTimestamps(timestamps, maxAgeMs) {
-        const now = Date.now();
-        const cutoff = now - maxAgeMs;
-        // Remove old timestamps (in-place filter)
-        let writeIdx = 0;
-        for (let readIdx = 0; readIdx < timestamps.length; readIdx++) {
-            if (timestamps[readIdx] >= cutoff) {
-                timestamps[writeIdx++] = timestamps[readIdx];
-            }
-        }
-        timestamps.length = writeIdx;
-    }
-}

package/lib/AntiBan/warmup.js

@@ -1,140 +0,0 @@
-/**
- * WarmUp — Gradual activity increase for new/reconnected numbers
- *
- * New numbers or numbers reconnecting after a break are under extra scrutiny.
- * This module enforces a gradual ramp-up of messaging activity.
- *
- * WhatsApp flags:
- * - New numbers sending many messages immediately
- * - Numbers going from 0 to 100 messages/day overnight
- * - Sudden pattern changes after period of inactivity
- */
-/** Generate a random growth factor in [1.5, 2.2] to avoid cross-account clustering */
-function randomGrowthFactor() {
-    return Math.round((1.5 + Math.random() * 0.7) * 100) / 100;
-}
-const DEFAULT_CONFIG = {
-    warmUpDays: 7,
-    day1Limit: 20,
-    growthFactor: randomGrowthFactor(), // intentionally non-deterministic
-    inactivityThresholdHours: 72,
-};
-export class WarmUp {
-    config;
-    state;
-    constructor(config = {}, existingState) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        this.state = existingState || this.freshState();
-    }
-    /**
-     * Get the current daily message limit based on warm-up phase
-     */
-    getDailyLimit() {
-        if (this.state.graduated)
-            return Infinity;
-        const day = this.getCurrentDay();
-        if (day >= this.config.warmUpDays) {
-            this.state.graduated = true;
-            return Infinity;
-        }
-        return Math.round(this.config.day1Limit * Math.pow(this.config.growthFactor, day));
-    }
-    /**
-     * Check if a message can be sent (within warm-up limits)
-     */
-    canSend() {
-        this.checkInactivity();
-        if (this.state.graduated)
-            return true;
-        const day = this.getCurrentDay();
-        const todayCount = this.state.dailyCounts[day] || 0;
-        return todayCount < this.getDailyLimit();
-    }
-    /**
-     * Record a sent message
-     */
-    record() {
-        const now = Date.now();
-        const day = this.getCurrentDay();
-        while (this.state.dailyCounts.length <= day) {
-            this.state.dailyCounts.push(0);
-        }
-        this.state.dailyCounts[day]++;
-        this.state.lastActiveAt = now;
-    }
-    /**
-     * Get current warm-up status
-     */
-    getStatus() {
-        const day = this.getCurrentDay();
-        const todaySent = this.state.dailyCounts[day] || 0;
-        const limit = this.getDailyLimit();
-        return {
-            phase: this.state.graduated ? 'graduated' : 'warming',
-            day: Math.min(day + 1, this.config.warmUpDays),
-            totalDays: this.config.warmUpDays,
-            todayLimit: limit === Infinity ? -1 : limit,
-            todaySent,
-            progress: this.state.graduated ? 100 : Math.round((day / this.config.warmUpDays) * 100),
-        };
-    }
-    /**
-     * Export state for persistence
-     */
-    exportState() {
-        const day = this.getCurrentDay();
-        const todaySent = this.state.dailyCounts[day] || 0;
-        const todayDate = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
-        return {
-            ...this.state,
-            todaySentCount: todaySent,
-            todayDate,
-        };
-    }
-    /**
-     * Import state from persistence
-     */
-    importState(state) {
-        this.state = { ...state };
-        // BUG FIX 1: Restore today's send count from persisted state
-        // If todayDate matches current date, restore the count to prevent
-        // post-crash burst (issue: warmup day counter survives but send history lost)
-        if (state.todayDate && state.todaySentCount !== undefined) {
-            const todayDate = new Date().toISOString().split('T')[0];
-            if (state.todayDate === todayDate) {
-                const day = this.getCurrentDay();
-                // Restore the persisted count if higher than current
-                while (this.state.dailyCounts.length <= day) {
-                    this.state.dailyCounts.push(0);
-                }
-                this.state.dailyCounts[day] = Math.max(this.state.dailyCounts[day] || 0, state.todaySentCount);
-            }
-        }
-    }
-    /**
-     * Reset warm-up (e.g., after detected ban risk)
-     */
-    reset() {
-        this.state = this.freshState();
-    }
-    getCurrentDay() {
-        return Math.floor((Date.now() - this.state.startedAt) / 86400000);
-    }
-    checkInactivity() {
-        const hoursSinceActive = (Date.now() - this.state.lastActiveAt) / 3600000;
-        if (hoursSinceActive > this.config.inactivityThresholdHours && this.state.graduated) {
-            // Re-enter warm-up after extended inactivity
-            this.state = this.freshState();
-            this.state.graduated = false;
-        }
-    }
-    freshState() {
-        const now = Date.now();
-        return {
-            startedAt: now,
-            lastActiveAt: now,
-            dailyCounts: [],
-            graduated: false,
-        };
-    }
-}

package/lib/AntiBan/webhooks.js

@@ -1,80 +0,0 @@
-/**
- * Webhook Alerts — Get notified on Telegram/Discord/Slack when risk changes
- */
-const DEFAULT_CONFIG = {
-    urls: [],
-    minRiskLevel: 'medium',
-    cooldownMs: 300000,
-    includeStats: true,
-};
-export class WebhookAlerts {
-    config;
-    lastAlertTime = 0;
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Send alert if risk level warrants it
-     */
-    async alert(data) {
-        const riskOrder = ['low', 'medium', 'high', 'critical'];
-        if (riskOrder.indexOf(data.risk) < riskOrder.indexOf(this.config.minRiskLevel)) {
-            return; // Below threshold
-        }
-        const now = Date.now();
-        if (now - this.lastAlertTime < this.config.cooldownMs) {
-            return; // Cooldown active
-        }
-        this.lastAlertTime = now;
-        const payload = {
-            source: 'baileys-antiban',
-            timestamp: new Date().toISOString(),
-            ...data,
-        };
-        // Send to generic webhook URLs
-        for (const url of this.config.urls) {
-            this.postWebhook(url, payload).catch(() => { });
-        }
-        // Telegram
-        if (this.config.telegram) {
-            const emoji = { low: '🟢', medium: '🟡', high: '🟠', critical: '🔴' }[data.risk] || '⚪';
-            const text = `${emoji} *baileys-antiban Alert*\n\nRisk: *${data.risk.toUpperCase()}* (score: ${data.score})\n${data.recommendation}\n\nReasons:\n${data.reasons.map(r => `• ${r}`).join('\n')}`;
-            this.postWebhook(`https://api.telegram.org/bot${this.config.telegram.botToken}/sendMessage`, { chat_id: this.config.telegram.chatId, text, parse_mode: 'Markdown' }).catch(() => { });
-        }
-        // Discord
-        if (this.config.discord) {
-            const color = { low: 0x00ff00, medium: 0xffff00, high: 0xff8800, critical: 0xff0000 }[data.risk] || 0;
-            this.postWebhook(this.config.discord.webhookUrl, {
-                embeds: [{
-                        title: '🛡️ baileys-antiban Alert',
-                        color,
-                        fields: [
-                            { name: 'Risk', value: data.risk.toUpperCase(), inline: true },
-                            { name: 'Score', value: String(data.score), inline: true },
-                            { name: 'Recommendation', value: data.recommendation },
-                            { name: 'Reasons', value: data.reasons.join('\n') },
-                        ],
-                        timestamp: new Date().toISOString(),
-                    }],
-            }).catch(() => { });
-        }
-    }
-    async postWebhook(url, payload) {
-        try {
-            const response = await fetch(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    ...this.config.headers,
-                },
-                body: JSON.stringify(payload),
-            });
-            if (!response.ok) {
-                console.error(`[baileys-antiban] Webhook failed: ${response.status}`);
-            }
-        }
-        catch (err) {
-            console.error(`[baileys-antiban] Webhook error:`, err);
-        }
-    }
-}