@vanzxy/baileys 1.6.2 → 1.6.4

package/lib/Utils/MessageBuilder.js

@@ -44,7 +44,7 @@
 
 'use strict';
 
-const MESSAGE_BUILDER_VERSION = '4.9.1';
+const MESSAGE_BUILDER_VERSION = '4.8';
 // Vanz@Fix 24-08-26: use the exported builder version everywhere; the old
 // verification helper referenced an undeclared `VERSION`, making every AIRich.build() fail.
 
@@ -52,6 +52,15 @@ const MESSAGE_BUILDER_VERSION = '4.9.1';
 import { generateWAMessageFromContent, prepareWAMessageMedia } from './messages.js';
 import { generateMessageIDV2 } from './generics.js';
 import { botMetadataSignature, botMetadataCertificate } from './rich-message-utils.js';
+// Vanz@Fix 27-08-26: Button.send() was hand-rolling its own <biz> node with
+// attrs: {} instead of reusing the canonical builder. Real client traffic
+// (and the auto-attached biz node in Socket/messages-send.js) always carries
+// actual_actors/host_storage/privacy_mode_ts on every <biz> node, including
+// the one wrapping a lone single_select's <list> node. Missing them made the
+// single_select wire payload diverge from what messages-send.js emits for
+// every other message type -- import the shared helper instead of duplicating
+// (and silently drifting from) its attrs.
+import { getBizBinaryNode } from '../WABinary/index.js';
 import crypto from 'crypto';
 import { PassThrough, Readable } from 'stream';
 // Vanz@Fix 15-08-26 --- sharp/fluent-ffmpeg were statically imported in the blurose source.
@@ -628,6 +637,46 @@ class BaseBuilder {
 	}
 }
 
