@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,88 @@
+import { proto } from '../../WAProto'
+import { ILogger } from './logger'
+
+export interface RecentMessageKey {
+    to: string
+    id: string
+}
+
+export interface RecentMessage {
+    message: proto.IMessage
+    timestamp: number
+}
+
+export interface SessionRecreateHistory {
+    [jid: string]: number
+}
+
+export interface RetryCounter {
+    [messageId: string]: number
+}
+
+export interface PendingPhoneRequest {
+    [messageId: string]: NodeJS.Timeout
+}
+
+export interface RetryStatistics {
+    totalRetries: number
+    successfulRetries: number
+    failedRetries: number
+    mediaRetries: number
+    sessionRecreations: number
+    phoneRequests: number
+}
+
+export declare class MessageRetryManager {
+    private logger
+    private recentMessagesMap
+    private sessionRecreateHistory
+    private retryCounters
+    private pendingPhoneRequests
+    private readonly maxMsgRetryCount
+    private statistics
+    constructor(logger: ILogger, maxMsgRetryCount: number)
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: string, id: string, message: proto.IMessage): void
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: string, id: string): RecentMessage | undefined
+    /**
+     * Check if a session should be recreated based on retry count and history
+     */
+    shouldRecreateSession(jid: string, retryCount: number, hasSession: boolean): {
+        reason: string
+        recreate: boolean
+    }
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: string): number
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: string): number
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: string): boolean
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: string): void
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: string): void
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: string, callback: () => void, delay?: number): void
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: string): void
+    private keyToString
+}

package/lib/Utils/message-retry-manager.js

@@ -0,0 +1,160 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+
+const LRUCache_1 = require('lru-cache')
+
+/** Number of sent messages to cache in memory for handling retry receipts */
+const RECENT_MESSAGES_SIZE = 512
+
+/** Timeout for session recreation - 1 hour */
+const RECREATE_SESSION_TIMEOUT = 60 * 60 * 1000 // 1 hour in milliseconds
+
+const PHONE_REQUEST_DELAY = 3000
+
+class MessageRetryManager {
+    constructor(logger, maxMsgRetryCount) {
+        this.logger = logger
+        this.recentMessagesMap = new LRUCache_1.LRUCache({
+            max: RECENT_MESSAGES_SIZE
+        })
+        this.sessionRecreateHistory = new LRUCache_1.LRUCache({
+            ttl: RECREATE_SESSION_TIMEOUT * 2,
+            ttlAutopurge: true
+        })
+        this.retryCounters = new LRUCache_1.LRUCache({
+            ttl: 15 * 60 * 1000,
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        }) // 15 minutes TTL
+        this.pendingPhoneRequests = {}
+        this.maxMsgRetryCount = 5
+        this.statistics = {
+            totalRetries: 0,
+            successfulRetries: 0,
+            failedRetries: 0,
+            mediaRetries: 0,
+            sessionRecreations: 0,
+            phoneRequests: 0
+        }
+        this.maxMsgRetryCount = maxMsgRetryCount
+    }
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to, id, message) {
+        const key = { to, id }
+        const keyStr = this.keyToString(key)
+        // Add new message
+        this.recentMessagesMap.set(keyStr, {
+            message,
+            timestamp: Date.now()
+        })
+        this.logger.debug(`Added message to retry cache: ${to}/${id}`)
+    }
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to, id) {
+        const key = { to, id }
+        const keyStr = this.keyToString(key)
+        return this.recentMessagesMap.get(keyStr)
+    }
+    /**
+     * Check if a session should be recreated based on retry count and history
+     */
+    shouldRecreateSession(jid, retryCount, hasSession) {
+        // If we don't have a session, always recreate
+        if (!hasSession) {
+            this.sessionRecreateHistory.set(jid, Date.now())
+            this.statistics.sessionRecreations++
+            return {
+                reason: "we don't have a Signal session with them",
+                recreate: true
+            }
+        }
+        // Only consider recreation if retry count > 1
+        if (retryCount < 2) {
+            return { reason: '', recreate: false }
+        }
+        const now = Date.now()
+        const prevTime = this.sessionRecreateHistory.get(jid)
+        // If no previous recreation or it's been more than an hour
+        if (!prevTime || now - prevTime > RECREATE_SESSION_TIMEOUT) {
+            this.sessionRecreateHistory.set(jid, now)
+            this.statistics.sessionRecreations++
+            return {
+                reason: 'retry count > 1 and over an hour since last recreation',
+                recreate: true
+            }
+        }
+        return { reason: '', recreate: false }
+    }
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId) {
+        this.retryCounters.set(messageId, (this.retryCounters.get(messageId) || 0) + 1)
+        this.statistics.totalRetries++
+        return this.retryCounters.get(messageId)
+    }
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId) {
+        return this.retryCounters.get(messageId) || 0
+    }
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId) {
+        return this.getRetryCount(messageId) >= this.maxMsgRetryCount
+    }
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId) {
+        this.statistics.successfulRetries++
+        // Clean up retry counter for successful message
+        this.retryCounters.delete(messageId)
+        this.cancelPendingPhoneRequest(messageId)
+    }
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId) {
+        this.statistics.failedRetries++
+        this.retryCounters.delete(messageId)
+    }
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId, callback, delay = PHONE_REQUEST_DELAY) {
+        // Cancel any existing request for this message
+        this.cancelPendingPhoneRequest(messageId)
+        this.pendingPhoneRequests[messageId] = setTimeout(() => {
+            delete this.pendingPhoneRequests[messageId]
+            this.statistics.phoneRequests++
+            callback()
+        }, delay)
+        this.logger.debug(`Scheduled phone request for message ${messageId} with ${delay}ms delay`)
+    }
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId) {
+        const timeout = this.pendingPhoneRequests[messageId]
+        if (timeout) {
+            clearTimeout(timeout)
+            delete this.pendingPhoneRequests[messageId]
+            this.logger.debug(`Cancelled pending phone request for message ${messageId}`)
+        }
+    }
+    keyToString(key) {
+        return `${key.to}:${key.id}`
+    }
+}
+
+module.exports = {
+    MessageRetryManager
+}

