@vanzxy/baileys 1.5.2 → 1.5.4

package/lib/Socket/chats.js

@@ -706,12 +706,35 @@ export const makeChatsSocket = (config) => {
             ev.emit('presence.update', { id: jid, presences: { [participant]: presence } });
         }
     };
+    // Vanz@Fix 24-08-26 --- appPatch() (used by updateProfileName/archive/mute/pin/etc — anything
+    // going through the app-state WRITE path) threw "App state key not present!" immediately if
+    // myAppStateKeyId wasn't set yet, with zero retry. The READ path (resyncAppState, above) already
+    // has a courtesy retry via blockedCollections + the creds.update listener below — the key
+    // arrives async after connect (APP_STATE_SYNC_KEY_SHARE), so calling e.g. updateProfileName()
+    // right after connection.update === 'open' would reliably fail on a fresh/early connection.
+    // Now appPatch() waits (bounded, 10s default) for the same creds.update event before giving up,
+    // instead of failing hard on what's usually just a timing race.
+    const waitForAppStateKeyId = (timeoutMs = 10_000) => {
+        if (authState.creds.myAppStateKeyId) {
+            return Promise.resolve(authState.creds.myAppStateKeyId);
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                ev.off('creds.update', onUpdate);
+                reject(new Boom('App state key not present!', { statusCode: 400 }));
+            }, timeoutMs);
+            const onUpdate = ({ myAppStateKeyId }) => {
+                if (!myAppStateKeyId) return;
+                clearTimeout(timeout);
+                ev.off('creds.update', onUpdate);
+                resolve(myAppStateKeyId);
+            };
+            ev.on('creds.update', onUpdate);
+        });
+    };
     const appPatch = async (patchCreate) => {
         const name = patchCreate.type;
-        const myAppStateKeyId = authState.creds.myAppStateKeyId;
-        if (!myAppStateKeyId) {
-            throw new Boom('App state key not present!', { statusCode: 400 });
-        }
+        const myAppStateKeyId = await waitForAppStateKeyId();
         let initial;
         let encodeResult;
         await appStatePatchMutex.mutex(async () => {

package/lib/Utils/MessageBuilder.js

@@ -47,6 +47,8 @@
 const MESSAGE_BUILDER_VERSION = '4.9';
 
 import { generateWAMessageFromContent, prepareWAMessageMedia } from './messages.js';
+import { generateMessageIDV2 } from './generics.js';
+import { botMetadataSignature, botMetadataCertificate } from './rich-message-utils.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.
@@ -292,15 +294,19 @@ class Toolkit {
 		return await waitAllPromises(input);
 	}
 
-	/** Fetch `url` into a Buffer. @param {boolean} [silent] Return an empty Buffer instead of throwing on failure. */
-	static async fetchBuffer(url, options = {}, { silent = true } = {}) {
+	/** Fetch `url` into a Buffer. @param {boolean} [silent] Return an empty Buffer instead of throwing on failure. @param {number} [timeout] Abort after this many ms (default 15s) instead of hanging indefinitely on a dead/slow host. */
+	static async fetchBuffer(url, options = {}, { silent = true, timeout = 15000 } = {}) {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeout);
 		try {
-			let response = await fetch(url, options);
+			let response = await fetch(url, { ...options, signal: options.signal ?? controller.signal });
 			if (!response.ok) throw Error(`HTTP ${response.status}`);
 			return Buffer.from(await response.arrayBuffer());
 		} catch (error) {
 			if (silent) return Buffer.alloc(0);
 			throw error;
+		} finally {
+			clearTimeout(timer);
 		}
 	}
 
@@ -1180,14 +1186,6 @@ class Button extends BaseBuilder {
 	}
 
 	/** Build and send this interactive message. @param {string} jid Destination chat/group jid. */
-	async sendEdit(jid, messageId, { ...options } = {}) {
-		if (!messageId) throw new Error('messageId is required');
-		const msg = await this.build(jid, options);
-		msg.key = { ...(msg.key || {}), remoteJid: jid, id: messageId, fromMe: true };
-		await this.#client.relayMessage(jid, msg.message, { messageId, ...options });
-		return msg;
-	}
-
 	async send(jid, { ...options } = {}) {
 		const msg = await this.build(jid, options);
 
@@ -1594,9 +1592,21 @@ class AIRich extends BaseBuilder {
 		// mediaKey still doesn't render, so it's a trust-chain gate, not a domain/encoding issue).
 		// Track every addInlineImage() call here so send() can fall back to a normal imageMessage.
 		this._inlineImages = [];
-		// Plain WhatsApp-media fallbacks for AIRich primitives that some clients refuse to render inline.
-		// Entries are { type: 'image'|'video'|'audio'|'document', url, caption, mimetype, fileName }.
-		this._mediaFallbacks = [];
+
+		// Vanz@Add 24-08-26 --- ported from temen's MessageBuilderV4.7 (setResponseId/setBotResponseId
+		// below), rewritten to fit this fork's conventions. build() used to always mint a fresh
+		// crypto.randomUUID() for both unifiedResponse.response_id and botMetadata.botResponseId on
+		// every call, with no way to reuse one — so a `sendEdit()`-style flow (rebuild the same
+		// message with updated content, same response_id, so WA patches it in place instead of
+		// showing a new message) was never actually possible despite being in the gist example.
+		// null here means "not pinned yet" — build() falls back to a fresh randomUUID() same as before
+		// when neither setResponseId() nor setBotResponseId() has been called.
+		this._responseId = null;
+		this._botResponseId = null;
+
+		// Vanz@Add --- set by send()/sendEdit() after every relay so a follow-up sendEdit(), called
+		// with no args, knows which jid/message id to patch in place (matches temen's v4.7 API).
+		this._lastMessageKey = null;
 
 		// Vanz@Add (v4.9.1) --- { id, insertAt } support for every add*()/set*() call, without
 		// touching each method's own body/signature. Every add*() call ends up pushing 0-N items
@@ -1915,7 +1925,7 @@ class AIRich extends BaseBuilder {
 	 *   One image, no prompt, nothing to download — use this when you don't need the rich card,
 	 *   just the picture to show up immediately.
 	 */
-	addImage(imageUrl, { resolveUrl = false, instant = true } = {}) {
+	addImage(imageUrl, { resolveUrl = false, instant = false } = {}) {
 		if (!(typeof imageUrl === 'string' || Buffer.isBuffer(imageUrl) || (Array.isArray(imageUrl) && imageUrl.every((v) => typeof v === 'string' || Buffer.isBuffer(v))))) {
 			throw new TypeError('imageUrl must be string | buffer | array of string/buffer');
 		}
@@ -1973,8 +1983,6 @@ class AIRich extends BaseBuilder {
 			}
 
 			if (instant) {
-				this._mediaFallbacks.push({ type: 'image', url: imagePreviewUrl, caption: undefined });
-				// Keep legacy inline queue in sync for callers that inspect it.
 				this._inlineImages.push({ url: imagePreviewUrl, caption: undefined });
 			}
 		});
@@ -2052,7 +2060,7 @@ class AIRich extends BaseBuilder {
 	// for before rendering. Mirrors addImage()'s { resolveUrl } — when true, the url is uploaded to
 	// WA's own media server first via Toolkit.toUrl() so it renders instantly like WA-native media.
 	/** Add a video block. */
-	addVideo(videoUrl, { autoFill = false, resolveUrl = false, instant = true } = {}) {
+	addVideo(videoUrl, { autoFill = false, resolveUrl = false } = {}) {
 		const isObjectVideo = (v) => v && typeof v === 'object' && v.url;
 
 		const isValidPrimitive =
@@ -2129,15 +2137,6 @@ class AIRich extends BaseBuilder {
 					__typename: 'GenAIImaginePrimitive',
 				})
 			);
-
-			if (instant) {
-				this._mediaFallbacks.push({
-					type: 'video',
-					url,
-					caption: isObject ? (item.caption ?? '') : '',
-					mimetype: isObject ? (item.mime_type ?? 'video/mp4') : 'video/mp4',
-				});
-			}
 		});
 
 		return this;
@@ -2224,6 +2223,56 @@ class AIRich extends BaseBuilder {
 		return this;
 	}
 
+	// Vanz@Add 24-08-26 --- ported from temen's MessageBuilderV4.7 (setResponseId/setBotResponseId/
+	// refreshResponseId/refreshBotResponseId), rewritten for this fork. Pins the two ids build()
+	// generates (see constructor comment) so a rebuilt message can reuse the same response_id/
+	// botResponseId — needed for editing an already-sent AIRich message in place.
+
+	/** Pin `unifiedResponse.response_id` to a specific value instead of a fresh random one each build() — needed to re-send an edited version of an already-sent message in place. */
+	setResponseId(id) {
+		if (typeof id !== 'string' || !id) throw new TypeError('setResponseId(id) requires a non-empty string');
+		this._responseId = id;
+		return this;
+	}
+
+	/** Un-pin `unifiedResponse.response_id`, generating a fresh crypto.randomUUID() immediately (not deferred to the next build()). */
+	refreshResponseId() {
+		this._responseId = crypto.randomUUID();
+		return this;
+	}
+
+	/** Pin `botMetadata.botResponseId` to a specific value instead of a fresh random one each build(). */
+	setBotResponseId(id) {
+		if (typeof id !== 'string' || !id) throw new TypeError('setBotResponseId(id) requires a non-empty string');
+		this._botResponseId = id;
+		return this;
+	}
+
+	/** Un-pin `botMetadata.botResponseId`, generating a fresh crypto.randomUUID() immediately. */
+	refreshBotResponseId() {
+		this._botResponseId = crypto.randomUUID();
+		return this;
+	}
+
+	/** Add a small metadata-style text line (`GenAIMetadataTextPrimitive`) — same visual style as the auto-appended footer/`addTip()`'s callout, but insertable anywhere and without `addTip()`'s icon prefix. */
+	addMetadata(text) {
+		if (typeof text !== 'string' || !text) throw new TypeError('addMetadata(text) requires a non-empty string');
+
+		this._submessages.push({
+			messageType: 2,
+			messageText: text,
+		});
+
+		this._sections.push(
+			AIRich.newLayout('Single', {
+				text,
+				__typename: 'GenAIMetadataTextPrimitive',
+			})
+		);
+
+		return this;
+	}
+
 	/** Add a small "tip" callout banner. @param {string} text */
 	addTip(text) {
 		if (typeof text !== 'string' || !text) {
@@ -2301,7 +2350,6 @@ class AIRich extends BaseBuilder {
 				__typename: 'GenAIImagePrimitive',
 			})
 		);
-		this._mediaFallbacks.push({ type: 'image', url: full || preview, caption: undefined });
 
 		return this;
 	}
@@ -2641,6 +2689,18 @@ class AIRich extends BaseBuilder {
 				]
 			: [...(await waitAllPromises(this._sections))];
 
+		// Vanz@Merge 15-08-26 --- Neither blurose nor arslan sign the bot metadata with
+		// verificationMetadata (proofs/certificateChain). Backported from this project's own
+		// rich-message-utils.js botMetadataSignature/botMetadataCertificate helpers, plus a
+		// botResponseId tying the signed metadata to unifiedResponse.response_id.
+		// Vanz@Fix 24-08-26 --- was `const responseId = crypto.randomUUID()` shared for BOTH
+		// unifiedResponse.response_id and botMetadata.botResponseId, generated fresh every build()
+		// with no override. Now each has its own id, pinned via setResponseId()/setBotResponseId()
+		// if the caller set one (for sendEdit()-style in-place message updates), otherwise still
+		// defaults to a fresh randomUUID() per build() exactly like before.
+		const responseId = this._responseId ?? crypto.randomUUID();
+		const botResponseId = this._botResponseId ?? crypto.randomUUID();
+
 		return {
 			messageContextInfo: {
 				deviceListMetadata: {},
@@ -2648,6 +2708,17 @@ class AIRich extends BaseBuilder {
 				botMetadata: {
 					messageDisclaimerText: this._title,
 					richResponseSourcesMetadata: { sources: this._richResponseSources },
+					botResponseId: botResponseId,
+					verificationMetadata: {
+						proofs: [
+							{
+								certificateChain: [botMetadataCertificate(), botMetadataCertificate(892)],
+								version: 1,
+								useCase: 1,
+								signature: botMetadataSignature(),
+							},
+						],
+					},
 					...notif,
 				},
 			},
@@ -2658,7 +2729,7 @@ class AIRich extends BaseBuilder {
 						messageType: 1,
 						submessages: includesSubmessages ? await waitAllPromises(this._submessages) : [],
 						unifiedResponse: {
-							data: includesUnifiedResponse ? Buffer.from(JSON.stringify({ response_id: crypto.randomUUID(), sections })).toString('base64') : '',
+							data: includesUnifiedResponse ? Buffer.from(JSON.stringify({ response_id: responseId, sections })).toString('base64') : '',
 						},
 						contextInfo: {
 							...forward,
@@ -2679,106 +2750,96 @@ class AIRich extends BaseBuilder {
 	// the two calls expect different option shapes, so the fallback now only forwards `quoted`
 	// (the one option that clearly applies to both) instead of blindly spreading everything.
 	/** Build and send this AI-rich message. @param {string} jid Destination chat/group jid. @param {boolean} [skipImageFallback] Skip auto-resending inline images as a plain imageMessage. */
-	async send(jid, {
-		forwarded,
-		notification,
-		includesUnifiedResponse,
-		includesSubmessages,
-		skipImageFallback = false,
-		nativeFallback = true,
-		quoted,
-		...options
-	} = {}) {
+	async send(jid, { forwarded, notification, includesUnifiedResponse, includesSubmessages, skipImageFallback = false, quoted, messageId, ...options } = {}) {
 		const msg = await this.build({ forwarded, notification, includesUnifiedResponse, includesSubmessages, quoted, ...options });
-		const sendOptions = quoted ? { quoted } : {};
-
-		// Native fallback is enabled by default because stock/third-party WhatsApp clients
-		// do not reliably render botForwardedMessage.richResponseMessage. The rich payload
-		// remains available through build()/relayMessage(), while send() uses ordinary WA
-		// message types that are known to render immediately.
-		if (nativeFallback) {
-			const sent = [];
-
-			// 1) Send real WhatsApp media first. addImage()/addVideo()/addInlineImage()
-			// already populate this queue with resolved URLs/buffers.
-			if (!skipImageFallback && this._mediaFallbacks.length) {
-				const fallbacks = await waitAllPromises(this._mediaFallbacks);
-				for (const item of fallbacks) {
-					try {
-						const media = Buffer.isBuffer(item.url) ? item.url : { url: item.url };
-						const content = { [item.type]: media };
-						if (item.caption) content.caption = item.caption;
-						if (item.mimetype) content.mimetype = item.mimetype;
-						if (item.fileName) content.fileName = item.fileName;
-						sent.push(await this.#client.sendMessage(jid, content, sendOptions));
-					} catch (err) {
-						this.#client.logger?.warn?.(
-							{ err, url: item.url, type: item.type },
-							'AIRich native media fallback failed'
-						);
-					}
+
+		if (!skipImageFallback && this._inlineImages.length) {
+			for (const { url, caption } of this._inlineImages) {
+				try {
+					await this.#client.sendMessage(jid, { image: { url }, caption }, quoted ? { quoted } : {});
+				} catch (err) {
+					// Vanz@Fix: don't let a fallback image failure block the actual rich card from sending
+					this.#client.logger?.warn?.({ err, url }, 'inline image fallback failed, continuing with rich card');
 				}
 			}
+		}
 
-			// 2) Convert AIRich submessages into ordinary WhatsApp text. This preserves
-			// every primitive's readable content even when the AI-only rich renderer is absent.
-			const lines = [];
-			for (const sub of await waitAllPromises(this._submessages)) {
-				if (!sub) continue;
-
-				if (typeof sub.messageText === 'string' && sub.messageText.trim()) {
-					const t = sub.messageText.trim();
-
-					// Media primitives already have a native media message above; don't emit
-					// their internal placeholder text as a duplicate.
-					if (
-						t === '[ Video tidak dapat dimuat ]' ||
-						t === '[ Postingan tidak dapat dimuat ]' ||
-						t === '[ Produk tidak dapat dimuat ]' ||
-						t === '[ Sedang diproses... ]'
-					) continue;
-
-					lines.push(t);
-					continue;
-				}
+		// Vanz@Add --- pin our own messageId (instead of letting relayMessage mint one internally)
+		// so we know exactly which id was sent, and stash it as _lastMessageKey. That's what lets
+		// sendEdit() be called with no args afterwards and still know which message to patch.
+		messageId = messageId || generateMessageIDV2();
 
-				if (sub.codeMetadata) {
-					const blocks = sub.codeMetadata.codeBlocks ?? [];
-					const code = Array.isArray(blocks)
-						? blocks.map((b) => typeof b === 'string' ? b : (b?.value ?? '')).join('')
-						: String(blocks);
-					lines.push('```' + (sub.codeMetadata.codeLanguage || '') + '\\n' + code + '\\n```');
-					continue;
-				}
+		await this.#client.relayMessage(jid, msg, { messageId, ...options });
 
-				if (sub.tableMetadata?.rows) {
-					const rows = sub.tableMetadata.rows;
-					if (Array.isArray(rows)) {
-						lines.push(rows.map((row) => {
-							const cells = Array.isArray(row) ? row : row?.cells;
-							return Array.isArray(cells)
-								? cells.map((c) => typeof c === 'string' ? c : (c?.text ?? c?.value ?? '')).join(' | ')
-								: String(row);
-						}).join('\\n'));
-					}
-					continue;
-				}
+		this._lastMessageKey = { remoteJid: jid, fromMe: true, id: messageId };
 
-				if (sub.latexMetadata?.text) {
-					lines.push(sub.latexMetadata.text);
-				}
-			}
+		return { key: this._lastMessageKey, message: msg };
+	}
 
-			const text = lines.join('\\n\\n').trim();
-			if (text) {
-				sent.push(await this.#client.sendMessage(jid, { text }, sendOptions));
-			}
+	/**
+	 * Build a `protocolMessage` (type EDIT) that patches an already-sent AIRich message in place.
+	 * @param {string} targetJid Chat the original message lives in.
+	 * @param {string} targetId `key.id` of the original message (the id `send()`/`sendEdit()` returned).
+	 * @param {object} [opts] Pass `{ msg }` to reuse an already-built content object instead of rebuilding via build().
+	 */
+	async buildEdit(targetJid, targetId, { msg, messageId, ...options } = {}) {
+		const editedMessage = msg || (await this.build({ ...options }));
+
+		if (!editedMessage) {
+			throw new Error('buildEdit: no message content to edit (build() returned nothing)');
+		}
 
-			if (sent.length) return sent.length === 1 ? sent[0] : sent;
+		return generateWAMessageFromContent(
+			targetJid,
+			{
+				protocolMessage: {
+					key: {
+						remoteJid: targetJid,
+						fromMe: true,
+						id: targetId,
+					},
+					type: 14, // MESSAGE_EDIT
+					editedMessage,
+				},
+			},
+			{ messageId: messageId || generateMessageIDV2(), ...options }
+		);
+	}
+
+	/**
+	 * Rebuild this AIRich message's current content and patch it into an already-sent message in place
+	 * (WA edits the bubble instead of showing a new one). With no args, edits the message from the last
+	 * send()/sendEdit() call — that's the flow `.addX(...); await rich.sendEdit();` relies on.
+	 * @param {string} [jid] Defaults to the jid from the last send()/sendEdit().
+	 * @param {string} [id] Defaults to the message id from the last send()/sendEdit().
+	 */
+	async sendEdit(jid, id, { msg, messageId, additionalNodes = [], ...options } = {}) {
+		jid = jid ?? this._lastMessageKey?.remoteJid;
+		id = id ?? this._lastMessageKey?.id;
+
+		if (!jid) {
+			throw new Error('sendEdit: no jid — pass one explicitly, or call send() first');
+		}
+
+		if (!id) {
+			throw new Error('sendEdit: no message id — pass one explicitly, or call send() first');
 		}
 
-		// Explicit compatibility mode: preserve the original AIRich rich payload.
-		return await this.#client.relayMessage(jid, msg, { ...options });
+		const msgEdit = await this.buildEdit(jid, id, {
+			msg,
+			messageId: messageId || generateMessageIDV2(),
+			...options,
+		});
+
+		await this.#client.relayMessage(jid, msgEdit.message, {
+			messageId: msgEdit.key.id,
+			additionalNodes,
+		});
+
+		// Vanz@Note --- deliberately NOT overwriting _lastMessageKey with msgEdit.key here: the
+		// protocolMessage envelope has its own id, but the message the user actually sees (and the
+		// one future sendEdit() calls need to keep patching) is still `id`/`jid` above.
+		return msgEdit;
 	}
 
 	/** Tokenize `code` into `{ type, value }` spans for syntax highlighting. Covers JS/TS/Python/Java and more; unsupported languages fall back to a single plain-text token. */
@@ -3452,9 +3513,6 @@ class AIRich extends BaseBuilder {
 		if (!Array.isArray(arr) || !arr.every((row) => Array.isArray(row) && row.every((cell) => typeof cell === 'string'))) {
 			throw new TypeError('Table must be a nested array of strings');
 		}
-		if (arr.length === 0 || arr[0].length === 0) {
-			throw new TypeError('Table must contain a non-empty header row');
-		}
 
 		const [header, ...rows] = arr;
 
@@ -3638,7 +3696,6 @@ export {
 	AIRich,
 	AIRich as AIVanzxy,
 	AIRich as LeafRich,
-	AIRich as LeafReach,
 	AIRich as VanzxyAI,
 	AIRich as VanzxyRich,
 	Toolkit,

package/lib/Utils/MessageBuilder_d.ts

@@ -155,6 +155,11 @@ export class AIRich extends BaseBuilder {
 	addProduct(data?: Record<string, any>, options?: { resolveUrl?: boolean }): this;
 	addPost(data?: Record<string, any>, options?: { resolveUrl?: boolean }): this;
 	addTip(text: string): this;
+	addMetadata(text: string): this;
+	setResponseId(id: string): this;
+	refreshResponseId(): this;
+	setBotResponseId(id: string): this;
+	refreshBotResponseId(): this;
 	/** FOATextPrimitive — large heading text, distinct from addText()'s paragraph text. */
 	addHeading(text: string): this;
 	/** GenAIImagePrimitive — "ready" static image (preview + full-res), distinct from addImage()'s generation-style card. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vanzxy/baileys",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "Enhanced Baileys fork by Vanzxy — based on @itsliaaa/baileys + @whiskeysockets/baileys with fixes for audio group status and clean media without newsletter button.",
   "type": "module",
   "module": "./lib/index.js",