@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/scheduling.js

@@ -0,0 +1,246 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.createMessageScheduler = exports.MessageScheduler = void 0
+
+/**
+ * Message Scheduling System
+ * Ported from Baileys-Joss: schedule messages to be sent automatically at specific times.
+ *
+ * Features:
+ *  - schedule(jid, content, Date) — send at an absolute time
+ *  - scheduleDelay(jid, content, delayMs)  — send after N milliseconds
+ *  - cancel(id) — cancel by ID
+ *  - cancelForJid(jid) — cancel all pending for a JID
+ *  - getPending() — list all pending messages
+ *  - get(id) — get a single scheduled entry
+ *  - clearAll() — wipe the whole queue
+ *  - stop() — stop the internal timer
+ *  - start() — restart the timer (queue must be non-empty)
+ */
+class MessageScheduler {
+    constructor(sendMessage, options = {}) {
+        this.queue = new Map()
+        this.timer = null
+        this.sendMessage = sendMessage
+        this.options = {
+            maxQueue: options.maxQueue ?? 1000,
+            checkInterval: options.checkInterval ?? 1000,
+            onSent: options.onSent ?? (() => {}),
+            onFailed: options.onFailed ?? (() => {})
+        }
+    }
+
+    /** Generate a unique ID for a scheduled message */
+    generateId() {
+        return `sched_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`
+    }
+
+    /**
+     * Schedule a message to be sent at a specific Date/time.
+     * @param {string} jid - Recipient JID
+     * @param {AnyMessageContent}  content - Message content
+     * @param {Date} scheduledTime - When to send (must be in the future)
+     * @returns {ScheduledMessage}
+     */
+    schedule(jid, content, scheduledTime) {
+        if (this.queue.size >= this.options.maxQueue) {
+            throw new Error(`Maximum queue size (${this.options.maxQueue}) reached`)
+        }
+
+        if (scheduledTime.getTime() <= Date.now()) {
+            throw new Error('Scheduled time must be in the future')
+        }
+
+        const scheduled = {
+            id: this.generateId(),
+            jid,
+            content,
+            scheduledTime,
+            createdAt: new Date(),
+            status: 'pending'
+        }
+
+        this.queue.set(scheduled.id, scheduled)
+        this.ensureTimerRunning()
+
+        return scheduled
+    }
+
+    /**
+     * Schedule a message with a delay from now.
+     * @param {string} jid - Recipient JID
+     * @param {AnyMessageContent} content  - Message content
+     * @param {number} delayMs  - Delay in milliseconds
+     * @returns {ScheduledMessage}
+     */
+    scheduleDelay(jid, content, delayMs) {
+        const scheduledTime = new Date(Date.now() + delayMs)
+        return this.schedule(jid, content, scheduledTime)
+    }
+
+    /**
+     * Cancel a scheduled message by its ID.
+     * @param {string} id
+     * @returns {boolean} true if cancelled, false if not found or already sent
+     */
+    cancel(id) {
+        const scheduled = this.queue.get(id)
+        if (scheduled && scheduled.status === 'pending') {
+            scheduled.status = 'cancelled'
+            this.queue.delete(id)
+            return true
+        }
+        return false
+    }
+
+    /**
+     * Cancel all pending messages for a specific JID.
+     * @param {string} jid
+     * @returns {number} number of messages cancelled
+     */
+    cancelForJid(jid) {
+        let cancelled = 0
+        for (const [id, scheduled] of this.queue) {
+            if (scheduled.jid === jid && scheduled.status === 'pending') {
+                scheduled.status = 'cancelled'
+                this.queue.delete(id)
+                cancelled++
+            }
+        }
+        return cancelled
+    }
+
+    /**
+     * Get all pending scheduled messages.
+     * @returns {ScheduledMessage[]}
+     */
+    getPending() {
+        return Array.from(this.queue.values()).filter((s) => s.status === 'pending')
+    }
+
+    /**
+     * Get a scheduled message by ID.
+     * @param {string} id
+     * @returns {ScheduledMessage|undefined}
+     */
+    get(id) {
+        return this.queue.get(id)
+    }
+
+    /**
+     * Clear all pending messages and stop the timer.
+     * @returns {number} number of messages cleared
+     */
+    clearAll() {
+        const count = this.queue.size
+        this.queue.clear()
+        this.stopTimer()
+        return count
+    }
+
+    /** Process the queue and send any due messages */
+    async processQueue() {
+        const now = Date.now()
+
+        for (const [id, scheduled] of this.queue) {
+            if (scheduled.status !== 'pending') continue
+            if (scheduled.scheduledTime.getTime() > now) continue
+
+            try {
+                const message = await this.sendMessage(scheduled.jid, scheduled.content)
+                scheduled.status = 'sent'
+                scheduled.messageId = message?.key?.id ?? undefined
+                this.options.onSent(scheduled, message)
+            } catch (error) {
+                scheduled.status = 'failed'
+                scheduled.error = error.message
+                this.options.onFailed(scheduled, error)
+            }
+
+            this.queue.delete(id)
+        }
+
+        // Auto-stop when nothing is left
+        if (this.queue.size === 0) {
+            this.stopTimer()
+        }
+    }
+
+    ensureTimerRunning() {
+        if (!this.timer) {
+            this.timer = setInterval(() => this.processQueue(), this.options.checkInterval)
+        }
+    }
+
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer)
+            this.timer = null
+        }
+    }
+
+    /** Stop the scheduler (timer is cleared; already scheduled entries remain in queue) */
+    stop() {
+        this.stopTimer()
+    }
+
+    /**
+     * (Re)start the scheduler — only has effect if the queue is non-empty.
+     * The scheduler auto-starts whenever `schedule()` or `scheduleDelay()` is called,
+     * so you only need this after an explicit `stop()`.
+     */
+    start() {
+        if (this.queue.size > 0) {
+            this.ensureTimerRunning()
+        }
+    }
+}
+
+exports.MessageScheduler = MessageScheduler
+
+/**
+ * Factory helper — creates and returns a ready-to-use MessageScheduler.
+ *
+ * @param {(jid: string, content: AnyMessageContent) => Promise<WAMessage|undefined>} sendMessage
+ * @param {SchedulerOptions} [options]
+ * @returns {MessageScheduler}
+ *
+ * @example
+ * const scheduler = createMessageScheduler(
+ * (jid, content) => sock.sendMessage(jid, content),
+ * {
+ * onSent:   (s, msg) => console.log(`Sent to ${s.jid}`),
+ * onFailed: (s, err) => console.error(`Failed: ${err.message}`)
+ * }
+ * )
+ *
+ * // Schedule for a specific time
+ * const entry = scheduler.schedule(jid, { text: 'Happy Birthday! 🎂' }, new Date('2026-12-25T09:00:00'))
+ *
+ * // Schedule with a delay (30 minutes)
+ * scheduler.scheduleDelay(jid, { text: 'Reminder!' }, 30 * 60 * 1000)
+ *
+ * // Cancel one message
+ * scheduler.cancel(entry.id)
+ *
+ * // Cancel all messages for a JID
+ * scheduler.cancelForJid(jid)
+ *
+ * // Get all pending entries
+ * const pending = scheduler.getPending()
+ *
+ * // Stop (timer cleared, queue preserved)
+ * scheduler.stop()
+ *
+ * // Restart after stop
+ * scheduler.start()
+ *
+ * // Wipe everything
+ * scheduler.clearAll()
+ */
+const createMessageScheduler = (sendMessage, options) => {
+    return new MessageScheduler(sendMessage, options)
+}
+
+exports.createMessageScheduler = createMessageScheduler

