@celestial-community/baileys 0.0.1-security → 1.0.0

package/lib/Utils/retry-reason-tracker.js

@@ -0,0 +1,140 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.retry_reason_tracker = void 0
+
+/**
+ * @file retry-reason-tracker.js
+ * @description Classifies message send failures/retries into known reasons
+ *   (bad_mac, no_session, decryption_failure, server 429/463, etc) and
+ *   detects "retry spirals" — a message stuck retrying repeatedly, which
+ *   usually signals a broken session that needs manual intervention.
+ *   Off by default.
+ * @author Denzy ZeroDay
+ */
+
+const default_config = {
+    enabled: false,
+    max_retries: 5,
+    spiral_threshold: 3,
+    onSpiral: () => {}
+}
+
+class retry_reason_tracker {
+    constructor(config) {
+        this.config = { ...default_config, ...config }
+        this.retries = new Map()
+        this.total_retries = 0
+        this.reason_counts = {
+            no_session: 0,
+            invalid_key: 0,
+            bad_mac: 0,
+            decryption_failure: 0,
+            server_error_463: 0,
+            server_error_429: 0,
+            timeout: 0,
+            no_route: 0,
+            node_malformed: 0,
+            unknown: 0
+        }
+        this.spirals_detected = 0
+    }
+
+    /**
+     * Call when a messages.update event arrives with a status/error.
+     * Classifies and records the retry.
+     */
+    on_message_update(update) {
+        if (!this.config.enabled) return
+        const msg_id = update.key?.id
+        if (!msg_id) return
+        if (update.status !== 0 && !update.error) return
+        const reason = this.classify(update.error || update)
+        this.record_retry(msg_id, reason)
+    }
+
+    /** Classify an arbitrary error object into a retry reason */
+    classify(err) {
+        if (!err) return 'unknown'
+        const status_code = err.output?.statusCode || err.statusCode || err.status
+        if (status_code === 463) return 'server_error_463'
+        if (status_code === 429) return 'server_error_429'
+
+        const error_msg = (err.message || err.text || String(err)).toLowerCase()
+        if (error_msg.includes('bad mac')) return 'bad_mac'
+        if (error_msg.includes('no session') || error_msg.includes('session not found'))
+            return 'no_session'
+        if (error_msg.includes('invalid key') || error_msg.includes('key error'))
+            return 'invalid_key'
+        if (error_msg.includes('decryption') || error_msg.includes('decrypt'))
+            return 'decryption_failure'
+        if (error_msg.includes('timeout') || error_msg.includes('timed out')) return 'timeout'
+        if (
+            error_msg.includes('no route') ||
+            error_msg.includes('unreachable') ||
+            error_msg.includes('offline')
+        )
+            return 'no_route'
+        if (error_msg.includes('malformed') || error_msg.includes('invalid node'))
+            return 'node_malformed'
+        return 'unknown'
+    }
+
+    /** Record a retry for a message */
+    record_retry(msg_id, reason) {
+        const now = Date.now()
+        let record = this.retries.get(msg_id)
+        if (!record) {
+            record = { msgId: msg_id, count: 0, reasons: [], firstRetry: now, lastRetry: now }
+            this.retries.set(msg_id, record)
+        }
+        record.count++
+        record.reasons.push(reason)
+        record.lastRetry = now
+        this.total_retries++
+        this.reason_counts[reason]++
+
+        if (record.count >= this.config.spiral_threshold) {
+            this.spirals_detected++
+            this.config.onSpiral(msg_id, reason)
+        }
+    }
+
+    /** Should we warn the user this message is spiraling? */
+    is_spiraling(msg_id) {
+        const record = this.retries.get(msg_id)
+        return record ? record.count >= this.config.spiral_threshold : false
+    }
+
+    /** Reset counters for a specific message (call on successful delivery) */
+    clear(msg_id) {
+        this.retries.delete(msg_id)
+    }
+
+    /** Get current stats */
+    get_stats() {
+        return {
+            totalRetries: this.total_retries,
+            byReason: { ...this.reason_counts },
+            spiralsDetected: this.spirals_detected,
+            activeRetries: this.retries.size
+        }
+    }
+
+    /** Clean up old retry records (>5 minutes old) */
+    cleanup() {
+        const now = Date.now()
+        const max_age = 5 * 60 * 1000
+        for (const [msg_id, record] of this.retries.entries()) {
+            if (now - record.lastRetry > max_age) this.retries.delete(msg_id)
+        }
+    }
+
+    /** Destroy and clean up */
+    destroy() {
+        this.retries.clear()
+        this.cleanup()
+    }
+}
+
+exports.retry_reason_tracker = retry_reason_tracker
+module.exports = { retry_reason_tracker }

