@prototypevip/baileys 0.0.9 → 0.1.1

package/lib/AntiBan/legitimacySignalInjector.js

@@ -1,231 +0,0 @@
-/**
- * LegitimacySignalInjector — Human imperfection signals
- *
- * WhatsApp's detection looks for accounts that are TOO perfect:
- * - Never make typos
- * - Always reply at consistent speeds
- * - Typing duration linearly correlates with message length
- *
- * This module injects realistic imperfections:
- * - Typos followed by corrections (2-3% of messages)
- * - Read-receipt without immediate reply (read gap)
- * - Mid-typing pauses for longer messages
- *
- * Note: Complements PresenceChoreographer, doesn't replace it.
- * PC handles timing/circadian rhythm; this handles content imperfections.
- */
-const DEFAULT_CONFIG = {
-    enableTypos: true,
-    typoProbability: 0.025,
-    typoCorrectMinMs: 500,
-    typoCorrectMaxMs: 2000,
-    enableReadGaps: true,
-    readGapProbability: 0.15,
-    readGapMinMs: 300_000,
-    readGapMaxMs: 3_600_000,
-    enableTypingPauses: true,
-    typingPauseLengthThreshold: 50,
-    typingPauseProbability: 0.4,
-    typingPauseMinMs: 1_500,
-    typingPauseMaxMs: 6_000,
-};
-/**
- * QWERTY keyboard adjacency map for realistic typos.
- * Maps common keys to their adjacent neighbors.
- */
-const QWERTY_ADJACENT = {
-    'a': ['q', 's', 'w', 'z'],
-    'b': ['v', 'g', 'h', 'n'],
-    'c': ['x', 'd', 'f', 'v'],
-    'd': ['s', 'e', 'r', 'f', 'c', 'x'],
-    'e': ['w', 'r', 'd', 's'],
-    'f': ['d', 'r', 't', 'g', 'v', 'c'],
-    'g': ['f', 't', 'y', 'h', 'b', 'v'],
-    'h': ['g', 'y', 'u', 'j', 'n', 'b'],
-    'i': ['u', 'o', 'k', 'j'],
-    'j': ['h', 'u', 'i', 'k', 'n', 'm'],
-    'k': ['j', 'i', 'o', 'l', 'm'],
-    'l': ['k', 'o', 'p'],
-    'm': ['n', 'j', 'k'],
-    'n': ['b', 'h', 'j', 'm'],
-    'o': ['i', 'p', 'l', 'k'],
-    'p': ['o', 'l'],
-    'q': ['w', 'a'],
-    'r': ['e', 't', 'f', 'd'],
-    's': ['a', 'w', 'e', 'd', 'x', 'z'],
-    't': ['r', 'y', 'g', 'f'],
-    'u': ['y', 'i', 'j', 'h'],
-    'v': ['c', 'f', 'g', 'b'],
-    'w': ['q', 'e', 's', 'a'],
-    'x': ['z', 's', 'd', 'c'],
-    'y': ['t', 'u', 'h', 'g'],
-    'z': ['a', 's', 'x'],
-};
-export class LegitimacySignalInjector {
-    config;
-    stats = {
-        typosInjected: 0,
-        correctionsGenerated: 0,
-        readGapsInjected: 0,
-        typingPausesInjected: 0,
-    };
-    constructor(config = {}) {
-        this.config = { ...DEFAULT_CONFIG, ...config };
-    }
-    /**
-     * Determine if a typo should be injected for this message.
-     * Returns typo version of text + correction delay, or null if no typo.
-     */
-    shouldInjectTypo(text) {
-        if (!this.config.enableTypos) {
-            return null;
-        }
-        // Only inject typos in messages > 10 chars
-        if (text.length <= 10) {
-            return null;
-        }
-        // Probability check
-        if (Math.random() >= this.config.typoProbability) {
-            return null;
-        }
-        // Don't inject typos in URLs
-        if (this.containsUrl(text)) {
-            return null;
-        }
-        // Extract words (excluding @mentions and numbers)
-        const words = text.split(/\s+/);
-        const eligibleWords = words.filter(word => word.length >= 3 && !word.startsWith('@') && !/^\d+$/.test(word));
-        if (eligibleWords.length === 0) {
-            return null;
-        }
-        // Pick a random eligible word
-        const targetWord = eligibleWords[Math.floor(Math.random() * eligibleWords.length)];
-        const typoWord = this.injectTypoInWord(targetWord);
-        if (!typoWord || typoWord === targetWord) {
-            return null;
-        }
-        // Generate typo text
-        const typoText = text.replace(targetWord, typoWord);
-        // Generate correction
-        const correctionDelay = this.randomBetween(this.config.typoCorrectMinMs, this.config.typoCorrectMaxMs);
-        // Correction format: "*correctedword" for single word, or full message for short texts
-        let correctionText;
-        if (text.length < 30) {
-            // Short message: resend the whole thing
-            correctionText = text;
-        }
-        else {
-            // Long message: use WA correction convention
-            correctionText = `*${targetWord}`;
-        }
-        this.stats.typosInjected++;
-        this.stats.correctionsGenerated++;
-        return {
-            typoText,
-            correctionDelay,
-            correctionText,
-        };
-    }
-    /**
-     * Determine if a read gap should be injected before sending a reply.
-     * Returns gap duration in ms, or null if no gap.
-     */
-    shouldInjectReadGap() {
-        if (!this.config.enableReadGaps) {
-            return null;
-        }
-        if (Math.random() >= this.config.readGapProbability) {
-            return null;
-        }
-        const gapMs = this.randomBetween(this.config.readGapMinMs, this.config.readGapMaxMs);
-        this.stats.readGapsInjected++;
-        return gapMs;
-    }
-    /**
-     * For a message of given length, calculate mid-typing pause positions.
-     * Returns array of { afterChars, pauseDurationMs } or empty array.
-     */
-    getTypingPauses(messageLength) {
-        if (!this.config.enableTypingPauses) {
-            return [];
-        }
-        // Only for messages above threshold
-        if (messageLength < this.config.typingPauseLengthThreshold) {
-            return [];
-        }
-        // Probability check
-        if (Math.random() >= this.config.typingPauseProbability) {
-            return [];
-        }
-        const pauses = [];
-        // Inject 1-2 pauses at natural break points
-        const numPauses = Math.random() < 0.6 ? 1 : 2;
-        for (let i = 0; i < numPauses; i++) {
-            let position;
-            if (i === 0) {
-                // First pause around 40% mark
-                position = Math.floor(messageLength * (0.35 + Math.random() * 0.15));
-            }
-            else {
-                // Second pause around 70% mark
-                position = Math.floor(messageLength * (0.65 + Math.random() * 0.15));
-            }
-            const pauseDurationMs = this.randomBetween(this.config.typingPauseMinMs, this.config.typingPauseMaxMs);
-            pauses.push({
-                afterChars: position,
-                pauseDurationMs,
-            });
-            this.stats.typingPausesInjected++;
-        }
-        // Sort by position
-        pauses.sort((a, b) => a.afterChars - b.afterChars);
-        return pauses;
-    }
-    /**
-     * Get statistics.
-     */
-    getStats() {
-        return { ...this.stats };
-    }
-    /**
-     * Reset statistics.
-     */
-    reset() {
-        this.stats = {
-            typosInjected: 0,
-            correctionsGenerated: 0,
-            readGapsInjected: 0,
-            typingPausesInjected: 0,
-        };
-    }
-    // Private helpers
-    injectTypoInWord(word) {
-        // Find a char that has QWERTY neighbors
-        const chars = word.toLowerCase().split('');
-        const eligibleIndices = chars
-            .map((char, idx) => ({ char, idx }))
-            .filter(({ char }) => QWERTY_ADJACENT[char] !== undefined);
-        if (eligibleIndices.length === 0) {
-            return null;
-        }
-        // Pick random position
-        const target = eligibleIndices[Math.floor(Math.random() * eligibleIndices.length)];
-        const neighbors = QWERTY_ADJACENT[target.char];
-        const replacement = neighbors[Math.floor(Math.random() * neighbors.length)];
-        // Preserve original casing
-        const originalChar = word[target.idx];
-        const replacementChar = originalChar === originalChar.toUpperCase()
-            ? replacement.toUpperCase()
-            : replacement;
-        // Build typo word
-        const typoChars = word.split('');
-        typoChars[target.idx] = replacementChar;
-        return typoChars.join('');
-    }
-    containsUrl(text) {
-        return /https?:\/\/|www\./i.test(text);
-    }
-    randomBetween(min, max) {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-}

package/lib/AntiBan/lidFirstResolver.js

@@ -1,174 +0,0 @@
-/**
- * LidFirstResolver — Standalone LID↔Phone mapper for Baileys auth state
- *
- * Lightweight drop-in utility that:
- * - Loads LID↔phone mappings from Baileys' auth state directory
- * - Resolves phone numbers to LID JIDs and vice versa
- * - Learns new mappings from Baileys events
- * - Works independently of the full AntiBan system
- *
- * Usage:
- * ```typescript
- * import { LidFirstResolver } from 'baileys-antiban';
- * const resolver = new LidFirstResolver();
- * resolver.loadFromAuthDir('./whatsapp-auth/my-session');
- * const jid = resolver.resolveToLID('27825651069'); // → "210543692497008@lid" or null
- * ```
- *
- * @author Kobus Wentzel <kobie@pop.co.za>
- * @license MIT
- */
-import * as fs from 'fs';
-import * as path from 'path';
-export class LidFirstResolver {
-    lidToPhone = new Map();
-    phoneToLid = new Map(); // phone → lid (quick reverse lookup)
-    /**
-     * Load mappings from Baileys auth state directory.
-     * Looks for lid-mapping-*_reverse.json files.
-     */
-    loadFromAuthDir(authDir) {
-        try {
-            if (!fs.existsSync(authDir)) {
-                return; // Directory doesn't exist, nothing to load
-            }
-            const files = fs.readdirSync(authDir);
-            const reverseMappingFiles = files.filter(f => f.startsWith('lid-mapping-') && f.endsWith('_reverse.json'));
-            for (const file of reverseMappingFiles) {
-                const filePath = path.join(authDir, file);
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const data = JSON.parse(content);
-                // Baileys reverse mapping format: { "lid@lid": "phone@s.whatsapp.net" }
-                for (const [lid, pnJid] of Object.entries(data)) {
-                    if (typeof pnJid === 'string') {
-                        const phone = this.extractPhone(pnJid);
-                        if (phone && lid.endsWith('@lid')) {
-                            const mapping = {
-                                lid: this.normalizeLid(lid),
-                                phone,
-                                learnedAt: Date.now(),
-                                source: 'auth-dir',
-                            };
-                            this.lidToPhone.set(mapping.lid, mapping);
-                            this.phoneToLid.set(phone, mapping.lid);
-                        }
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Silently fail — don't crash if auth dir is malformed
-        }
-    }
-    /**
-     * Learn a new mapping from a Baileys event (messages, contacts, etc.).
-     * Accepts partial data — will extract what it can.
-     */
-    learnFromEvent(event) {
-        try {
-            // Extract from message event structure
-            if (event.key?.remoteJid) {
-                const jid = event.key.remoteJid;
-                this.learnJid(jid, 'event');
-            }
-            // Extract from participant field (group messages)
-            if (event.key?.participant) {
-                const jid = event.key.participant;
-                this.learnJid(jid, 'event');
-            }
-            // Extract from contact event
-            if (event.id) {
-                this.learnJid(event.id, 'event');
-            }
-            // Extract from pushName field (has phone)
-            if (event.pushName && event.key?.remoteJid) {
-                this.learnJid(event.key.remoteJid, 'event');
-            }
-        }
-        catch (error) {
-            // Silently fail — don't crash on malformed events
-        }
-    }
-    /**
-     * Resolve phone number or phone JID to LID JID.
-     * Returns null if not known.
-     */
-    resolveToLID(phoneOrJid) {
-        const phone = this.extractPhone(phoneOrJid);
-        if (!phone)
-            return null;
-        return this.phoneToLid.get(phone) || null;
-    }
-    /**
-     * Resolve LID JID to phone number.
-     * Returns null if not known.
-     */
-    resolveToPhone(lid) {
-        const normalized = this.normalizeLid(lid);
-        const mapping = this.lidToPhone.get(normalized);
-        return mapping ? mapping.phone : null;
-    }
-    /**
-     * Get full mapping for a given JID (either LID or phone).
-     * Returns null if not known.
-     */
-    getMapping(jid) {
-        const normalized = this.normalizeLid(jid);
-        // Try as LID
-        const byLid = this.lidToPhone.get(normalized);
-        if (byLid)
-            return byLid;
-        // Try as phone
-        const phone = this.extractPhone(jid);
-        if (phone) {
-            const lid = this.phoneToLid.get(phone);
-            if (lid)
-                return this.lidToPhone.get(lid) || null;
-        }
-        return null;
-    }
-    /**
-     * Get total number of known mappings.
-     */
-    size() {
-        return this.lidToPhone.size;
-    }
-    /**
-     * Clear all mappings.
-     */
-    clear() {
-        this.lidToPhone.clear();
-        this.phoneToLid.clear();
-    }
-    // Private helpers
-    learnJid(_jid, _source) {
-        // Check if this is a LID JID with a phone equivalent we can learn
-        // For now, we can only learn from auth dir or from paired data
-        // Single JID without context can't create a mapping
-        // This is intentionally limited — real learning happens in loadFromAuthDir
-    }
-    extractPhone(jid) {
-        if (!jid)
-            return null;
-        // Remove @s.whatsapp.net suffix if present
-        let cleaned = jid.replace('@s.whatsapp.net', '');
-        // Remove device suffix :N if present
-        cleaned = cleaned.replace(/:\d+$/, '');
-        // Check if it's a phone number (digits only)
-        if (/^\d+$/.test(cleaned)) {
-            return cleaned;
-        }
-        return null;
-    }
-    normalizeLid(lid) {
-        // Remove device suffix :N if present
-        return lid.replace(/:\d+@/, '@');
-    }
-}
-/**
- * Factory function for creating a singleton resolver instance.
- * Useful for shared state across modules.
- */
-export function createLidFirstResolver() {
-    return new LidFirstResolver();
-}