+/** Tiny fluent helper for building a single quickReply button row (type 1). Standalone — not tied to Button/ButtonV2. */
+class RowBuilder {
+	constructor() {
+		this.buttons = [];
+	}
+
+	button(displayText, buttonId) {
+		this.buttons.push({ buttonId, buttonText: { displayText }, type: 1 });
+		return this;
+	}
+}
+
+/** Thin fluent wrapper around `Button` for building a single image+title+text+reply "card" in one chain. */
+class CardBuilder {
+	/** @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket. */
+	constructor(client) {
+		this._card = new Button(client);
+	}
+
+	image(url) {
+		this._card.setImage(url);
+		return this;
+	}
+
+	title(t) {
+		this._card.setTitle(t);
+		return this;
+	}
+
+	text(t) {
+		this._card.setBody(t);
+		return this;
+	}
+
+	button(displayText, id) {
+		this._card.addReply(displayText, id);
+		return this;
+	}
+}
+
 /**
  * Interactive (native-flow) message builder — header/body/footer + a mix of
  * buttons (quick_reply, cta_url, cta_call, single_select, ...). Sends via
@@ -704,19 +753,44 @@ class Button extends BaseBuilder {
 	// error-prone (dangling ids, ordering), so this accepts a plain nested tree instead —
 	// { component, ...props, children: [...] } / { component, ...props, child: {...} } — and
 	// flattens it into that array itself, auto-assigning ids.
-	#flattenBloks(tree, out, counter = { n: 0 }, id = 'root') {
+	//
+	// Vanz@Fix 26-08-26 (v2) --- Modal is a different shape: `trigger`/`content` point to a
+	// SIBLING node by id (e.g. the Button that opens it), not a fresh child — captured traffic
+	// confirmed `{ trigger: "<id of an existing Button node>", content: "<id of its body>" }`.
+	// Nesting it as a plain `child`/`children` would duplicate the trigger node. So:
+	//   - any prop whose value is `{ component: ..., ... }` is now auto-flattened as a nested
+	//     node too (not just `child`/`children`) — covers Modal.content directly.
+	//   - a node can carry a builder-only `ref: 'name'` tag; another prop can then point back
+	//     at it with `{ $ref: 'name' }`, resolved to that node's real id after the whole tree
+	//     is walked (order-independent). `ref` itself is stripped and never reaches the wire.
+	#flattenBloks(tree, out, ctx = { n: 0, refs: new Map(), pending: [] }, id = 'root') {
 		if (!tree || typeof tree !== 'object') throw new TypeError('setBloksWidget: every node needs a "component" type');
-		const { component, children, child, ...props } = tree;
+		const { component, children, child, ref, ...rest } = tree;
 		if (typeof component !== 'string' || !component) throw new TypeError('setBloksWidget: every node needs a "component" type');
 
-		const node = { id, component, ...props };
+		const isTreeNode = (v) => v && typeof v === 'object' && !Array.isArray(v) && typeof v.component === 'string';
+		const isRefMarker = (v) => v && typeof v === 'object' && !Array.isArray(v) && typeof v.$ref === 'string' && Object.keys(v).length === 1;
+
+		const node = { id, component };
+		for (const [k, v] of Object.entries(rest)) {
+			if (isRefMarker(v)) {
+				node[k] = null; // resolved once the full tree (and its `ref` tags) has been walked
+				ctx.pending.push({ node, key: k, refName: v.$ref });
+			} else if (isTreeNode(v)) {
+				node[k] = this.#flattenBloks(v, out, ctx, `n${ctx.n++}`);
+			} else {
+				node[k] = v;
+			}
+		}
 
 		if (Array.isArray(children)) {
-			node.children = children.map((c) => this.#flattenBloks(c, out, counter, `n${counter.n++}`));
+			node.children = children.map((c) => this.#flattenBloks(c, out, ctx, `n${ctx.n++}`));
 		} else if (child) {
-			node.child = this.#flattenBloks(child, out, counter, `n${counter.n++}`);
+			node.child = this.#flattenBloks(child, out, ctx, `n${ctx.n++}`);
 		}
 
+		if (ref) ctx.refs.set(ref, id);
+
 		out.push(node);
 		return id;
 	}
@@ -725,12 +799,23 @@ class Button extends BaseBuilder {
 	 * Set a Bloks/A2UI native widget (`bloksWidget`, `type: "im_a2ui"`) — a real interactive
 	 * screen (images, video, checkboxes, text fields, buttons that fire an `action`), not a
 	 * static card. Pass a nested tree; ids are assigned automatically.
+	 *
+	 * For components that reference a SIBLING node instead of nesting one — currently just
+	 * `Modal.trigger` — tag the source node with `ref: 'someName'` and point at it with
+	 * `{ $ref: 'someName' }`. Everything else (including `Modal.content`) can just be nested
+	 * directly, no special key needed.
 	 * @param {Record<string, any>} tree Root node, e.g. `{ component: 'Column', children: [...] }`.
 	 * @param {{uuid?: string, catalogId?: string, surfaceId?: string, version?: string}} [options]
 	 */
 	setBloksWidget(tree, { uuid = crypto.randomUUID(), catalogId = 'https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json', surfaceId, version = 'v0.9' } = {}) {
 		const components = [];
-		this.#flattenBloks(tree, components);
+		const ctx = { n: 0, refs: new Map(), pending: [] };
+		this.#flattenBloks(tree, components, ctx);
+		for (const { node, key, refName } of ctx.pending) {
+			const resolved = ctx.refs.get(refName);
+			if (!resolved) throw new Error(`setBloksWidget: ref "${refName}" (used on "${key}") was never declared with ref: "${refName}" on any node`);
+			node[key] = resolved;
+		}
 
 		this._bloksWidget = {
 			uuid,
@@ -1165,13 +1250,23 @@ class Button extends BaseBuilder {
 		return this;
 	}
 
-	/** WhatsApp Flows `flow_action` shortcut. Requires a real registered Flow. */
+	/** WhatsApp Flows shortcut. Requires a real registered Flow. */
 	addFlow(flow = {}, display_text = '') {
 		if (typeof flow !== 'object' || flow === null || Array.isArray(flow) || !flow.id) throw new TypeError('addFlow(flow) requires a plain object with flow.id');
 		this._buttons.push({
-			name: 'flow_action',
+			// Vanz@Fix 27-08-26: the button name was 'flow_action', which is actually
+			// the *field name* inside buttonParamsJson (flow_action: 'navigate' | 'data_exchange'),
+			// not a native_flow name WhatsApp recognises. The real native_flow name for
+			// launching a registered WhatsApp Flow is 'flow' -- client silently ignored
+			// the button because <native_flow name='flow_action'> isn't a thing it renders.
+			name: 'flow',
 			buttonParamsJson: JSON.stringify({
 				flow_message_version: flow.version || '3',
+				// flow_token: unique per-send session token WhatsApp Flows requires to
+				// correlate a flow_action data-exchange callback with this specific
+				// message. Was missing entirely -- without it the client can accept the
+				// message but has nothing to key the flow session on.
+				flow_token: flow.token || generateMessageIDV2(),
 				flow_id: flow.id,
 				flow_cta: display_text || flow.cta || 'Continue',
 				flow_action: flow.action || 'navigate',
@@ -1369,50 +1464,29 @@ class Button extends BaseBuilder {
 		);
 	}
 
-	// Vanz@Add 22-08-26 (v4.7) --- picks the native_flow node variant for the first
-	// button's name, per Button.#SPECIAL_FLOW. Falls back to the generic mixed node
-	// (previous unconditional behaviour) for anything not in that map.
-	#buildNativeFlowNode() {
-		const special = Button.#SPECIAL_FLOW[this._buttons[0]?.name];
-		return special ? { tag: 'native_flow', attrs: special } : { tag: 'native_flow', attrs: { v: '9', name: 'mixed' } };
-	}
-
 	/** Build and send this interactive message. @param {string} jid Destination chat/group jid. */
 	async send(jid, { ...options } = {}) {
 		const msg = await this.build(jid, options);
 
-		const bizContent = this.#isLoneSingleSelect()
-			? [{ tag: 'list', attrs: { v: '2', type: 'product_list' } }]
-			: [
-					...(this._buttons.length > 0
-						? [
-								{
-									tag: 'interactive',
-									attrs: { type: 'native_flow', v: '1' },
-									content: [this.#buildNativeFlowNode()],
-								},
-						  ]
-						: []),
-					...(this._bloksWidget
-						? [
-								{
-									tag: 'quality_control',
-									attrs: { decision_id: crypto.randomUUID().replace(/-/g, ''), source_type: 'third_party' },
-									content: [{ tag: 'decision_source', attrs: { value: 'df' } }],
-								},
-						  ]
-						: []),
-			  ];
+		// Vanz@Fix 27-08-26: delegate the <biz> node to the shared getBizBinaryNode()
+		// helper instead of hand-rolling one here. It already:
+		//  - stamps actual_actors/host_storage/privacy_mode_ts (previously missing,
+		//    the likely cause of single_select's wire being flagged for validation)
+		//  - picks the correct wrapper per button name (FLOWS_MAP dedicated node,
+		//    ORDER_RESPONSE_ALIAS native_flow_name, mixed native_flow, or the
+		//    <list v='2' type='product_list'> node for a lone single_select via
+		//    message.listMessage) using the exact same table messages-send.js uses
+		//    for every non-Button send path, so Button.send() can't silently drift
+		//    out of sync with it.
+		// Button.#SPECIAL_FLOW is kept only as documentation for addFlow()/etc.
+		// JSDoc now (see below); getBizBinaryNode()'s own ORDER_RESPONSE_ALIAS /
+		// FLOWS_MAP tables are what actually pick the wire node -- keep those two
+		// tables in sync if a new special-cased button name is ever added.
+		const bizNode = getBizBinaryNode(msg.message);
 
 		await this.#client.relayMessage(msg.key.remoteJid, msg.message, {
 			messageId: msg.key.id,
-			additionalNodes: [
-				{
-					tag: 'biz',
-					attrs: {},
-					content: bizContent,
-				},
-			],
+			additionalNodes: [bizNode],
 			...options,
 		});
 		return msg;
@@ -1478,6 +1552,24 @@ class ButtonV2 extends BaseBuilder {
 		return this;
 	}
 
+	/** Alias for addButton() — shorthand parity with RowBuilder#button(). */
+	button(displayText, buttonId) {
+		return this.addButton(displayText, buttonId);
+	}
+
+	/**
+	 * Vanz@Add 29-08-26 --- Fluent row helper ported from the RowBuilder class (already
+	 * present but previously unwired into ButtonV2). Lets callers group buttons via a
+	 * callback instead of chaining addButton() calls one at a time.
+	 * @param {(row: RowBuilder) => void} cb
+	 */
+	row(cb) {
+		const r = new RowBuilder();
+		cb(r);
+		r.buttons.forEach((b) => this._buttons.push(b));
+		return this;
+	}
+
 	// Vanz@Fix 22-08-26 (v4.7) --- _thumbnail was computed unconditionally (fetch + resize) even
 	// when setMedia() is used, in which case the location-fallback header (the only place
 	// _thumbnail is used) never runs at all — wasted network/CPU work on every build() call.
@@ -1542,6 +1634,193 @@ class ButtonV2 extends BaseBuilder {
 	}
 }
 
+/**
+ * Legacy `templateMessage` / `hydratedFourRowTemplate` builder — WA's Generation-1
+ * button protocol (predates the nativeFlow format that Button/ButtonV2 use).
+ * Capped at 3 buttons (quickReply/url/call only), no interactive list/flow support.
+ * Ported from MessageBuilderV4.7.
+ */
+class ButtonV3 extends BaseBuilder {
+	#client;
+
+	/** @param {import('../../WAProto/index.js').WASocket} client Active Baileys socket. */
+	constructor(client) {
+		super();
+		if (!client) {
+			throw new Error('Socket is required');
+		}
+
+		this.#client = client;
+		this._data;
+		this._mediaHeaderType = null;
+		this._buttons = [];
+	}
+
+	/** Load an existing templateMessage (e.g. from a fetched/quoted message) for editing. */
+	loadFrom(msg) {
+		if (!msg) throw new Error('templateMessage needed');
+		if (!msg.templateMessage) throw new Error('templateMessage not found');
+
+		const { templateMessage, ...extraPayload } = msg;
+		const hft = templateMessage.hydratedFourRowTemplate || {};
+
+		this._title = hft.hydratedTitleText || '';
+		this._body = hft.hydratedContentText || '';
+		this._footer = hft.hydratedFooterText || '';
+		this._contextInfo = templateMessage.contextInfo || {};
+		this._extraPayload = extraPayload;
+
+		this._buttons = Array.isArray(hft.hydratedButtons)
+			? hft.hydratedButtons.map((button) => ({ ...button }))
+			: [];
+
+		if (hft.imageMessage) {
+			this._data = { imageMessage: hft.imageMessage };
+			this._mediaHeaderType = 'imageMessage';
+		} else if (hft.videoMessage) {
+			this._data = { videoMessage: hft.videoMessage };
+			this._mediaHeaderType = 'videoMessage';
+		} else if (hft.documentMessage) {
+			this._data = { documentMessage: hft.documentMessage };
+			this._mediaHeaderType = 'documentMessage';
+		} else if (hft.locationMessage) {
+			this._data = { locationMessage: hft.locationMessage };
+			this._mediaHeaderType = 'locationMessage';
+		} else {
+			this._data = undefined;
+			this._mediaHeaderType = null;
+		}
+
+		return this;
+	}
+
+	setImage(path, options = {}) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._data = Buffer.isBuffer(path)
+			? { image: path, ...options }
+			: { image: { url: path }, ...options };
+		this._mediaHeaderType = 'imageMessage';
+		return this;
+	}
+
+	setVideo(path, options = {}) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._data = Buffer.isBuffer(path)
+			? { video: path, ...options }
+			: { video: { url: path }, ...options };
+		this._mediaHeaderType = 'videoMessage';
+		return this;
+	}
+
+	setDocument(path, options = {}) {
+		if (!path) throw new Error('Url or buffer needed');
+		this._data = Buffer.isBuffer(path)
+			? { document: path, ...options }
+			: { document: { url: path }, ...options };
+		this._mediaHeaderType = 'documentMessage';
+		return this;
+	}
+
+	setMedia(obj) {
+		if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
+			throw new TypeError('Media must be a plain object');
+		}
+		this._data = obj;
+		this._mediaHeaderType = null; // caller is expected to pass an already-resolved shape
+		return this;
+	}
+
+	clearButtons() {
+		this._buttons = [];
+		return this;
+	}
+
+	addButton(hydratedButton) {
+		if (this._buttons.length >= 3) {
+			throw new Error('ButtonV3 (TemplateMessage) supports a maximum of 3 buttons');
+		}
+		this._buttons.push({ index: this._buttons.length + 1, ...hydratedButton });
+		return this;
+	}
+
+	addReply(display_text = '', id = '') {
+		return this.addButton({
+			quickReplyButton: { displayText: display_text, id },
+		});
+	}
+
+	addUrl(display_text = '', url = '', options = {}) {
+		return this.addButton({
+			urlButton: { displayText: display_text, url, ...options },
+		});
+	}
+
+	addCall(display_text = '', phone_number = '') {
+		return this.addButton({
+			callButton: { displayText: display_text, phoneNumber: phone_number },
+		});
+	}
+
+	async toTemplate() {
+		let mediaFields = {};
+
+		if (this._data) {
+			const alreadyResolved =
+				this._data.imageMessage || this._data.videoMessage ||
+				this._data.documentMessage || this._data.locationMessage;
+
+			mediaFields = alreadyResolved
+				? this._data
+				: await prepareWAMessageMedia(this._data, {
+						upload: this.#client.waUploadToServer,
+					}).catch((e) => {
+						if (String(e).includes('Invalid media type')) return this._data;
+						throw e;
+					});
+		} else if (this._title) {
+			mediaFields = { hydratedTitleText: this._title };
+		}
+
+		return {
+			hydratedContentText: this._body,
+			hydratedFooterText: this._footer,
+			hydratedButtons: this._buttons,
+			...mediaFields,
+		};
+	}
+
+	async build(jid, { messageId, ...options } = {}) {
+		const hydratedFourRowTemplate = await this.toTemplate();
+
+		return generateWAMessageFromContent(
+			jid,
+			{
+				...this._extraPayload,
+				templateMessage: {
+					hydratedFourRowTemplate,
+					contextInfo: this._contextInfo,
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options },
+		);
+	}
+
+	async send(jid, { messageId, additionalNodes = [], ...options } = {}) {
+		if (this._buttons.length < 1)
+			throw new Error('ButtonV3 requires at least one button');
+		const msg = await this.build(jid, { messageId, ...options });
+
+		// TemplateMessage predates the nativeFlow protocol and does not need the
+		// "biz"/"native_flow" additionalNodes hack that Button/ButtonV2 use.
+		await this.#client.relayMessage(msg.key.remoteJid, msg.message, {
+			messageId: msg.key.id,
+			additionalNodes,
+			...options,
+		});
+		return msg;
+	}
+}
+
 /** Carousel of interactive cards (each with its own header media + optional buttons), scrollable horizontally in-chat. */
 class Carousel extends BaseBuilder {
 	#client;
@@ -4018,6 +4297,9 @@ class AIRich extends BaseBuilder {
 	}
 }
 
