@vanzxysenpai/baileys 0.0.0-stage → 0.0.2

package/lib/WABinary/generic-utils.js

@@ -0,0 +1,285 @@
+import { Boom } from '@hapi/boom';
+import { randomBytes } from 'crypto';
+import { proto } from '../../WAProto/index.js';
+// some extra useful utilities
+const indexCache = new WeakMap();
+export const getBinaryNodeChildren = (node, childTag) => {
+    if (!node || !Array.isArray(node.content))
+        return [];
+    let index = indexCache.get(node);
+    // Build the index once per node
+    if (!index) {
+        index = new Map();
+        for (const child of node.content) {
+            let arr = index.get(child.tag);
+            if (!arr)
+                index.set(child.tag, (arr = []));
+            arr.push(child);
+        }
+        indexCache.set(node, index);
+    }
+    // Return first matching child
+    return index.get(childTag) || [];
+};
+export const getBinaryNodeChild = (node, childTag) => {
+    return getBinaryNodeChildren(node, childTag)[0];
+};
+export const getAllBinaryNodeChildren = ({ content }) => {
+    if (Array.isArray(content)) {
+        return content;
+    }
+    return [];
+};
+export const getBinaryNodeChildBuffer = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return child;
+    }
+};
+export const getBinaryNodeChildString = (node, childTag) => {
+    const child = getBinaryNodeChild(node, childTag)?.content;
+    if (Buffer.isBuffer(child) || child instanceof Uint8Array) {
+        return Buffer.from(child).toString('utf-8');
+    }
+    else if (typeof child === 'string') {
+        return child;
+    }
+};
+// Vanz@Port (v2.1.6) --- from @nexustechpro/baileys: true when additionalNodes already carries a button/biz node.
+export const getBinaryFilteredButtons = (nodeContent) => {
+    if (!Array.isArray(nodeContent)) return false;
+    return nodeContent.some(a => ['native_flow'].includes(a?.content?.[0]?.content?.[0]?.tag) ||
+        ['interactive', 'buttons', 'list'].includes(a?.content?.[0]?.tag) ||
+        ['hsm', 'biz'].includes(a?.tag));
+};
+// Vanz@Port (2.0.3) --- from @yemo-dev/yebail: getBinaryFilteredButtons plus the biz-bot case (<bot biz_bot='1'>).
+export const getBinaryNodeFilter = (nodeContent) => {
+    if (!Array.isArray(nodeContent)) return false;
+    return getBinaryFilteredButtons(nodeContent) ||
+        nodeContent.some(a => a?.tag === 'bot' && a?.attrs?.biz_bot === '1');
+};
+export const getBinaryNodeChildUInt = (node, childTag, length) => {
+    const buff = getBinaryNodeChildBuffer(node, childTag);
+    if (buff) {
+        return bufferToUInt(buff, length);
+    }
+};
+export const assertNodeErrorFree = (node) => {
+    const errNode = getBinaryNodeChild(node, 'error');
+    if (errNode) {
+        throw new Boom(errNode.attrs.text || 'Unknown error', { data: +errNode.attrs.code });
+    }
+};
+export const reduceBinaryNodeToDictionary = (node, tag) => {
+    const nodes = getBinaryNodeChildren(node, tag);
+    const dict = nodes.reduce((dict, { attrs }) => {
+        if (typeof attrs.name === 'string') {
+            dict[attrs.name] = attrs.value || attrs.config_value;
+        }
+        else {
+            dict[attrs.config_code] = attrs.value || attrs.config_value;
+        }
+        return dict;
+    }, {});
+    return dict;
+};
+export const getBinaryNodeMessages = ({ content }) => {
+    const msgs = [];
+    if (Array.isArray(content)) {
+        for (const item of content) {
+            if (item.tag === 'message') {
+                msgs.push(proto.WebMessageInfo.decode(item.content).toJSON());
+            }
+        }
+    }
+    return msgs;
+};
+function bufferToUInt(e, t) {
+    let a = 0;
+    for (let i = 0; i < t; i++) {
+        a = 256 * a + e[i];
+    }
+    return a;
+}
+const tabs = (n) => '\t'.repeat(n);
+export function binaryNodeToString(node, i = 0) {
+    if (!node) {
+        return node;
+    }
+    if (typeof node === 'string') {
+        return tabs(i) + node;
+    }
+    if (node instanceof Uint8Array) {
+        return tabs(i) + Buffer.from(node).toString('hex');
+    }
+    if (Array.isArray(node)) {
+        return node.map(x => tabs(i + 1) + binaryNodeToString(x, i + 1)).join('\n');
+    }
+    const children = binaryNodeToString(node.content, i + 1);
+    const tag = `<${node.tag} ${Object.entries(node.attrs || {})
+        .filter(([, v]) => v !== undefined)
+        .map(([k, v]) => `${k}='${v}'`)
+        .join(' ')}`;
+    const content = children ? `>\n${children}\n${tabs(i)}</${node.tag}>` : '/>';
+    return tag + content;
+}
+/**
+ * Lia@Changes 30-01-26
+ * ---
+ * Produce the binary node (WABinary-like JSON shape) required for the specific
+ * interactive button / list type.
+ * compatible with observed official client traffic.
+ *
+ * NOTE: Returning different "v" (version) and "name" values influences how
+ * WhatsApp renders & validates flows. The constants here are empirically derived.
+ *
+ * @param {object} message Normalized message content (after Baileys normalization).
+ * @returns {object} A node with shape { tag, attrs, [content] } to inject into additionalNodes.
+ */
+const FLOWS_MAP = {
+    // Original flow types
+    mpm: true,
+    catalog_message: true,
+    cta_catalog: true,
+    send_location: true,
+    call_permission_request: true,
+    wa_payment_transaction_details: true,
+    automated_greeting_message_view_catalog: true,
+    // Vanzxy extended button types
+    card_message: true,
+    order_status: true,
+    track_order: true,
+    reorder: true,
+    cancel_order: true,
+    clear_chat: true,
+    navigateToScreen: true,
+    payment_status: true,
+    payment_method: true,
+    flow_action: true,
+    voice_call: true,
+    video_call_button: true,
+    // Confirmed not a bug (see lib/Utils/messages.js "Vanzxy@Fix (bug 12)"): otp_button/
+    // authentication_button are WhatsApp Business Platform (Cloud API) authentication-template
+    // buttons gated behind Meta template approval — no MD-protocol client, this fork included,
+    // can ever produce a button with these names, so no builder method exists for them and
+    // these two entries can never actually route anything. Left in place only as a documented
+    // no-op in case a caller ever hand-constructs a raw button object with one of these names;
+    // harmless either way since nothing upstream ever creates one.
+    otp_button: true,
+    authentication_button: true,
+    cta_reminder: true,
+    cta_cancel_reminder: true,
+    flow: true,
+    payment_key_info: '1',
+    booking_confirmation: '1',
+};
+const DECISION_SOURCE_CONTENT = [
+    {
+        tag: 'decision_source',
+        attrs: { value: 'df' }
+    }
+];
+const LIST_TYPE_CONTENT = {
+    tag: 'list',
+    attrs: { v: '2', type: 'product_list' }
+};
+const NATIVE_FLOW_ATTRIBUTE = { type: 'native_flow', v: '1' };
+const MIXED_NATIVE_FLOW = {
+    tag: 'interactive',
+    attrs: NATIVE_FLOW_ATTRIBUTE,
+    content: [
+        {
+            tag: 'native_flow',
+            attrs: { v: '9', name: 'mixed' }
+        }
+    ]
+};
+export const getBizBinaryNode = (message) => {
+    const flowMsg = message.interactiveMessage?.nativeFlowMessage;
+    const carouselMsg = message.interactiveMessage?.carouselMessage;
+    const buttonsMsg = message.buttonsMessage;
+    const firstButtonName =
+        flowMsg?.buttons?.[0]?.name ??
+        carouselMsg?.cards?.[0]?.nativeFlowMessage?.buttons?.[0]?.name ??
+        buttonsMsg?.buttons?.[0]?.nativeFlowInfo?.name;
+    const qualityContent = {
+        tag: 'quality_control',
+        attrs: {
+            decision_id: randomBytes(20).toString('hex'),
+            source_type: 'third_party'
+        },
+        content: DECISION_SOURCE_CONTENT
+    };
+    const bizAttributes = {
+        actual_actors: '2',
+        host_storage: '2',
+        privacy_mode_ts: `${Date.now() / 1_000 | 0}`
+    };
+    const ORDER_RESPONSE_ALIAS = {
+        review_and_pay: 'order_details',
+        review_order: 'order_status',
+        payment_info: 'payment_info',
+        payment_status: 'payment_status',
+        payment_method: 'payment_method',
+        order_details: 'order_details',
+        order_status: 'order_status',
+        track_order: 'track_order',
+        reorder: 'reorder',
+        cancel_order: 'cancel_order',
+        catalog_message: 'catalog_message',
+    };
+    if (firstButtonName && ORDER_RESPONSE_ALIAS[firstButtonName]) {
+        bizAttributes.native_flow_name = ORDER_RESPONSE_ALIAS[firstButtonName];
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [qualityContent]
+        };
+    }
+    if (firstButtonName && FLOWS_MAP[firstButtonName]) {
+        const flowVersion = typeof FLOWS_MAP[firstButtonName] === 'string' ? FLOWS_MAP[firstButtonName] : '2';
+        const flowAttrs = firstButtonName === 'payment_key_info' ? { name: firstButtonName } : { v: flowVersion, name: firstButtonName };
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                {
+                    tag: 'interactive',
+                    attrs: NATIVE_FLOW_ATTRIBUTE,
+                    content: [
+                        {
+                            tag: 'native_flow',
+                            attrs: flowAttrs
+                        }
+                    ]
+                },
+                qualityContent
+            ]
+        };
+    }
+    if (flowMsg || carouselMsg || message.buttonsMessage || message.templateMessage) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                MIXED_NATIVE_FLOW,
+                qualityContent
+            ]
+        };
+    }
+    if (message.listMessage) {
+        return {
+            tag: 'biz',
+            attrs: bizAttributes,
+            content: [
+                LIST_TYPE_CONTENT,
+                qualityContent
+            ]
+        };
+    }
+    return {
+        tag: 'biz',
+        attrs: bizAttributes,
+        content: [qualityContent]
+    };
+};

