@prototypevip/baileys 0.0.8 → 0.1.0

package/lib/AntiBan/legitimacySignalInjector.js

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

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