package/lib/Utils/message-search.d.ts

@@ -0,0 +1,52 @@
+import type { WAMessage } from '../Types'
+
+export interface SearchOptions {
+    caseSensitive?: boolean
+    jid?: string
+    fromDate?: Date
+    toDate?: Date
+    limit?: number
+    messageTypes?: ('text' | 'image' | 'video' | 'document' | 'audio' | 'sticker' | 'location' | 'contact')[]
+    includeCaption?: boolean
+    fromSender?: string
+    fromMe?: boolean
+}
+
+export interface SearchResult {
+    message: WAMessage
+    matchedText: string
+    matchPosition: number
+    relevanceScore: number
+}
+
+export declare const extractMessageText: (message: WAMessage) => string
+
+export declare const searchMessages: (
+    messages: WAMessage[],
+    query: string,
+    options?: SearchOptions
+) => SearchResult[]
+
+export declare const searchMessagesRegex: (
+    messages: WAMessage[],
+    pattern: RegExp,
+    options?: Omit<SearchOptions, 'caseSensitive'>
+) => SearchResult[]
+
+export declare class MessageSearchManager {
+    private messages
+    private messageIndex
+    constructor()
+    addMessages(messages: WAMessage[]): void
+    removeMessages(messageIds: string[]): void
+    clear(): void
+    get count(): number
+    search(query: string, options?: SearchOptions): SearchResult[]
+    searchRegex(pattern: RegExp, options?: Omit<SearchOptions, 'caseSensitive'>): SearchResult[]
+    getByJid(jid: string): WAMessage[]
+    getBySender(sender: string): WAMessage[]
+    getByType(type: 'text' | 'image' | 'video' | 'document' | 'audio' | 'sticker' | 'location' | 'contact'): WAMessage[]
+    getById(id: string): WAMessage | undefined
+}
+
+export declare const createMessageSearch: () => MessageSearchManager

package/lib/Utils/message-search.js