package/lib/WABinary/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./encode.js";
+export * from "./decode.js";
+export * from "./generic-utils.js";
+export * from "./jid-utils.js";
+export * from "./types.js";

package/lib/WABinary/index.js

@@ -0,0 +1,5 @@
+export * from './encode.js';
+export * from './decode.js';
+export * from './generic-utils.js';
+export * from './jid-utils.js';
+export * from './types.js';

package/lib/WABinary/jid-utils.d.ts

@@ -0,0 +1,32 @@
+export const S_WHATSAPP_NET: "@s.whatsapp.net";
+export const OFFICIAL_BIZ_JID: "16505361212@c.us";
+export const SERVER_JID: "server@c.us";
+export const PSA_WID: "0@c.us";
+export const STORIES_JID: "status@broadcast";
+export const LOCATION_BROADCAST_JID: "location@broadcast";
+export const META_AI_JID: "13135550002@c.us";
+export const WAJIDDomains: any;
+export function getServerFromDomainType(initialServer: any, domainType: any): any;
+export function jidEncode(user: any, server: any, device: any, agent: any): string;
+export function jidDecode(jid: any): {
+    server: any;
+    user: any;
+    domainType: any;
+    device: number;
+};
+export function areJidsSameUser(jid1: any, jid2: any): boolean;
+export function isJidMetaAI(jid: any): any;
+export function isJidMetaAi(jid: any): any;
+export function isPnUser(jid: any): any;
+export function isJidUser(jid: any): any;
+export function isLidUser(jid: any): any;
+export function isJidBroadcast(jid: any): any;
+export function isJidGroup(jid: any): any;
+export function isJidStatusBroadcast(jid: any): boolean;
+export function isJidLocationBroadcast(jid: any): boolean;
+export function isJidNewsletter(jid: any): any;
+export function isHostedPnUser(jid: any): any;
+export function isHostedLidUser(jid: any): any;
+export function isJidBot(jid: any): any;
+export function jidNormalizedUser(jid: any): string;
+export function transferDevice(fromJid: any, toJid: any): string;