package/lib/Utils/rich-message-utils.d.ts

@@ -0,0 +1,48 @@
+export function tokenizeCode(code: any, language?: string): {
+    highlightType: any;
+    codeContent: string | undefined;
+}[];
+export function toUnified(submessages: any, uuid: any): {
+    response_id: any;
+    sections: any;
+};
+export function prepareRichResponseMessage(content: any): {
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: {
+                    certificateChain: Uint8Array[];
+                    version: number;
+                    useCase: number;
+                    signature: Uint8Array;
+                }[];
+            };
+        };
+    };
+    botForwardedMessage: {
+        message: {
+            richResponseMessage: any;
+        };
+    };
+};
+export function botMetadataSignature(): Uint8Array;
+export function botMetadataCertificate(length?: number): Uint8Array;
+export function wrapToBotForwardedMessage(richResponseMessage: any): {
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: {
+                    certificateChain: Uint8Array[];
+                    version: number;
+                    useCase: number;
+                    signature: Uint8Array;
+                }[];
+            };
+        };
+    };
+    botForwardedMessage: {
+        message: {
+            richResponseMessage: any;
+        };
+    };
+};

package/lib/Utils/rich-message-utils.js

@@ -0,0 +1,400 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', { value: true })
+
+const crypto = require('crypto')
+const Defaults = require('../Defaults')
+const constants = require('../WABinary/constants')
+const RichType = require('../Types/RichType')
+const WAProto = require('../../WAProto')
+const generics = require('./generics')
+
+const DONATE_URL = ''
+const NOOP = new Set([])
+
+const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = constants.LANGUAGE_KEYWORDS[language] || NOOP
+    const blocks = []
+    Defaults.LEXER_REGEX.lastIndex = 0
+    let match
+    while ((match = Defaults.LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({
+                highlightType: RichType.CodeHighlightType.COMMENT,
+                codeContent: match[1]
+            })
+        } else if (match[2]) {
+            blocks.push({ highlightType: RichType.CodeHighlightType.STRING, codeContent: match[2] })
+        } else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3])
+                    ? RichType.CodeHighlightType.KEYWORD
+                    : RichType.CodeHighlightType.METHOD,
+                codeContent: match[3]
+            })
+        } else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4])
+                    ? RichType.CodeHighlightType.KEYWORD
+                    : RichType.CodeHighlightType.DEFAULT,
+                codeContent: match[4]
+            })
+        } else if (match[5]) {
+            blocks.push({ highlightType: RichType.CodeHighlightType.NUMBER, codeContent: match[5] })
+        } else {
+            blocks.push({
+                highlightType: RichType.CodeHighlightType.DEFAULT,
+                codeContent: match[6]
+            })
+        }
+    }
+    return blocks
+}
+
+const toUnified = (submessages, uuid) => ({
+    response_id: uuid || crypto.randomUUID(),
+    sections: submessages.map((submessage) => {
+        switch (submessage.messageType) {
+            case RichType.RichSubMessageType.CODE:
+                const codeMetadata = submessage.codeMetadata
+                return {
+                    view_model: {
+                        primitive: {
+                            language: codeMetadata.codeLanguage,
+                            code_blocks: codeMetadata.codeBlocks.map((block) => ({
+                                content: block.codeContent,
+                                type: RichType.CodeHighlightType[block.highlightType] || 'DEFAULT'
+                            })),
+                            __typename: 'GenAICodeUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                }
+            case RichType.RichSubMessageType.CONTENT_ITEMS:
+                return {}
+            case RichType.RichSubMessageType.INLINE_IMAGE:
+                return {}
+            case RichType.RichSubMessageType.LATEX:
+                return {}
+            case RichType.RichSubMessageType.TABLE:
+                const tableMetadata = submessage.tableMetadata
+                return {
+                    view_model: {
+                        primitive: {
+                            title: tableMetadata.title,
+                            rows: tableMetadata.rows.map((row) => ({
+                                is_header: row.isHeading,
+                                cells: row.items,
+                                markdown_cells: row.items.map((item) => ({ text: item }))
+                            })),
+                            __typename: 'GenATableUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                }
+            case RichType.RichSubMessageType.TEXT:
+                return {
+                    view_model: {
+                        primitive: {
+                            text: submessage.messageText,
+                            inline_entities: submessage.inlineEntities || [],
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                }
+        }
+        return submessage
+    })
+})
+
+const prepareRichResponseMessage = (content) => {
+    const {
+        alignment,
+        code,
+        contentText,
+        disclaimerText,
+        footerText,
+        headerText,
+        imageText,
+        inlineImage,
+        inlineVideo,
+        items,
+        language,
+        latex,
+        links,
+        noHeading,
+        posts,
+        products,
+        suggested,
+        richResponse,
+        table,
+        tapLinkUrl,
+        title
+    } = content
+    let submessages = []
+    if (Array.isArray(richResponse)) {
+        submessages = richResponse.map((submessage) => {
+            if (submessage.text) {
+                return {
+                    messageType: RichType.RichSubMessageType.TEXT,
+                    messageText: submessage.text,
+                    inlineEntities: submessage.inlineEntities
+                }
+            } else if (submessage.code) {
+                return {
+                    messageType: RichType.RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language,
+                        codeBlocks: submessage.code
+                    }
+                }
+            } else if (submessage.items) {
+                return {
+                    messageType: RichType.RichSubMessageType.CONTENT_ITEMS,
+                    contentItemsMetadata: {
+                        itemsMetadata: submessage.items,
+                        contentType:
+                            WAProto.proto.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                    }
+                }
+            } else if (submessage.inlineImage) {
+                return {
+                    messageType: RichType.RichSubMessageType.INLINE_IMAGE,
+                    imageMetadata: {
+                        imageUrl: submessage.inlineImage,
+                        imageText: submessage.imageText,
+                        alignment: submessage.alignment,
+                        tapLinkUrl: submessage.tapLinkUrl
+                    }
+                }
+            } else if (submessage.inlineVideo) {
+                return {
+                    messageType: RichType.RichSubMessageType.TEXT,
+                    messageText: 'INLINE_VIDEO'
+                }
+            } else if (submessage.latex) {
+                return {
+                    messageType: RichType.RichSubMessageType.LATEX,
+                    latexMetadata: {
+                        text: submessage.text,
+                        expressions: submessage.latex
+                    }
+                }
+            } else if (submessage.posts) {
+                return {
+                    messageType: RichType.RichSubMessageType.TEXT,
+                    messageText: 'POSTS'
+                }
+            } else if (submessage.products) {
+                return {
+                    messageType: RichType.RichSubMessageType.TEXT,
+                    messageText: 'PRODUCTS'
+                }
+            } else if (submessage.suggested) {
+                return {
+                    messageType: RichType.RichSubMessageType.TEXT,
+                    messageText: 'SUGGESTED_PROMPT'
+                }
+            } else if (submessage.table) {
+                return {
+                    messageType: RichType.RichSubMessageType.TABLE,
+                    tableMetadata: {
+                        title: submessage.title,
+                        rows: submessage.table
+                    }
+                }
+            }
+            return submessage
+        })
+    } else {
+        if (headerText) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: headerText
+            })
+        }
+        if (contentText) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: contentText
+            })
+        }
+        if (code) {
+            const lang = language || 'javascript'
+            submessages.push({
+                messageType: RichType.RichSubMessageType.CODE,
+                codeMetadata: {
+                    codeLanguage: lang,
+                    codeBlocks: tokenizeCode(code, lang)
+                }
+            })
+        }
+        if (items) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.CONTENT_ITEMS,
+                contentItemsMetadata: {
+                    itemsMetadata: items,
+                    contentType:
+                        WAProto.proto.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                }
+            })
+        }
+        if (inlineImage) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.INLINE_IMAGE,
+                imageMetadata: {
+                    imageUrl: inlineImage,
+                    imageText,
+                    alignment,
+                    tapLinkUrl
+                }
+            })
+        }
+        if (inlineVideo) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: 'INLINE_VIDEO'
+            })
+        }
+        if (latex) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.LATEX,
+                latexMetadata: {
+                    text: content.text,
+                    expressions: latex
+                }
+            })
+        }
+        if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index
+                const url = linkField.url || DONATE_URL
+                const sources = linkField.sources?.map((sourceField) => ({
+                    source_type: 'THIRD_PARTY',
+                    source_display_name: sourceField.displayName || 'Donate',
+                    source_subtitle: sourceField.subtitle || '',
+                    source_url: sourceField.url || url
+                }))
+                submessages.push({
+                    messageType: RichType.RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}¹{{/${prefix}}} `,
+                    inlineEntities: [
+                        {
+                            key: prefix,
+                            metadata: {
+                                reference_id: index + 1,
+                                reference_url: url,
+                                reference_title: linkField.title || 'Citation Reference',
+                                reference_display_name: linkField.displayName || 'Reference',
+                                sources: sources || [],
+                                __typename: 'GenAISearchCitationItem'
+                            }
+                        }
+                    ]
+                })
+            })
+        }
+        if (posts) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: 'POSTS'
+            })
+        }
+        if (products) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: 'PRODUCTS'
+            })
+        }
+        if (suggested) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: 'SUGGESTED_PROMPT'
+            })
+        }
+        if (table) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: table.map((rowItems, index) => ({
+                        isHeading: !noHeading && index == 0,
+                        items: rowItems
+                    }))
+                }
+            })
+        }
+        if (footerText) {
+            submessages.push({
+                messageType: RichType.RichSubMessageType.TEXT,
+                messageText: footerText
+            })
+        }
+    }
+    const uuid = crypto.randomUUID()
+    const unified = toUnified(submessages, uuid)
+    const richResponseMessage = WAProto.proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: WAProto.proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: Buffer.from(JSON.stringify(unified))
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    })
+    const wrappedMsg = wrapToBotForwardedMessage(richResponseMessage)
+    const botMetadata = wrappedMsg.messageContextInfo.botMetadata
+    if (disclaimerText) {
+        botMetadata.messageDisclaimerText = disclaimerText
+    }
+    botMetadata.botResponseId = uuid
+    return wrappedMsg
+}
+
+const botMetadataSignature = () => {
+    const signature = new Uint8Array(64)
+    crypto.randomFillSync(signature)
+    return signature
+}
+
+const botMetadataCertificate = (length = 685) => {
+    const certificate = new Uint8Array(length)
+    certificate[0] = 48
+    certificate[1] = 130
+    crypto.randomFillSync(certificate.subarray(2))
+    return certificate
+}
+
+const wrapToBotForwardedMessage = (richResponseMessage) => ({
+    messageContextInfo: {
+        botMetadata: {
+            verificationMetadata: {
+                proofs: [
+                    {
+                        certificateChain: [botMetadataCertificate(), botMetadataCertificate(892)],
+                        version: 1,
+                        useCase: 1,
+                        signature: botMetadataSignature()
+                    }
+                ]
+            }
+        }
+    },
+    botForwardedMessage: {
+        message: { richResponseMessage }
+    }
+})
+
+module.exports = {
+    tokenizeCode,
+    toUnified,
+    prepareRichResponseMessage,
+    botMetadataSignature,
+    botMetadataCertificate,
+    wrapToBotForwardedMessage
+}