@@ -0,0 +1,226 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.createMessageSearch =
+    exports.MessageSearchManager =
+    exports.searchMessagesRegex =
+    exports.searchMessages =
+    exports.extractMessageText =
+        void 0
+
+/**
+ * Message Search Utilities
+ * Ported from Baileys-Joss
+ */
+
+const extractMessageText = (message) => {
+    const content = message.message
+    if (!content) return ''
+
+    if (content.conversation) return content.conversation
+    if (content.extendedTextMessage?.text) return content.extendedTextMessage.text
+
+    if (content.imageMessage?.caption) return content.imageMessage.caption
+    if (content.videoMessage?.caption) return content.videoMessage.caption
+    if (content.documentMessage?.caption) return content.documentMessage.caption
+
+    if (content.documentMessage?.fileName) return content.documentMessage.fileName
+
+    if (content.locationMessage?.name) return content.locationMessage.name
+    if (content.locationMessage?.address) return content.locationMessage.address
+
+    if (content.contactMessage?.displayName) return content.contactMessage.displayName
+
+    if (content.pollCreationMessage?.name) return content.pollCreationMessage.name
+
+    return ''
+}
+exports.extractMessageText = extractMessageText
+
+const getMessageType = (message) => {
+    const content = message.message
+    if (!content) return 'other'
+
+    if (content.conversation || content.extendedTextMessage) return 'text'
+    if (content.imageMessage) return 'image'
+    if (content.videoMessage) return 'video'
+    if (content.documentMessage) return 'document'
+    if (content.audioMessage) return 'audio'
+    if (content.stickerMessage) return 'sticker'
+    if (content.locationMessage || content.liveLocationMessage) return 'location'
+    if (content.contactMessage || content.contactsArrayMessage) return 'contact'
+
+    return 'other'
+}
+
+const calculateRelevance = (query, text, position) => {
+    let score = 100
+
+    if (text.toLowerCase() === query.toLowerCase()) {
+        score += 50
+    }
+
+    score -= Math.min(position / 10, 20)
+
+    const lowerText = text.toLowerCase()
+    const lowerQuery = query.toLowerCase()
+    if (
+        position === 0 ||
+        lowerText[position - 1] === ' ' ||
+        lowerText[position + lowerQuery.length] === ' ' ||
+        position + lowerQuery.length === text.length
+    ) {
+        score += 20
+    }
+
+    return Math.max(score, 0)
+}
+
+const searchMessages = (messages, query, options = {}) => {
+    const results = []
+    const searchQuery = options.caseSensitive ? query : query.toLowerCase()
+
+    for (const message of messages) {
+        if (options.jid && message.key.remoteJid !== options.jid) continue
+
+        const ts = message.messageTimestamp
+        const messageTime = ts
+            ? new Date(typeof ts === 'number' ? ts * 1000 : Number(ts) * 1000)
+            : null
+
+        if (options.fromDate && messageTime && messageTime < options.fromDate) continue
+        if (options.toDate && messageTime && messageTime > options.toDate) continue
+
+        if (options.fromSender && message.key.participant !== options.fromSender) continue
+        if (options.fromMe !== undefined && message.key.fromMe !== options.fromMe) continue
+
+        if (options.messageTypes && options.messageTypes.length > 0) {
+            const type = getMessageType(message)
+            if (!options.messageTypes.includes(type)) continue
+        }
+
+        const text = (0, exports.extractMessageText)(message)
+        if (!text) continue
+
+        const searchText = options.caseSensitive ? text : text.toLowerCase()
+        const position = searchText.indexOf(searchQuery)
+
+        if (position !== -1) {
+            results.push({
+                message,
+                matchedText: text.substring(
+                    Math.max(0, position - 20),
+                    Math.min(text.length, position + query.length + 20)
+                ),
+                matchPosition: position,
+                relevanceScore: calculateRelevance(query, text, position)
+            })
+        }
+
+        if (options.limit && results.length >= options.limit) break
+    }
+
+    results.sort((a, b) => b.relevanceScore - a.relevanceScore)
+
+    return results
+}
+exports.searchMessages = searchMessages
+
+const searchMessagesRegex = (messages, pattern, options = {}) => {
+    const results = []
+
+    for (const message of messages) {
+        if (options.jid && message.key.remoteJid !== options.jid) continue
+        if (options.fromSender && message.key.participant !== options.fromSender) continue
+        if (options.fromMe !== undefined && message.key.fromMe !== options.fromMe) continue
+
+        if (options.messageTypes && options.messageTypes.length > 0) {
+            const type = getMessageType(message)
+            if (!options.messageTypes.includes(type)) continue
+        }
+
+        const text = (0, exports.extractMessageText)(message)
+        if (!text) continue
+
+        const match = text.match(pattern)
+        if (match) {
+            results.push({
+                message,
+                matchedText: match[0],
+                matchPosition: match.index || 0,
+                relevanceScore: 100
+            })
+        }
+
+        if (options.limit && results.length >= options.limit) break
+    }
+
+    return results
+}
+exports.searchMessagesRegex = searchMessagesRegex
+
+class MessageSearchManager {
+    constructor() {
+        this.messages = []
+        this.messageIndex = new Map()
+    }
+
+    addMessages(messages) {
+        for (const msg of messages) {
+            const id = msg.key.id
+            if (id && !this.messageIndex.has(id)) {
+                this.messages.push(msg)
+                this.messageIndex.set(id, msg)
+            }
+        }
+    }
+
+    removeMessages(messageIds) {
+        const idSet = new Set(messageIds)
+        this.messages = this.messages.filter((m) => !idSet.has(m.key.id || ''))
+        for (const id of messageIds) {
+            this.messageIndex.delete(id)
+        }
+    }
+
+    clear() {
+        this.messages = []
+        this.messageIndex.clear()
+    }
+
+    get count() {
+        return this.messages.length
+    }
+
+    search(query, options) {
+        return (0, exports.searchMessages)(this.messages, query, options)
+    }
+
+    searchRegex(pattern, options) {
+        return (0, exports.searchMessagesRegex)(this.messages, pattern, options)
+    }
+
+    getByJid(jid) {
+        return this.messages.filter((m) => m.key.remoteJid === jid)
+    }
+
+    getBySender(sender) {
+        return this.messages.filter(
+            (m) => m.key.participant === sender || m.key.remoteJid === sender
+        )
+    }
+
+    getByType(type) {
+        return this.messages.filter((m) => getMessageType(m) === type)
+    }
+
+    getById(id) {
+        return this.messageIndex.get(id)
+    }
+}
+exports.MessageSearchManager = MessageSearchManager
+
+const createMessageSearch = () => {
+    return new MessageSearchManager()
+}
+exports.createMessageSearch = createMessageSearch