@boruto_vk7/baileys 1.0.0

package/lib/Utils/reporting-utils.js

@@ -0,0 +1,257 @@
+import { createHmac } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+import { hkdf } from './crypto.js';
+const reportingFields = [
+    { f: 1 },
+    {
+        f: 3,
+        s: [{ f: 2 }, { f: 3 }, { f: 8 }, { f: 11 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 25 }]
+    },
+    { f: 4, s: [{ f: 1 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 5, s: [{ f: 3 }, { f: 4 }, { f: 5 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 6, s: [{ f: 1 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 30 }] },
+    { f: 7, s: [{ f: 2 }, { f: 7 }, { f: 10 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 8, s: [{ f: 2 }, { f: 7 }, { f: 9 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 21 }] },
+    { f: 9, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 12, s: [{ f: 1 }, { f: 2 }, { f: 14, m: true }, { f: 15 }] },
+    { f: 18, s: [{ f: 6 }, { f: 16 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 26, s: [{ f: 4 }, { f: 5 }, { f: 8 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 28, s: [{ f: 1 }, { f: 2 }, { f: 4 }, { f: 5 }, { f: 6 }, { f: 7, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 37, s: [{ f: 1, m: true }] },
+    {
+        f: 49,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    { f: 53, s: [{ f: 1, m: true }] },
+    { f: 55, s: [{ f: 1, m: true }] },
+    { f: 58, s: [{ f: 1, m: true }] },
+    { f: 59, s: [{ f: 1, m: true }] },
+    {
+        f: 60,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    {
+        f: 64,
+        s: [
+            { f: 2 },
+            { f: 3, s: [{ f: 1 }, { f: 2 }] },
+            { f: 5, s: [{ f: 21 }, { f: 22 }] },
+            { f: 8, s: [{ f: 1 }, { f: 2 }] }
+        ]
+    },
+    { f: 66, s: [{ f: 2 }, { f: 6 }, { f: 7 }, { f: 13 }, { f: 17, s: [{ f: 21 }, { f: 22 }] }, { f: 20 }] },
+    { f: 74, s: [{ f: 1, m: true }] },
+    { f: 87, s: [{ f: 1, m: true }] },
+    { f: 88, s: [{ f: 1 }, { f: 2, s: [{ f: 1 }] }, { f: 3, s: [{ f: 21 }, { f: 22 }] }] },
+    { f: 92, s: [{ f: 1, m: true }] },
+    { f: 93, s: [{ f: 1, m: true }] },
+    { f: 94, s: [{ f: 1, m: true }] }
+];
+const compileReportingFields = (fields) => {
+    const map = new Map();
+    for (const f of fields) {
+        map.set(f.f, {
+            m: f.m,
+            children: f.s ? compileReportingFields(f.s) : undefined
+        });
+    }
+    return map;
+};
+const compiledReportingFields = compileReportingFields(reportingFields);
+const EMPTY_MAP = new Map();
+const ENC_SECRET_REPORT_TOKEN = 'Report Token';
+const WIRE = {
+    VARINT: 0,
+    FIXED64: 1,
+    BYTES: 2,
+    FIXED32: 5
+};
+export const shouldIncludeReportingToken = (message) => !message.reactionMessage &&
+    !message.encReactionMessage &&
+    !message.encEventResponseMessage &&
+    !message.pollUpdateMessage;
+const generateMsgSecretKey = (modificationType, origMsgId, origMsgSender, modificationSender, origMsgSecret) => {
+    const useCaseSecret = Buffer.concat([
+        Buffer.from(origMsgId, 'utf8'),
+        Buffer.from(origMsgSender, 'utf8'),
+        Buffer.from(modificationSender, 'utf8'),
+        Buffer.from(modificationType, 'utf8')
+    ]);
+    return hkdf(origMsgSecret, 32, { info: useCaseSecret.toString('latin1') });
+};
+const extractReportingTokenContent = (data, cfg) => {
+    const out = [];
+    let i = 0;
+    while (i < data.length) {
+        const tag = decodeVarint(data, i);
+        if (!tag.ok) {
+            return null;
+        }
+        const fieldNum = tag.value >> 3;
+        const wireType = tag.value & 0x7;
+        const fieldStart = i;
+        i += tag.bytes;
+        const fieldCfg = cfg.get(fieldNum);
+        const pushSlice = (end) => {
+            if (end > data.length) {
+                return false;
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, end) });
+            i = end;
+            return true;
+        };
+        const skip = (end) => {
+            if (end > data.length) {
+                return false;
+            }
+            i = end;
+            return true;
+        };
+        if (wireType === WIRE.VARINT) {
+            const v = decodeVarint(data, i);
+            if (!v.ok) {
+                return null;
+            }
+            const end = i + v.bytes;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.FIXED64) {
+            const end = i + 8;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.FIXED32) {
+            const end = i + 4;
+            if (!fieldCfg) {
+                if (!skip(end)) {
+                    return null;
+                }
+                continue;
+            }
+            if (!pushSlice(end)) {
+                return null;
+            }
+            continue;
+        }
+        if (wireType === WIRE.BYTES) {
+            const len = decodeVarint(data, i);
+            if (!len.ok) {
+                return null;
+            }
+            const valStart = i + len.bytes;
+            const valEnd = valStart + len.value;
+            if (valEnd > data.length) {
+                return null;
+            }
+            if (!fieldCfg) {
+                i = valEnd;
+                continue;
+            }
+            if (fieldCfg.m || fieldCfg.children) {
+                const sub = extractReportingTokenContent(data.subarray(valStart, valEnd), fieldCfg.children ?? EMPTY_MAP);
+                if (sub === null) {
+                    return null;
+                }
+                if (sub.length > 0) {
+                    const newTag = encodeVarint(tag.value);
+                    const newLen = encodeVarint(sub.length);
+                    out.push({
+                        num: fieldNum,
+                        bytes: Buffer.concat([newTag, newLen, sub])
+                    });
+                }
+                i = valEnd;
+                continue;
+            }
+            out.push({ num: fieldNum, bytes: data.subarray(fieldStart, valEnd) });
+            i = valEnd;
+            continue;
+        }
+        return null;
+    }
+    if (out.length === 0) {
+        return Buffer.alloc(0);
+    }
+    out.sort((a, b) => a.num - b.num);
+    return Buffer.concat(out.map(f => f.bytes));
+};
+const decodeVarint = (buffer, offset) => {
+    let value = 0;
+    let bytes = 0;
+    let shift = 0;
+    while (offset + bytes < buffer.length) {
+        const current = buffer[offset + bytes];
+        value |= (current & 0x7f) << shift;
+        bytes++;
+        if ((current & 0x80) === 0) {
+            return { value, bytes, ok: true };
+        }
+        shift += 7;
+        if (shift > 35) {
+            return { value: 0, bytes: 0, ok: false };
+        }
+    }
+    return { value: 0, bytes: 0, ok: false };
+};
+const encodeVarint = (value) => {
+    const parts = [];
+    let remaining = value >>> 0;
+    while (remaining > 0x7f) {
+        parts.push((remaining & 0x7f) | 0x80);
+        remaining >>>= 7;
+    }
+    parts.push(remaining);
+    return Buffer.from(parts);
+};
+export const getMessageReportingToken = async (msgProtobuf, message, key) => {
+    const msgSecret = message.messageContextInfo?.messageSecret;
+    if (!msgSecret || !key.id) {
+        return null;
+    }
+    const from = key.fromMe ? key.remoteJid : key.participant || key.remoteJid;
+    const to = key.fromMe ? key.participant || key.remoteJid : key.remoteJid;
+    const reportingSecret = generateMsgSecretKey(ENC_SECRET_REPORT_TOKEN, key.id, from, to, msgSecret);
+    const content = extractReportingTokenContent(msgProtobuf, compiledReportingFields);
+    if (!content || content.length === 0) {
+        return null;
+    }
+    const reportingToken = createHmac('sha256', reportingSecret).update(content).digest().subarray(0, 16);
+    return {
+        tag: 'reporting',
+        attrs: {},
+        content: [
+            {
+                tag: 'reporting_token',
+                attrs: { v: '2' },
+                content: reportingToken
+            }
+        ]
+    };
+};

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

@@ -0,0 +1,387 @@
+/**
+ * Lia@Changes 09-04-26 [WIP]
+ * Adds support for tables and code blocks with richResponseMessage (wrapped inside botForwardedMessage).
+ *
+ * If you use or copy this code, please credit my name or project.
+ * @boruto_vk7/baileys
+ */
+import { getRandomValues, randomUUID, randomBytes } from 'crypto';
+import { BOT_RENDERING_CONFIG_METADATA, DONATE_URL, LEXER_REGEX } from '../Defaults/index.js';
+import { LANGUAGE_KEYWORDS } from '../WABinary/constants.js';
+import { CodeHighlightType, RichSubMessageType } from '../Types/RichType.js';
+import { proto } from '../../WAProto/index.js';
+import { unixTimestampSeconds } from './generics.js';
+const textEncoder = new TextEncoder();
+const NOOP = new Set([]);
+export 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;
+};
+// Lia@Changes 09-04-26 --- Inject buffer into unifiedResponse.data to support proper rendering of rich messages (ex: tables and code blocks)
+export const toUnified = (submessages) =>
+    ({
+        response_id: randomUUID(),
+        sections: submessages.map((submessage, index) => {
+            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.CONTENT_ITEMS:
+                    return {
+                        view_model: {
+                            primitives: submessage.contentItemsMetadata.itemsMetadata.map((item) => {
+                                const reelItem = item.reelItem
+                                return {
+                                    reels_url: reelItem.videoUrl,
+                                    thumbnail_url: reelItem.thumbnailUrl,
+                                    creator: reelItem.creator || '@boruto_vk7/baileys',
+                                    avatar_url: reelItem.profileIconUrl,
+                                    reels_title: reelItem.title,
+                                    likes_count: reelItem.likesCount || 0,
+                                    shares_count: reelItem.sharesCount || 0,
+                                    view_count: reelItem.viewCount || 0,
+                                    reel_source: reelItem.reelSource || 'IG',
+                                    is_verified: reelItem.isVerified || false,
+                                    __typename: 'GenAIReelPrimitive'
+                                }
+                            }),
+                            __typename: 'GenAIHScrollLayoutViewModel'
+                        }
+                    };
+                case RichSubMessageType.LATEX:
+                    const latexMetadata = submessage.latexMetadata;
+                    const item = {
+                        latex_expression: latexMetadata.expressions[0]?.latexExpression,
+                        font_height: latexMetadata.expressions[0]?.fontHeight,
+                        padding: 15,
+                        latex_image: {
+                            url: latexMetadata.expressions[0]?.url,
+                            width: latexMetadata.expressions[0]?.width || 388,
+                            height: latexMetadata.expressions[0]?.height || 160
+                        }
+                    };
+                    return {
+                        view_model: {
+                            primitive: {
+                                item,
+                                ...item,
+                                __typename: 'GenAILatexUXPrimitive'
+                            },
+                            __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: [] })),
+                                __typename: 'GenATableUXPrimitive'
+                            },
+                            __typename: 'GenAISingleLayoutViewModel'
+                        }
+                    };
+                case RichSubMessageType.TEXT:
+                    const shouldAddInlineEntity = index == 0;
+                    const inlineEntity = [{
+                        key: 'Starseed',
+                        metadata: {
+                            reference_id: 1,
+                            reference_url: DONATE_URL,
+                            reference_title: 'For Donation via Saweria',
+                            reference_display_name: 'Donate',
+                            sources: [{
+                                source_type: 'THIRD_PARTY',
+                                source_display_name: 'Donate',
+                                source_subtitle: '',
+                                source_url: DONATE_URL
+                            }],
+                            __typename: 'GenAISearchCitationItem'
+                        }
+                    }];
+                    const textEntity = shouldAddInlineEntity ?
+                        '{{Starseed}}¹{{/Starseed}}' :
+                        '';
+                    return {
+                        view_model: {
+                            primitive: {
+                                text: submessage.messageText + textEntity,
+                                inline_entities: shouldAddInlineEntity ?
+                                    inlineEntity :
+                                    [],
+                                __typename: 'GenAIMarkdownTextUXPrimitive'
+                            },
+                            __typename: 'GenAISingleLayoutViewModel'
+                        }
+                    };
+            }
+            return submessage;
+        })
+    });
+// Lia@Note 17-04-26 --- WIP
+export const buildAdditionalBotMetadataContext = (submessages) => {
+    const sources = [];
+    const mediaDetailsMetadataList = [];
+    for (let i = 0; i < submessages.length; i++) {
+        const submessage = submessages[i];
+        switch (submessage.messageType) {
+            case RichSubMessageType.CONTENT_ITEMS:
+                const itemsMetadata = submessage.contentItemsMetadata.itemsMetadata;
+                for (let n = 0; n < itemsMetadata.length; n++) {
+                    const reelItem = itemsMetadata[n].reelItem;
+                    sources.push({
+                        provider: 0,
+                        thumbnailCdnUrl: reelItem.thumbnailUrl,
+                        sourceProviderUrl: reelItem.videoUrl,
+                        sourceQuery: '',
+                        faviconCdnUrl: '',
+                        citationNumber: i + 1,
+                        sourceTitle: reelItem.title
+                    });
+                    mediaDetailsMetadataList.push({
+                        id: randomBytes(32).toString('hex'),
+                        previewMedia: {
+                            fileSha256: '',
+                            mediaKey: '',
+                            fileEncSha256: '',
+                            directPath: '',
+                            mediaKeyTimestamp: unixTimestampSeconds(),
+                            mimetype: 'image/jpeg'
+                        }
+                    });
+                }
+                break;
+            case RichSubMessageType.LATEX:
+                const expressions = submessage.latexMetadata.expressions;
+                for (let n = 0; n < expressions.length; n++) {
+                    const expression = expressions[n];
+                    mediaDetailsMetadataList.push({
+                        id: randomBytes(32).toString('hex'),
+                        previewMedia: {
+                            fileSha256: '',
+                            mediaKey: '',
+                            fileEncSha256: '',
+                            directPath: '',
+                            mediaKeyTimestamp: unixTimestampSeconds(),
+                            mimetype: 'image/jpeg'
+                        }
+                    });
+                }
+                break;
+        }
+    }
+    return { sources, mediaDetailsMetadataList };
+}
+export const prepareRichResponseMessage = (content) => {
+    const { code, contentText, expressions, footerText, headerText, items, language, richResponse, table, text, title } = content;
+    let submessages = [];
+    if (Array.isArray(richResponse)) {
+        submessages = richResponse.map((submessage) => {
+            if (submessage.text) {
+                return {
+                    messageType: RichSubMessageType.TEXT,
+                    messageText: submessage.text
+                };
+            }
+            else if (submessage.code) {
+                return {
+                    messageType: RichSubMessageType.CODE,
+                    codeMetadata: {
+                        codeLanguage: submessage.language,
+                        codeBlocks: submessage.code
+                    }
+                };
+            }
+            else if (submessage.expressions) {
+                return {
+                    messageType: RichSubMessageType.LATEX,
+                    latexMetadata: {
+                        text: submessage.text,
+                        expressions: submessage.expressions
+                    }
+                };
+            }
+            else if (submessage.items) {
+                return {
+                    messageType: RichSubMessageType.CONTENT_ITEMS,
+                    contentItemsMetadata: {
+                        itemsMetadata: submessage.items
+                    }
+                };
+            }
+            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) {
+            language ??= 'javascript';
+            submessages.push({
+                messageType: RichSubMessageType.CODE,
+                codeMetadata: {
+                    codeLanguage: language,
+                    codeBlocks: tokenizeCode(code, language)
+                }
+            });
+        }
+        else if (expressions) {
+            submessages.push({
+                messageType: RichSubMessageType.LATEX,
+                latexMetadata: {
+                    text,
+                    expressions
+                }
+            });
+        }
+        else if (items) {
+            submessages.push({
+                messageType: RichSubMessageType.CONTENT_ITEMS,
+                contentItemsMetadata: {
+                    itemsMetadata: items.map((item) => ({ reelItem: item })),
+                    contentType: proto.AIRichResponseContentItemsMetadata.ContentType.CAROUSEL
+                }
+            });
+        }
+        else if (table) {
+            const tableRows = table.map((items, index) => ({
+                isHeading: index == 0,
+                items
+            }));
+            submessages.push({
+                messageType: RichSubMessageType.TABLE,
+                tableMetadata: {
+                    title,
+                    rows: tableRows
+                }
+            });
+        }
+        if (footerText) {
+            submessages.push({
+                messageType: RichSubMessageType.TEXT,
+                messageText: footerText
+            });
+        }
+    }
+    const unified = toUnified(submessages);
+    const message = wrapToBotForwardedMessage({
+        submessages,
+        messageType: proto.AIRichResponseMessageType.AI_RICH_RESPONSE_TYPE_STANDARD,
+        unifiedResponse: {
+            data: textEncoder.encode(JSON.stringify(unified))
+        },
+        contextInfo: {
+            isForwarded: true,
+            forwardingScore: 1,
+            forwardedAiBotMessageInfo: { botJid: '867051314767696@bot' },
+            forwardOrigin: 4
+        }
+    });
+    // Lia@Note 17-04-26 --- TODO: Fill mediaDetailsMetadataList and sources field
+    const { sources, mediaDetailsMetadataList } = buildAdditionalBotMetadataContext(submessages);
+    const botMetadata = message.messageContextInfo.botMetadata;
+    if (sources.length > 0) {
+        botMetadata.richResponseSourcesMetadata = { sources };
+    }
+    if (mediaDetailsMetadataList.length > 0) {
+        botMetadata.unifiedResponseMutation = { mediaDetailsMetadataList };
+    }
+    return message;
+}
+// Lia@Note 17-04-26 --- signature and certificateChain for proofs[] field
+export const botMetadataSignature = () => {
+    const signature = new Uint8Array(64);
+    getRandomValues(signature);
+    return signature;
+}
+export const botMetadataCertificate = (length = 700) => {
+    const certificate = new Uint8Array(length);
+    certificate[0] = 48;
+    certificate[1] = 130;
+    getRandomValues(certificate.subarray(2));
+    return certificate;
+}
+export const wrapToBotForwardedMessage = (richResponseMessage) =>
+    ({
+        messageContextInfo: {
+            botMetadata: {
+                pluginMetadata: {},
+                // Lia@Note 09-04-26 --- TODO: Fill verificationMetadata field
+                verificationMetadata: {
+                    proofs: [
+                        {
+                            certificateChain: [
+                                botMetadataCertificate(684),
+                                botMetadataCertificate(892)
+                            ],
+                            version: 1,
+                            useCase: 1,
+                            signature: botMetadataSignature()
+                        }
+                    ]
+                },
+                botRenderingConfigMetadata: BOT_RENDERING_CONFIG_METADATA
+            }
+        },
+        botForwardedMessage: {
+            message: { richResponseMessage }
+        }
+    });