package/lib/Utils/session-fingerprint.js

@@ -0,0 +1,226 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.createStealthFingerprint =
+    exports.getBatteryState =
+    exports.getVoiceNoteMetadata =
+    exports.getRetryJitter =
+    exports.getTypingJitter =
+    exports.getMessageSendJitter =
+    exports.applySessionFingerprint =
+    exports.generateSessionFingerprint =
+        void 0
+
+/**
+ * @file session-fingerprint.js
+ * @description Per-session fingerprint randomization (Obscura-inspired).
+ *   Comprehensive anti-detection: device profile, network timing, voice note
+ *   metadata, connection state, and protocol version variance.
+ *   Ported from baileys-antiban to CJS for bilis.
+ * @author Denzy ZeroDay (port), Kobus Wentzel (original)
+ */
+
+const { generateFingerprint } = require('./device-fingerprint')
+
+const DEFAULT_SEND_JITTER_MS = [50, 300]
+const DEFAULT_TYPING_JITTER_MS = [30, 150]
+const DEFAULT_RETRY_JITTER_MS = [100, 500]
+const DEFAULT_DURATION_JITTER_MS = 200
+const DEFAULT_SAMPLE_RATE_POOL = [8000, 16000, 44100, 48000]
+const DEFAULT_IDLE_TIMEOUT_JITTER_MS = [25000, 35000]
+const DEFAULT_KEEPALIVE_JITTER_MS = [15000, 25000]
+const DEFAULT_BATTERY_LEVEL_POOL = [20, 35, 50, 65, 80, 95, 100]
+const DEFAULT_PROTOCOL_VERSION_POOL = ['2.24.5', '2.24.4', '2.24.3']
+
+class SeededRandom {
+    constructor(seed) {
+        let hash = 0
+        for (let i = 0; i < seed.length; i++) {
+            hash = (hash << 5) - hash + seed.charCodeAt(i)
+            hash = hash & hash
+        }
+        this.state = Math.abs(hash) || 1
+    }
+
+    next() {
+        let t = (this.state += 0x6d2b79f5)
+        t = Math.imul(t ^ (t >>> 15), t | 1)
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+    }
+
+    range(min, max) {
+        return Math.floor(this.next() * (max - min + 1)) + min
+    }
+    rangeFloat(min, max) {
+        return this.next() * (max - min) + min
+    }
+    pick(array) {
+        return array[Math.floor(this.next() * array.length)]
+    }
+    boolean(probability = 0.5) {
+        return this.next() < probability
+    }
+}
+
+const generateSessionFingerprint = (config = {}, sessionId) => {
+    const {
+        enabled = true,
+        deviceProfile = {},
+        networkTiming = {},
+        voiceNote = {},
+        connectionState = {},
+        protocolVersion = {},
+        seed
+    } = config
+
+    const finalSessionId = sessionId || `session-${Date.now()}-${Math.random()}`
+    const rng = new SeededRandom(seed || finalSessionId)
+
+    const device = generateFingerprint(
+        {
+            enabled,
+            randomizeAppVersion: deviceProfile.randomizeAppVersion ?? true,
+            randomizeOsVersion: deviceProfile.randomizeOsVersion ?? true,
+            randomizeDeviceModel: deviceProfile.randomizeDeviceModel ?? true,
+            seed: seed || finalSessionId,
+            appVersionPool: deviceProfile.appVersionPool,
+            osVersionPool: deviceProfile.osVersionPool,
+            deviceModelPool: deviceProfile.deviceModelPool
+        },
+        finalSessionId
+    )
+
+    const sendJitterRange = networkTiming.sendJitterMs || DEFAULT_SEND_JITTER_MS
+    const typingJitterRange = networkTiming.typingJitterMs || DEFAULT_TYPING_JITTER_MS
+    const retryJitterRange = networkTiming.retryJitterMs || DEFAULT_RETRY_JITTER_MS
+
+    const networkTimingProfile = enabled
+        ? {
+              sendJitterMs: rng.range(sendJitterRange[0], sendJitterRange[1]),
+              typingJitterMs: rng.range(typingJitterRange[0], typingJitterRange[1]),
+              retryJitterMs: rng.range(retryJitterRange[0], retryJitterRange[1])
+          }
+        : { sendJitterMs: 0, typingJitterMs: 0, retryJitterMs: 0 }
+
+    const sampleRatePool = voiceNote.sampleRatePool || DEFAULT_SAMPLE_RATE_POOL
+    const voiceNoteProfile = {
+        waveformSeed: enabled ? rng.range(0, 2147483647) : 0,
+        durationJitterMs:
+            enabled && voiceNote.randomizeWaveform !== false
+                ? rng.range(0, voiceNote.durationJitterMs || DEFAULT_DURATION_JITTER_MS)
+                : 0,
+        sampleRate: enabled ? rng.pick(sampleRatePool) : sampleRatePool[0]
+    }
+
+    const idleTimeoutRange = connectionState.idleTimeoutJitterMs || DEFAULT_IDLE_TIMEOUT_JITTER_MS
+    const keepaliveRange = connectionState.keepaliveJitterMs || DEFAULT_KEEPALIVE_JITTER_MS
+    const batteryLevelPool = connectionState.batteryLevelPool || DEFAULT_BATTERY_LEVEL_POOL
+
+    const connectionStateProfile = {
+        idleTimeoutMs: enabled ? rng.range(idleTimeoutRange[0], idleTimeoutRange[1]) : 30000,
+        keepaliveMs: enabled ? rng.range(keepaliveRange[0], keepaliveRange[1]) : 20000,
+        batteryLevel:
+            enabled && connectionState.randomizeBattery !== false
+                ? rng.pick(batteryLevelPool)
+                : 100,
+        batteryCharging: enabled ? rng.boolean(0.3) : false
+    }
+
+    const versionPool = protocolVersion.versionPool || DEFAULT_PROTOCOL_VERSION_POOL
+    const protocolVersionStr =
+        enabled && protocolVersion.randomizeSubVersion !== false
+            ? rng.pick(versionPool)
+            : versionPool[0]
+
+    return {
+        device,
+        networkTiming: networkTimingProfile,
+        voiceNote: voiceNoteProfile,
+        connectionState: connectionStateProfile,
+        protocolVersion: protocolVersionStr,
+        sessionId: finalSessionId,
+        createdAt: Date.now()
+    }
+}
+exports.generateSessionFingerprint = generateSessionFingerprint
+
+const applySessionFingerprint = (socketConfig, fingerprint) => {
+    const config = { ...socketConfig }
+    config.version = fingerprint.device.appVersion
+    config.browser = [
+        fingerprint.device.deviceModel,
+        fingerprint.device.osVersion,
+        `WhatsApp/${fingerprint.device.appVersion.join('.')}`
+    ]
+    if (config.connectTimeoutMs !== undefined)
+        config.connectTimeoutMs = fingerprint.connectionState.idleTimeoutMs
+    if (config.keepAliveIntervalMs !== undefined)
+        config.keepAliveIntervalMs = fingerprint.connectionState.keepaliveMs
+    config.__sessionFingerprint = fingerprint
+    return config
+}
+exports.applySessionFingerprint = applySessionFingerprint
+
+const getMessageSendJitter = (fingerprint) => {
+    const base = fingerprint.networkTiming.sendJitterMs
+    return Math.floor(base * 0.5 + Math.random() * base * 0.5)
+}
+exports.getMessageSendJitter = getMessageSendJitter
+
+const getTypingJitter = (fingerprint) => {
+    const base = fingerprint.networkTiming.typingJitterMs
+    return Math.floor(base * 0.5 + Math.random() * base * 0.5)
+}
+exports.getTypingJitter = getTypingJitter
+
+const getRetryJitter = (fingerprint) => {
+    const base = fingerprint.networkTiming.retryJitterMs
+    return Math.floor(base * 0.5 + Math.random() * base * 0.5)
+}
+exports.getRetryJitter = getRetryJitter
+
+const getVoiceNoteMetadata = (fingerprint) => ({
+    sampleRate: fingerprint.voiceNote.sampleRate,
+    durationJitterMs: fingerprint.voiceNote.durationJitterMs,
+    waveformSeed: fingerprint.voiceNote.waveformSeed
+})
+exports.getVoiceNoteMetadata = getVoiceNoteMetadata
+
+const getBatteryState = (fingerprint) => ({
+    level: fingerprint.connectionState.batteryLevel,
+    charging: fingerprint.connectionState.batteryCharging
+})
+exports.getBatteryState = getBatteryState
+
+const createStealthFingerprint = (sessionId) =>
+    generateSessionFingerprint(
+        {
+            enabled: true,
+            deviceProfile: {
+                randomizeAppVersion: true,
+                randomizeOsVersion: true,
+                randomizeDeviceModel: true
+            },
+            networkTiming: {
+                sendJitterMs: [100, 500],
+                typingJitterMs: [50, 200],
+                retryJitterMs: [200, 800]
+            },
+            voiceNote: { randomizeWaveform: true, durationJitterMs: 300 },
+            connectionState: { randomizeBattery: true },
+            protocolVersion: { randomizeSubVersion: true }
+        },
+        sessionId
+    )
+exports.createStealthFingerprint = createStealthFingerprint
+
+module.exports = {
+    generateSessionFingerprint,
+    applySessionFingerprint,
+    getMessageSendJitter,
+    getTypingJitter,
+    getRetryJitter,
+    getVoiceNoteMetadata,
+    getBatteryState,
+    createStealthFingerprint
+}