+/** Thin no-op subclass of `AIRich` — kept for drop-in compatibility with code ported from ourin-baileys that references `ORich` by name. */
+class ORich extends AIRich {}
+
 // Vanz@Alias --- AIRich diekspos ulang pake nama sendiri. Implementasi & referensi
 // internal (AIRich.newLayout/tokenizer/toTableMetadata) TETAP pake nama class asli
 // biar nggak perlu rewrite ratusan pemanggilan; ini cuma nge-alias binding exportnya.
@@ -4027,9 +4309,13 @@ export {
 	MESSAGE_BUILDER_VERSION,
 	Button,
 	ButtonV2,
+	ButtonV3,
+	RowBuilder,
+	CardBuilder,
 	Carousel,
 	Poll,
 	AIRich,
+	ORich,
 	AIRich as AIVanzxy,
 	AIRich as LeafRich,
 	AIRich as VanzxyAI,

package/lib/Utils/MessageBuilder_d.ts

@@ -104,9 +104,27 @@ export class Button extends BaseBuilder {
 	static menu?: (client: any, options?: Record<string, any>) => Button;
 }
 
+export class RowBuilder {
+	constructor();
+	buttons: Record<string, any>[];
+	button(displayText: string, buttonId?: string): this;
+}
+
+export class CardBuilder {
+	constructor(client: any);
+	title(text: string): this;
+	text(text: string): this;
+	image(path: string | Buffer, options?: Record<string, any>): this;
+	button(displayText: string, buttonId?: string): this;
+}
+
 export class ButtonV2 extends BaseBuilder {
 	constructor(client: any);
 	addButton(displayText: string, buttonId?: string): this;
+	/** Alias for addButton(). */
+	button(displayText: string, buttonId?: string): this;
+	/** Fluent row helper — group buttons via a callback instead of chaining addButton(). */
+	row(cb: (row: RowBuilder) => void): this;
 	addRawButton(obj: Record<string, any>): this;
 	setThumbnail(path: string | Buffer): this;
 	setMedia(obj: Record<string, any>): this;
@@ -115,6 +133,30 @@ export class ButtonV2 extends BaseBuilder {
 	send(jid: string, options?: Record<string, any> & { viewOnce?: boolean }): Promise<any>;
 }
 
+/**
+ * Legacy `templateMessage` / `hydratedFourRowTemplate` builder — WA's Generation-1
+ * button protocol (predates the nativeFlow format Button/ButtonV2 use). Capped at
+ * 3 buttons (quickReply/url/call only), no interactive list/flow support.
+ */
+export class ButtonV3 extends BaseBuilder {
+	constructor(client: any);
+	/** Load an existing templateMessage (e.g. from a fetched/quoted message) for editing. */
+	loadFrom(msg: Record<string, any>): this;
+	setImage(path: string | Buffer, options?: Record<string, any>): this;
+	setVideo(path: string | Buffer, options?: Record<string, any>): this;
+	setDocument(path: string | Buffer, options?: Record<string, any>): this;
+	setMedia(obj: Record<string, any>): this;
+	clearButtons(): this;
+	/** Max 3 buttons — throws past the limit. */
+	addButton(hydratedButton: Record<string, any>): this;
+	addReply(display_text?: string, id?: string): this;
+	addUrl(display_text?: string, url?: string, options?: Record<string, any>): this;
+	addCall(display_text?: string, phone_number?: string): this;
+	toTemplate(): Promise<Record<string, any>>;
+	build(jid: string, options?: Record<string, any>): Promise<Record<string, any>>;
+	send(jid: string, options?: Record<string, any>): Promise<any>;
+}
+
 export class Carousel extends BaseBuilder {
 	constructor(client: any);
 	/** WhatsApp caps carousels at this many cards (10); addCard() throws past it. */
@@ -224,6 +266,9 @@ export class AIRich extends BaseBuilder {
 // MessageBuilder.js). All four are structurally identical to AIRich.
 export { AIRich as AIVanzxy, AIRich as LeafRich, AIRich as VanzxyAI, AIRich as VanzxyRich };
 
+/** `class ORich extends AIRich {}` — plain re-export alias, no additional members. */
+export class ORich extends AIRich {}
+
 export class Toolkit {
 	static extractIE(text: string, options?: AddTextOptions): Record<string, any>;
 	static getMp4Duration(buffer: Buffer, options?: { silent?: boolean }): Promise<number>;