@fer2809fl/baileys 7.0.4 → 7.0.5

package/lib/Utils/message-queue.js

@@ -0,0 +1,226 @@
+import { LRUCache } from 'lru-cache';
+
+const PRIORITY = {
+    CRITICAL: 0,
+    HIGH: 1,
+    NORMAL: 2,
+    LOW: 3,
+    BACKGROUND: 4
+};
+
+const QUEUE_CONFIG = {
+    MAX_QUEUE_SIZE: 1000,
+    PROCESS_INTERVAL: 50,
+    RATE_LIMITS: {
+        message: { count: 100, window: 60000 },
+        group: { count: 40, window: 60000 },
+        media: { count: 50, window: 60000 },
+        broadcast: { count: 200, window: 3600000 }
+    },
+    DELAYS: {
+        message: 300,
+        group: 500,
+        media: 800,
+        broadcast: 1500
+    }
+};
+
+class QueueItem {
+    constructor(task, priority = PRIORITY.NORMAL, metadata = {}) {
+        this.id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        this.task = task;
+        this.priority = priority;
+        this.metadata = metadata;
+        this.createdAt = Date.now();
+        this.attempts = 0;
+        this.maxAttempts = metadata.maxAttempts || 3;
+        this.status = 'pending';
+    }
+}
+
+class MessageQueue {
+    constructor(logger, config = {}) {
+        this.logger = logger;
+        this.config = { ...QUEUE_CONFIG, ...config };
+        this.queue = [];
+        this.processing = false;
+        this.paused = false;
+        this.rateLimiters = new Map();
+        this.processTimer = null;
+        this.stats = {
+            totalQueued: 0,
+            totalProcessed: 0,
+            totalFailed: 0,
+            averageWaitTime: 0
+        };
+        this.recentMessages = new LRUCache({ max: 500, ttl: 300000 });
+    }
+
+    enqueue(task, priority = PRIORITY.NORMAL, metadata = {}) {
+        if (this.queue.length >= this.config.MAX_QUEUE_SIZE) {
+            this.logger?.warn('Queue is full, dropping oldest low priority items');
+            this._dropLowPriority();
+        }
+        const item = new QueueItem(task, priority, metadata);
+        const hash = this._hashTask(task, metadata);
+        if (this.recentMessages.has(hash) && !metadata.allowDuplicate) {
+            this.logger?.debug({ hash }, 'Duplicate message detected, skipping');
+            return null;
+        }
+        let inserted = false;
+        for (let i = 0; i < this.queue.length; i++) {
+            if (this.queue[i].priority > priority) {
+                this.queue.splice(i, 0, item);
+                inserted = true;
+                break;
+            }
+        }
+        if (!inserted) this.queue.push(item);
+        this.stats.totalQueued++;
+        this.recentMessages.set(hash, true);
+        this.logger?.debug({ id: item.id, priority, queueSize: this.queue.length }, 'Task enqueued');
+        if (!this.processing && !this.paused) this._startProcessing();
+        return item.id;
+    }
+
+    _hashTask(task, metadata) {
+        const data = JSON.stringify({ jid: metadata.jid, content: typeof task === 'function' ? metadata.contentHash : task });
+        return Buffer.from(data).toString('base64').substr(0, 32);
+    }
+
+    _dropLowPriority() {
+        this.queue.sort((a, b) => b.priority - a.priority);
+        const toDrop = Math.ceil(this.queue.length * 0.1);
+        const dropped = this.queue.splice(0, toDrop);
+        this.logger?.warn({ dropped: dropped.length }, 'Dropped low priority items');
+    }
+
+    _startProcessing() {
+        if (this.processTimer) return;
+        this.processing = true;
+        this.processTimer = setInterval(() => this._processNext(), this.config.PROCESS_INTERVAL);
+    }
+
+    _stopProcessing() {
+        if (this.processTimer) {
+            clearInterval(this.processTimer);
+            this.processTimer = null;
+        }
+        this.processing = false;
+    }
+
+    async _processNext() {
+        if (this.paused || this.queue.length === 0) {
+            if (this.queue.length === 0) this._stopProcessing();
+            return;
+        }
+        const item = this.queue.shift();
+        if (!item) return;
+        item.status = 'processing';
+        item.attempts++;
+        const waitTime = Date.now() - item.createdAt;
+        this._updateAverageWaitTime(waitTime);
+        try {
+            const type = item.metadata.type || 'message';
+            await this._checkRateLimit(type, item.metadata.jid);
+            const result = typeof item.task === 'function' ? await item.task() : item.task;
+            item.status = 'completed';
+            this.stats.totalProcessed++;
+            this.logger?.debug({ id: item.id, waitTime }, 'Task completed');
+            const delay = this.config.DELAYS[type] || this.config.DELAYS.message;
+            await this._delay(delay);
+            return result;
+        } catch (error) {
+            this.logger?.error({ id: item.id, error: error.message }, 'Task failed');
+            if (item.attempts < item.maxAttempts) {
+                item.priority = Math.min(item.priority + 1, PRIORITY.BACKGROUND);
+                item.status = 'pending';
+                this.queue.push(item);
+                this.logger?.debug({ id: item.id, attempts: item.attempts }, 'Task re-queued');
+            } else {
+                item.status = 'failed';
+                this.stats.totalFailed++;
+                this.logger?.warn({ id: item.id }, 'Task permanently failed');
+            }
+        }
+    }
+
+    async _checkRateLimit(type, jid) {
+        const limit = this.config.RATE_LIMITS[type] || this.config.RATE_LIMITS.message;
+        const key = jid ? `${type}:${jid}` : type;
+        if (!this.rateLimiters.has(key)) this.rateLimiters.set(key, []);
+        const timestamps = this.rateLimiters.get(key);
+        const now = Date.now();
+        const valid = timestamps.filter(ts => now - ts < limit.window);
+        this.rateLimiters.set(key, valid);
+        if (valid.length >= limit.count) {
+            const oldestValid = valid[valid.length - limit.count];
+            const waitTime = limit.window - (now - oldestValid);
+            if (waitTime > 0) {
+                this.logger?.debug({ key, waitTime }, 'Rate limited, waiting');
+                await this._delay(waitTime);
+            }
+        }
+        valid.push(now);
+    }
+
+    _updateAverageWaitTime(newTime) {
+        const total = this.stats.totalProcessed;
+        this.stats.averageWaitTime = (this.stats.averageWaitTime * total + newTime) / (total + 1);
+    }
+
+    _delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    pause() {
+        this.paused = true;
+        this.logger?.info('Queue paused');
+    }
+
+    resume() {
+        this.paused = false;
+        if (this.queue.length > 0 && !this.processing) this._startProcessing();
+        this.logger?.info('Queue resumed');
+    }
+
+    clear(priority = null) {
+        if (priority !== null) this.queue = this.queue.filter(item => item.priority !== priority);
+        else this.queue = [];
+        this.logger?.info({ cleared: true, remaining: this.queue.length }, 'Queue cleared');
+    }
+
+    getStats() {
+        return {
+            ...this.stats,
+            currentQueueSize: this.queue.length,
+            isProcessing: this.processing,
+            isPaused: this.paused,
+            pendingByPriority: {
+                critical: this.queue.filter(i => i.priority === PRIORITY.CRITICAL).length,
+                high: this.queue.filter(i => i.priority === PRIORITY.HIGH).length,
+                normal: this.queue.filter(i => i.priority === PRIORITY.NORMAL).length,
+                low: this.queue.filter(i => i.priority === PRIORITY.LOW).length,
+                background: this.queue.filter(i => i.priority === PRIORITY.BACKGROUND).length
+            }
+        };
+    }
+
+    cleanup() {
+        this._stopProcessing();
+        this.queue = [];
+        this.rateLimiters.clear();
+    }
+}
+
+function createMessageQueue(logger, customConfig = {}) {
+    return new MessageQueue(logger, customConfig);
+}
+
+export {
+    PRIORITY,
+    QUEUE_CONFIG,
+    QueueItem,
+    MessageQueue,
+    createMessageQueue
+};

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