package/lib/WABinary/jid-utils.js

@@ -0,0 +1,102 @@
+export const S_WHATSAPP_NET = '@s.whatsapp.net';
+export const OFFICIAL_BIZ_JID = '16505361212@c.us';
+export const SERVER_JID = 'server@c.us';
+export const PSA_WID = '0@c.us';
+export const STORIES_JID = 'status@broadcast';
+// Vanz@Port (2.0.3) --- from @rexxhayanasi/elaina-baileys: live-location broadcast pseudo-JID.
+export const LOCATION_BROADCAST_JID = 'location@broadcast';
+export const META_AI_JID = '13135550002@c.us';
+export var WAJIDDomains;
+(function (WAJIDDomains) {
+    WAJIDDomains[WAJIDDomains["WHATSAPP"] = 0] = "WHATSAPP";
+    WAJIDDomains[WAJIDDomains["LID"] = 1] = "LID";
+    WAJIDDomains[WAJIDDomains["HOSTED"] = 128] = "HOSTED";
+    WAJIDDomains[WAJIDDomains["HOSTED_LID"] = 129] = "HOSTED_LID";
+})(WAJIDDomains || (WAJIDDomains = {}));
+export const getServerFromDomainType = (initialServer, domainType) => {
+    switch (domainType) {
+        case WAJIDDomains.LID:
+            return 'lid';
+        case WAJIDDomains.HOSTED:
+            return 'hosted';
+        case WAJIDDomains.HOSTED_LID:
+            return 'hosted.lid';
+        case WAJIDDomains.WHATSAPP:
+        default:
+            return initialServer;
+    }
+};
+export const jidEncode = (user, server, device, agent) => {
+    return `${user || ''}${!!agent ? `_${agent}` : ''}${!!device ? `:${device}` : ''}@${server || 'lid'}`;
+};
+export const jidDecode = (jid) => {
+    // todo: investigate how to implement hosted ids in this case
+    const sepIdx = typeof jid === 'string' ? jid.indexOf('@') : -1;
+    if (sepIdx < 0) {
+        return undefined;
+    }
+    const server = jid.slice(sepIdx + 1);
+    const userCombined = jid.slice(0, sepIdx);
+    const [userAgent, device] = userCombined.split(':');
+    const [user, agent] = userAgent.split('_');
+    let domainType = WAJIDDomains.WHATSAPP;
+    if (server === 'lid') {
+        domainType = WAJIDDomains.LID;
+    }
+    else if (server === 'hosted') {
+        domainType = WAJIDDomains.HOSTED;
+    }
+    else if (server === 'hosted.lid') {
+        domainType = WAJIDDomains.HOSTED_LID;
+    }
+    else if (agent) {
+        domainType = parseInt(agent);
+    }
+    return {
+        server: server,
+        user: user,
+        domainType,
+        device: device ? +device : undefined
+    };
+};
+/** is the jid a user */
+export const areJidsSameUser = (jid1, jid2) => jidDecode(jid1)?.user === jidDecode(jid2)?.user;
+/** is the jid Meta AI */
+export const isJidMetaAI = (jid) => jid?.endsWith('@bot');
+// Vanz@Port (2.0.3) --- alias with the casing used by several forks (isJidMetaAi).
+export const isJidMetaAi = isJidMetaAI;
+/** is the jid a PN user */
+export const isPnUser = (jid) => jid?.endsWith('@s.whatsapp.net');
+// Vanz@Port (2.0.3) --- legacy Baileys 6.x name, kept so old bot plugins keep working.
+export const isJidUser = isPnUser;
+/** is the jid a LID */
+export const isLidUser = (jid) => jid?.endsWith('@lid');
+/** is the jid a broadcast */
+export const isJidBroadcast = (jid) => jid?.endsWith('@broadcast');
+/** is the jid a group */
+export const isJidGroup = (jid) => jid?.endsWith('@g.us');
+/** is the jid the status broadcast */
+export const isJidStatusBroadcast = (jid) => jid === 'status@broadcast';
+export const isJidLocationBroadcast = (jid) => jid === LOCATION_BROADCAST_JID;
+/** is the jid a newsletter */
+export const isJidNewsletter = (jid) => jid?.endsWith('@newsletter');
+/** is the jid a hosted PN */
+export const isHostedPnUser = (jid) => jid?.endsWith('@hosted');
+/** is the jid a hosted LID */
+export const isHostedLidUser = (jid) => jid?.endsWith('@hosted.lid');
+const botRegexp = /^1313555\d{4}$|^131655500\d{2}$/;
+export const isJidBot = (jid) => jid && botRegexp.test(jid.split('@')[0]) && jid.endsWith('@c.us');
+export const jidNormalizedUser = (jid) => {
+    const result = jidDecode(jid);
+    if (!result) {
+        return '';
+    }
+    const { user, server } = result;
+    return jidEncode(user, server === 'c.us' ? 's.whatsapp.net' : server);
+};
+export const transferDevice = (fromJid, toJid) => {
+    const fromDecoded = jidDecode(fromJid);
+    const deviceId = fromDecoded?.device || 0;
+    const { server, user } = jidDecode(toJid);
+    return jidEncode(user, server, deviceId);
+};

package/lib/WABinary/types.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/WABinary/types.js

@@ -0,0 +1 @@
+import * as constants from './constants.js';

package/lib/WAM/BinaryInfo.d.ts

@@ -0,0 +1,7 @@
+export class BinaryInfo {
+    constructor(options?: {});
+    protocolVersion: number;
+    sequence: number;
+    events: any[];
+    buffer: any[];
+}

package/lib/WAM/BinaryInfo.js

@@ -0,0 +1,9 @@
+export class BinaryInfo {
+    constructor(options = {}) {
+        this.protocolVersion = 5;
+        this.sequence = 0;
+        this.events = [];
+        this.buffer = [];
+        Object.assign(this, options);
+    }
+}