package/lib/Utils/session-stability.js

@@ -0,0 +1,224 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.wrap_with_session_stability =
+    exports.session_health_monitor =
+    exports.classify_disconnect =
+        void 0
+
+/**
+ * @file session-stability.js
+ * @description Classifies WA disconnect status codes into actionable
+ *   categories (fatal / recoverable / rate-limited / unknown) with
+ *   suggested backoff, and tracks decrypt/Bad-MAC failure rate to detect
+ *   a degraded session before it fully breaks.
+ *   `wrap_with_session_stability` wraps a sock in a Proxy that optionally
+ *   canonicalizes JIDs before sending (via an external lid_resolver) and
+ *   exposes live session health stats.
+ * @author Denzy ZeroDay
+ */
+
+/** Classify a WA disconnect status code into category + recommended action */
+function classify_disconnect(status_code) {
+    if (status_code === 401 || status_code === 440) {
+        return {
+            category: 'fatal',
+            shouldReconnect: false,
+            message: 'Logged out — restart with QR code required',
+            code: status_code
+        }
+    }
+    if (status_code === 515) {
+        return {
+            category: 'fatal',
+            shouldReconnect: false,
+            message: 'Restart required by WhatsApp — client too old or protocol mismatch',
+            code: status_code
+        }
+    }
+    if (status_code === 405) {
+        return {
+            category: 'fatal',
+            shouldReconnect: false,
+            message: 'Method not allowed — server rejected connection method',
+            code: status_code
+        }
+    }
+    if (status_code === 409 || status_code === 428) {
+        return {
+            category: 'fatal',
+            shouldReconnect: false,
+            message: 'Connection replaced — another device took over',
+            code: status_code
+        }
+    }
+    if (status_code === 412) {
+        return {
+            category: 'recoverable',
+            shouldReconnect: true,
+            backoffMs: 30000,
+            message: 'Precondition failed — auth state mismatch, retry after delay',
+            code: status_code
+        }
+    }
+    if (status_code === 429) {
+        return {
+            category: 'rate-limited',
+            shouldReconnect: true,
+            backoffMs: 300000,
+            message: 'Rate limited by WhatsApp — cool-off period required',
+            code: status_code
+        }
+    }
+    if (status_code === 503) {
+        return {
+            category: 'rate-limited',
+            shouldReconnect: true,
+            backoffMs: 60000,
+            message: 'WhatsApp service unavailable — temporary outage',
+            code: status_code
+        }
+    }
+    if (status_code === 408) {
+        return {
+            category: 'recoverable',
+            shouldReconnect: true,
+            backoffMs: 5000,
+            message: 'Connection timeout — network issue, safe to retry',
+            code: status_code
+        }
+    }
+    if (status_code === 500) {
+        return {
+            category: 'recoverable',
+            shouldReconnect: true,
+            backoffMs: 10000,
+            message: 'WhatsApp internal error — temporary server issue',
+            code: status_code
+        }
+    }
+    if (status_code === 1000) {
+        return {
+            category: 'recoverable',
+            shouldReconnect: true,
+            backoffMs: 2000,
+            message: 'Connection closed gracefully — safe to reconnect',
+            code: status_code
+        }
+    }
+    return {
+        category: 'unknown',
+        shouldReconnect: true,
+        backoffMs: 15000,
+        message: `Unknown disconnect reason (code ${status_code}) — reconnect with caution`,
+        code: status_code
+    }
+}
+exports.classify_disconnect = classify_disconnect
+
+const default_health_config = {
+    bad_mac_threshold: 3,
+    bad_mac_window_ms: 60000
+}
+
+class session_health_monitor {
+    constructor(config = {}) {
+        this.config = { ...default_health_config, ...config }
+        this.on_degraded = config.onDegraded
+        this.on_recovered = config.onRecovered
+        this.stats = { decryptSuccess: 0, decryptFail: 0, badMacCount: 0, isDegraded: false }
+        this.bad_mac_timestamps = []
+    }
+
+    /** Record successful decrypt */
+    record_decrypt_success() {
+        this.stats.decryptSuccess++
+        this.check_recovery()
+    }
+
+    /** Record failed decrypt (Bad MAC or similar) */
+    record_decrypt_fail(is_bad_mac = false) {
+        this.stats.decryptFail++
+        if (is_bad_mac) {
+            const now = Date.now()
+            this.stats.badMacCount++
+            this.stats.lastBadMac = new Date(now)
+            this.bad_mac_timestamps.push(now)
+            const cutoff = now - this.config.bad_mac_window_ms
+            this.bad_mac_timestamps = this.bad_mac_timestamps.filter((ts) => ts > cutoff)
+
+            if (
+                !this.stats.isDegraded &&
+                this.bad_mac_timestamps.length >= this.config.bad_mac_threshold
+            ) {
+                this.stats.isDegraded = true
+                this.stats.degradedSince = new Date(now)
+                this.on_degraded?.(this.get_stats())
+            }
+        }
+    }
+
+    /** Check if session has recovered from degraded state */
+    check_recovery() {
+        if (!this.stats.isDegraded) return
+        const now = Date.now()
+        const cutoff = now - this.config.bad_mac_window_ms
+        this.bad_mac_timestamps = this.bad_mac_timestamps.filter((ts) => ts > cutoff)
+
+        if (this.bad_mac_timestamps.length < this.config.bad_mac_threshold) {
+            this.stats.isDegraded = false
+            this.stats.degradedSince = undefined
+            this.on_recovered?.(this.get_stats())
+        }
+    }
+
+    /** Get current health stats */
+    get_stats() {
+        return { ...this.stats }
+    }
+
+    /** Reset all counters */
+    reset() {
+        this.stats = { decryptSuccess: 0, decryptFail: 0, badMacCount: 0, isDegraded: false }
+        this.bad_mac_timestamps = []
+    }
+}
+exports.session_health_monitor = session_health_monitor
+
+/**
+ * Wrap a Baileys sock in a Proxy that:
+ * - optionally canonicalizes JIDs before sendMessage via an external lid_resolver
+ * - exposes `sessionHealthStats` and `sessionHealthMonitor` getters
+ *
+ * @param {object} sock
+ * @param {object} config
+ * @param {boolean} config.canonicalJidNormalization
+ * @param {boolean} config.healthMonitoring
+ * @param {object} config.health - passed to session_health_monitor
+ * @param {object} config.lidResolver - optional, must expose resolveCanonical(jid)
+ */
+function wrap_with_session_stability(sock, config = {}) {
+    const {
+        canonicalJidNormalization = true,
+        healthMonitoring = true,
+        health: health_config,
+        lidResolver: lid_resolver
+    } = config
+    const health_monitor = healthMonitoring ? new session_health_monitor(health_config) : null
+
+    return new Proxy(sock, {
+        get(target, prop) {
+            if (prop === 'sendMessage' && canonicalJidNormalization && lid_resolver) {
+                return async (jid, content, options) => {
+                    const canonical = lid_resolver.resolveCanonical(jid)
+                    return target.sendMessage(canonical, content, options)
+                }
+            }
+            if (prop === 'sessionHealthStats' && health_monitor) return health_monitor.get_stats()
+            if (prop === 'sessionHealthMonitor' && health_monitor) return health_monitor
+            return target[prop]
+        }
+    })
+}
+exports.wrap_with_session_stability = wrap_with_session_stability
+
+module.exports = { classify_disconnect, session_health_monitor, wrap_with_session_stability }