@@ -0,0 +1,21 @@
+export declare function toUnified(submessages: any[], uuid?: string): { response_id: string; sections: any[] };
+
+export interface RichResponseContent {
+    headerText?: string;
+    contentText?: string;
+    footerText?: string;
+    disclaimerText?: string;
+    code?: string;
+    language?: string;
+    table?: any[][];
+    title?: string;
+    noHeading?: boolean;
+    links?: Array<{ text: string; url?: string; title?: string; displayName?: string }>;
+    richResponse?: any[];
+    [key: string]: any;
+}
+
+export declare function prepareRichResponseMessage(content: RichResponseContent): any;
+export declare function botMetadataSignature(): Uint8Array;
+export declare function botMetadataCertificate(length?: number): Uint8Array;
+export declare function wrapToBotForwardedMessage(richResponseMessage: any): any;

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

@@ -0,0 +1,229 @@
+import { randomUUID, getRandomValues } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { CodeHighlightType, RichSubMessageType, LANGUAGE_KEYWORDS } from './rich-messages.js';
+
+const LEXER_REGEX = /(\/\/[^\n]*|\/\*[\s\S]*?\*\/|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`|\b\d+\.?\d*\b|\b[a-zA-Z_$][\w$]*\b|\s+|[^\s\w$]+)/g;
+const NOOP = new Set([]);
+
+const tokenizeCode = (code, language = 'javascript') => {
+    const keywords = LANGUAGE_KEYWORDS[language] || NOOP;
+    const blocks = [];
+    LEXER_REGEX.lastIndex = 0;
+    let match;
+    while ((match = LEXER_REGEX.exec(code)) !== null) {
+        if (match[1]) {
+            blocks.push({ highlightType: CodeHighlightType.COMMENT, codeContent: match[1] });
+        } else if (match[2]) {
+            blocks.push({ highlightType: CodeHighlightType.STRING, codeContent: match[2] });
+        } else if (match[3]) {
+            blocks.push({
+                highlightType: keywords.has(match[3]) ? CodeHighlightType.KEYWORD : CodeHighlightType.METHOD,
+                codeContent: match[3]
+            });
+        } else if (match[4]) {
+            blocks.push({
+                highlightType: keywords.has(match[4]) ? CodeHighlightType.KEYWORD : CodeHighlightType.DEFAULT,
+                codeContent: match[4]
+            });
+        } else if (match[5]) {
+            blocks.push({ highlightType: CodeHighlightType.NUMBER, codeContent: match[5] });
+        } else {
+            blocks.push({ highlightType: CodeHighlightType.DEFAULT, codeContent: match[6] });
+        }
+    }
+    return blocks;
+};
+
+const toUnified = (submessages, uuid) => ({
+    response_id: uuid || randomUUID(),
+    sections: submessages.map(submessage => {
+        switch (submessage.messageType) {
+            case RichSubMessageType.CODE: {
+                const codeMetadata = submessage.codeMetadata;
+                return {
+                    view_model: {
+                        primitive: {
+                            language: codeMetadata.codeLanguage,
+                            code_blocks: codeMetadata.codeBlocks.map(block => ({
+                                content: block.codeContent,
+                                type: CodeHighlightType[block.highlightType]
+                            })),
+                            __typename: 'GenAICodeUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+            }
+            case 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 RichSubMessageType.TEXT:
+                return {
+                    view_model: {
+                        primitive: {
+                            text: submessage.messageText,
+                            inline_entities: submessage.inlineEntities || [],
+                            __typename: 'GenAIMarkdownTextUXPrimitive'
+                        },
+                        __typename: 'GenAISingleLayoutViewModel'
+                    }
+                };
+        }
+        return submessage;
+    })
+});
+
+const botMetadataSignature = () => {
+    const signature = new Uint8Array(64);
+    getRandomValues(signature);
+    return signature;
+};
+
+const botMetadataCertificate = (length = 685) => {
+    const certificate = new Uint8Array(length);
+    certificate[0] = 48;
+    certificate[1] = 130;
+    getRandomValues(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 }
+    }
+});
+
+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: RichSubMessageType.TEXT, messageText: submessage.text, inlineEntities: submessage.inlineEntities };
+            } else if (submessage.code) {
+                return {
+                    messageType: RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language || 'javascript',
+                        codeBlocks: typeof submessage.code === 'string'
+                            ? tokenizeCode(submessage.code, submessage.language || 'javascript')
+                            : submessage.code
+                    }
+                };
+            } else if (submessage.table) {
+                return {
+                    messageType: RichSubMessageType.TABLE,
+                    tableMetadata: { title: submessage.title, rows: submessage.table }
+                };
+            }
+            return submessage;
+        });
+    } else {
+        if (headerText) submessages.push({ messageType: RichSubMessageType.TEXT, messageText: headerText });
+        if (contentText) submessages.push({ messageType: RichSubMessageType.TEXT, messageText: contentText });
+        if (code) {
+            const lang = language || 'javascript';
+            submessages.push({
+                messageType: RichSubMessageType.CODE,
+                codeMetadata: { codeLanguage: lang, codeBlocks: tokenizeCode(code, lang) }
+            });
+        }
+        if (links) {
+            links.forEach((linkField, index) => {
+                const prefix = 'SS_' + index;
+                submessages.push({
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: linkField.text + ` {{${prefix}}}1{{/${prefix}}} `,
+                    inlineEntities: [{
+                        key: prefix,
+                        metadata: {
+                            reference_id: index + 1,
+                            reference_url: linkField.url || '',
+                            reference_title: linkField.title || 'Reference',
+                            reference_display_name: linkField.displayName || 'Source',
+                            sources: [],
+                            __typename: 'GenAISearchCitationItem'
+                        }
+                    }]
+                });
+            });
+        }
+        if (table) {
+            submessages.push({
+                messageType: RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: table.map((items, index) => ({ isHeading: !noHeading && index === 0, items }))
+                }
+            });
+        }
+        if (footerText) submessages.push({ messageType: RichSubMessageType.TEXT, messageText: footerText });
+    }
+
+    const uuid = randomUUID();
+    const unified = toUnified(submessages, uuid);
+
+    const richResponseMessage = proto.AIRichResponseMessage.create({
+        submessages,
+        messageType: 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 message = wrapToBotForwardedMessage(richResponseMessage);
+    const botMetadata = message.messageContextInfo.botMetadata;
+    if (disclaimerText) botMetadata.messageDisclaimerText = disclaimerText;
+    botMetadata.botResponseId = uuid;
+
+    return message;
+};
+
+export {
+    toUnified,
+    prepareRichResponseMessage,
+    botMetadataSignature,
+    botMetadataCertificate,
+    wrapToBotForwardedMessage
+};

package/lib/Utils/rich-messages.d.ts

@@ -273,5 +273,57 @@ export declare const generateLinkContentV2: (
   message: any;
   messageId: string;
 };
+
+/**
+ * Opciones para generar un mensaje HTML embebido en WhatsApp.
+ *
+ * El mensaje resultante es renderizado por el cliente de WhatsApp como un
+ * WebView sandboxed dentro del bocadillo del mensaje, usando el campo interno
+ * `GenAIaeacdsnwHtmlPrimitive` del protocolo AIRichResponseMessage.
+ */
+export interface HtmlContentOptions extends RichMessageOptions {
+  /**
+   * Dominios que el WebView puede contactar (fetch, imágenes, fuentes, etc.).
+   * Sin esquema (ej: `["api.tuyo.com", "cdn.tuyo.com"]`).
+   * Default: `[]` (sin red).
+   */
+  trustedSources?: string[];
+  /** Cabecera opcional arriba del HTML (markdown). */
+  headerText?: string;
+  /** Pie opcional debajo del HTML (markdown). */
+  footer?: string;
+  /**
+   * Texto mostrado en el submessage de respaldo si el cliente no soporta
+   * HTML. Default: `"Contenido interactivo"`.
+   */
+  fallbackText?: string;
+}
+
+/**
+ * Construye un mensaje que el cliente de WhatsApp renderiza como un WebView
+ * embebido dentro del bocadillo del mensaje.
+ *
+ * Ver `HtmlContentOptions` para las limitaciones estructurales conocidas y
+ * el patrón recomendado (backend + inyección de estado + JWT).
+ *
+ * @example
+ * ```ts
+ * const html = `<body><h1>Hola ${jid}</h1></body>`;
+ * const { message, messageId } = generateHtmlContent(html, quoted, {
+ *   trustedSources: ["api.tuyo.com"],
+ *   headerText: "Demo HTML",
+ * });
+ * await sock.relayMessage(jid, message, { messageId });
+ * ```
+ */
+export declare const generateHtmlContent: (
+  html: string,
+  quoted?: QuotedMessage | null,
+  options?: HtmlContentOptions,
+) => {
+  message: any;
+  messageId: string;
+};
+
 export {};
 //# sourceMappingURL=rich-messages.d.ts.map