@vanzxy/baileys 1.6.4 → 1.6.6

package/lib/Defaults/index.d.ts

@@ -5,6 +5,11 @@ export const CALL_VIDEO_PREFIX: "https://call.whatsapp.com/video/";
 export const CALL_AUDIO_PREFIX: "https://call.whatsapp.com/voice/";
 export const DONATE_URL: "";
 export const LIBRARY_NAME: "vanzxy/baileys";
+export const COMPANION_DEVICE_VERSION: {
+    primary: number;
+    secondary: number;
+    tertiary: number;
+};
 export const DEF_CALLBACK_PREFIX: "CB:";
 export const DEF_TAG_PREFIX: "TAG:";
 export const PHONE_CONNECTION_CB: "CB:Pong";

package/lib/Defaults/index.js

@@ -2,10 +2,27 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-// Vanz@Fix: dinaikin ke angka yang sama kayak baileys resmi (per 14/8/2026)
-// — ini cuma fallback kalau fetchLatestBaileysVersion() gagal total
-// (mis. GitHub gak bisa diakses), jadi tetap worth di-update berkala.
-const version = [2, 3000, 1045191189];
+// Vanz@Fix: disamain sama baseline yang dipake pas diff WAProto (lihat
+// WAProto/CHANGELOG-proto-upgrade.md — sempet lebih baru dari fallback
+// lama, jadi socket ngaku versi lebih tua dari field yang udah didukung
+// proto-nya sendiri). Ini cuma fallback kalau fetchLatestBaileysVersion()
+// gagal total (mis. GitHub gak bisa diakses) — tetap worth di-update
+// berkala, dan runtime tetap disaranin pake fetchLatestWaWebVersion()
+// dulu (parse sw.js langsung) baru fallback ke fetchLatestBaileysVersion()
+// / konstanta ini, karena fetchLatestBaileysVersion resmi Baileys ada
+// history bug isLatest:true padahal versinya stale (WhiskeySockets#2679).
+const version = [2, 3000, 1046350168];
+// Vanz@Fix (bug 65): this was an untracked, uncommented magic number inline
+// inside generateRegistrationNode() in validate-connection.js — a *second*,
+// independent hardcoded version (WA's "companion/device-props" version sent
+// during device pairing, distinct from `version` above which is the WA Web
+// client version used for appVersion/buildHash). It can go stale the exact
+// same way `version` can (same failure mode as WhiskeySockets#2370/#2485),
+// but unlike `version`, it isn't covered by fetchLatestWaWebVersion(),
+// fetchLatestBaileysVersion(), or fetchBestWaVersion() — none of those touch
+// it, so it was silently unmaintained. Named + documented here so it's at
+// least visible and update-able; still worth bumping periodically by hand.
+export const COMPANION_DEVICE_VERSION = { primary: 10, secondary: 15, tertiary: 7 };
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const BIZ_BOT_SUPPORT_PAYLOAD = '{"version":1,"is_ai_message":true,"should_upload_client_logs":false,"should_show_system_message":false,"ticket_id":"7004947587700716","citation_items":[],"ticket_locale":"us"}';
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';

package/lib/Utils/A2UI.js

@@ -16,7 +16,7 @@
 "use strict";
 
 import crypto from "crypto";
-import { generateWAMessageFromContent } from "./messages.js";
+import { generateWAMessageFromContent, prepareWAMessageMedia } from "./messages.js";
 import { getBizBinaryNode } from "../WABinary/index.js";
 
 class A2UI {
@@ -133,11 +133,45 @@ class A2UI {
 		};
 		return this;
 	}
+	// Vanz@Add 30-08-26 --- send(): terminal method so A2UI can be used as a one-liner like
+	// the other builders (Button/ButtonV2/AIRich `.send()`), instead of always needing the
+	// separate `sendA2UIWidget()` call. Thin wrapper only — root([...ids])/listCard() must
+	// still be called first, same as before build(); this doesn't change the id-returning
+	// factory API (child methods still return ids, not `this`, since sibling nodes need to
+	// reference each other by id when wiring children/trigger/content).
+	async send(client, jid, opts = {}) {
+		return sendA2UIWidget(client, jid, { ...opts, a2ui: this });
+	}
+	// Vanz@Add 30-08-26 --- validates that every structural id-reference (child/children on
+	// Button/Card/Column/Row, trigger/content on Modal) points at a component that was
+	// actually registered. Without this, a typo'd id just gets written into the wire payload
+	// as-is and the failure only surfaces as a broken/blank widget on the WA client, with no
+	// error on this end. Only covers the dedicated methods' known reference keys — raw()'s
+	// free-form props aren't inspected, since there's no way to know which of those are id
+	// references vs plain data.
+	#validateRefs(components) {
+		const validIds = new Set(components.map((c) => c.id));
+		for (const c of components) {
+			for (const key of ["child", "trigger", "content"]) {
+				if (c[key] !== undefined && !validIds.has(c[key])) {
+					throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${c[key]}" via "${key}"`);
+				}
+			}
+			if (Array.isArray(c.children)) {
+				for (const childId of c.children) {
+					if (!validIds.has(childId)) {
+						throw new Error(`A2UI: component "${c.id}" (${c.component}) references unknown id "${childId}" in "children"`);
+					}
+				}
+			}
+		}
+	}
 	build({ uuid = crypto.randomUUID(), surfaceId, type = "im_a2ui", wrapped = true } = {}) {
 		if (this._listCardPayload) return this._listCardPayload;
 		if (!this._rootChildren.length) throw new Error("Call root([...ids]) before build()");
 		const root = { id: "root", component: "Column", children: this._rootChildren };
 		const components = [root, ...this._components.values()];
+		this.#validateRefs(components);
 		const data = wrapped
 			? {
 					version: this._version,
@@ -171,7 +205,13 @@ async function sendA2UIWidget(client, jid, {
 	quoted,
 	type = "im_a2ui",
 	wrapped = true,
-	singleScreen = false
+	singleScreen = false,
+	// Vanz@Add 30-08-26 --- optional header media, mirroring Button/ButtonV2's toCard()
+	// pattern (prepareWAMessageMedia + client.waUploadToServer). { title, subtitle, image
+	// | video | document: path/buffer/{url} } — media is mutually exclusive, image wins if
+	// more than one is passed. Falls back to a title/subtitle-only header (no attachment)
+	// when no media is given, same shape as before this change.
+	header
 } = {}) {
 	if (!client) throw new Error("Socket is required");
 	if (!(a2ui instanceof A2UI)) throw new TypeError("a2ui must be an A2UI instance");
@@ -187,6 +227,26 @@ async function sendA2UIWidget(client, jid, {
 			}
 		: { messageParamsJson: "" };
 
+	const headerMediaData = header?.image
+		? { image: header.image }
+		: header?.video
+			? { video: header.video }
+			: header?.document
+				? { document: header.document }
+				: null;
+
+	const headerBlock = {
+		...(header?.title !== undefined ? { title: header.title } : {}),
+		...(header?.subtitle !== undefined ? { subtitle: header.subtitle } : {}),
+		hasMediaAttachment: !!headerMediaData,
+		...(headerMediaData
+			? await prepareWAMessageMedia(headerMediaData, { upload: client.waUploadToServer }).catch((e) => {
+					if (String(e).includes("Invalid media type")) return headerMediaData;
+					throw e;
+				})
+			: {})
+	};
+
 	const interactiveMessage = singleScreen
 		? {
 				nativeFlowMessage,
@@ -194,7 +254,7 @@ async function sendA2UIWidget(client, jid, {
 				...(expiration || Object.keys(contextInfo).length ? { contextInfo: { ...(expiration ? { expiration } : {}), ...contextInfo } } : {})
 			}
 		: {
-				header: { hasMediaAttachment: false },
+				header: headerBlock,
 				body: { text: bodyText },
 				...(footer ? { footer: { text: footer } } : {}),
 				nativeFlowMessage,

package/lib/Utils/anti-delete.d.ts

@@ -50,6 +50,9 @@ export declare const createAntiDeleteHandler: (store: MessageStore, onDelete?: (
     key: WAMessageKey;
     update: Partial<WAMessage>;
 }>) => DeletedMessageInfo[];
+export declare const createAntiDeleteUpsertHandler: (store: MessageStore, onDelete?: (info: DeletedMessageInfo) => void) => ({ messages }: {
+    messages: WAMessage[];
+}) => DeletedMessageInfo[];
 export declare const createMessageStoreHandler: (store: MessageStore) => ({ messages }: {
     messages: WAMessage[];
 }) => void;
@@ -61,6 +64,9 @@ declare const _default: {
         key: WAMessageKey;
         update: Partial<WAMessage>;
     }>) => DeletedMessageInfo[];
+    createAntiDeleteUpsertHandler: (store: MessageStore, onDelete?: (info: DeletedMessageInfo) => void) => ({ messages }: {
+        messages: WAMessage[];
+    }) => DeletedMessageInfo[];
     createMessageStoreHandler: (store: MessageStore) => ({ messages }: {
         messages: WAMessage[];
     }) => void;

package/lib/Utils/anti-delete.js

@@ -156,6 +156,34 @@ export const createAntiDeleteHandler = (store, onDelete) => {
         return deletedMessages;
     };
 };
+/**
+ * Vanz@Fix (bug 58): `createAntiDeleteHandler` above only listens on
+ * `messages.update` with `messageStubType === REVOKE`. In practice, most
+ * delete-for-everyone events actually arrive as a *new* message on
+ * `messages.upsert` carrying a `protocolMessage` of type REVOKE (the
+ * `isDeleteMessage`/`getDeletedMessageKey` helpers above existed for this but
+ * were never wired to anything). Wire this into `sock.ev.on('messages.upsert', ...)`
+ * alongside `createMessageStoreHandler` to actually catch those.
+ */
+export const createAntiDeleteUpsertHandler = (store, onDelete) => {
+    return ({ messages }) => {
+        const deletedMessages = [];
+        for (const message of messages) {
+            if (!isDeleteMessage(message))
+                continue;
+            const key = getDeletedMessageKey(message);
+            if (!key)
+                continue;
+            const deletedBy = message.key.participant || message.key.remoteJid;
+            const info = store.markAsDeleted(key, deletedBy);
+            if (info) {
+                deletedMessages.push(info);
+                onDelete?.(info);
+            }
+        }
+        return deletedMessages;
+    };
+};
 /**
  * Wire this into `sock.ev.on('messages.upsert', ...)` to keep `store` populated.
  * Skips protocol/sender-key-distribution messages, which carry no user content.
@@ -180,6 +208,7 @@ export default {
     isDeleteMessage,
     getDeletedMessageKey,
     createAntiDeleteHandler,
+    createAntiDeleteUpsertHandler,
     createMessageStoreHandler
 };
 //# sourceMappingURL=anti-delete.js.map

package/lib/Utils/auth-utils.js

@@ -195,15 +195,20 @@ export const addTransactionCapability = (state, logger, { maxCommitRetries, dela
             if (!ctx) {
                 // No transaction - direct write with queue protection
                 const types = Object.keys(data);
-                // Process pre-keys with validation
-                for (const type_ of types) {
-                    const type = type_;
+                // Vanz@Fix (bug 66): validateDeletions() used to run *before* this,
+                // serialized only against PreKeyManager's own internal queue —
+                // a separate PQueue instance from getQueue(type) below, both keyed
+                // 'pre-key' but never synchronized with each other. Two concurrent
+                // set() calls for pre-key data could validate against a store state
+                // that a still-pending write from the other call hadn't applied yet,
+                // letting a stale deletion go through or a just-deleted key get
+                // resurrected by data racing back in. Validation now happens inside
+                // the same per-type queue job as the write, so it's ordered against
+                // any other set() for that type instead of racing it.
+                await Promise.all(types.map(type => getQueue(type).add(async () => {
                     if (type === 'pre-key') {
                         await preKeyManager.validateDeletions(data, type);
                     }
-                }
-                // Write all data in parallel
-                await Promise.all(types.map(type => getQueue(type).add(async () => {
                     const typeData = { [type]: data[type] };
                     await state.set(typeData);
                 })));

package/lib/Utils/auto-reply.js

@@ -63,7 +63,6 @@ export class AutoReplyHandler {
     }
     setCooldown(ruleId, jid, cooldown) {
         this.cooldowns.set(`${ruleId}:${jid}`, Date.now() + cooldown);
-        this.globalCooldown.set(jid, Date.now());
     }
     matchRule(text, rule) {
         if (!rule.active)
@@ -137,6 +136,10 @@ export class AutoReplyHandler {
                     await this.sendPresence(jid, 'paused');
                 }
                 await this.sendMessage(jid, response, rule.quoted ? { quoted: message } : undefined);
+                // Vanz@Fix (bug 60): global cooldown used to only get stamped inside
+                // setCooldown(), which only ran when the matched rule had its own
+                // cooldown — so rules without one never fed the global anti-spam gate.
+                this.globalCooldown.set(jid, Date.now());
                 if (rule.cooldown)
                     this.setCooldown(rule.id, jid, rule.cooldown);
                 this.options.onReply(rule, message, response);

package/lib/Utils/baileys-event-stream.d.ts

@@ -0,0 +1,8 @@
+import type { BaileysEventEmitter } from '../Types/index.js';
+/** Monkey-patches ev.emit to append every event as an NDJSON line to `filename`. */
+export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void;
+/** Reads an NDJSON file written by captureEventStream and replays each event on a new EventEmitter. */
+export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
+    ev: BaileysEventEmitter;
+    task: Promise<void>;
+};

package/lib/Utils/baileys-event-stream.js

@@ -0,0 +1,62 @@
+// Ported from @queenanya/baileys `addons/baileys-event-stream.ts`.
+// Adjustments for @vanzxy/baileys: import paths rewired to this fork's own
+// `generics.js` (delay) and `make-mutex.js` (makeMutex) — both already
+// present, no logic changes otherwise.
+import EventEmitter from 'events';
+import { createReadStream } from 'fs';
+import { writeFile } from 'fs/promises';
+import { createInterface } from 'readline';
+import { delay } from './generics.js';
+import { makeMutex } from './make-mutex.js';
+
+/**
+ * Monkey-patches `ev.emit` to append every Baileys event as a JSON line
+ * (NDJSON) to `filename`. Useful for debugging or replaying sessions.
+ *
+ * @example
+ * captureEventStream(sock.ev, './events.ndjson')
+ */
+export const captureEventStream = (ev, filename) => {
+    const originalEmit = ev.emit.bind(ev);
+    const writeMutex = makeMutex();
+    const patchedEmit = (event, ...rest) => {
+        const line = JSON.stringify({ timestamp: Date.now(), event, data: rest[0] }) + '\n';
+        const result = originalEmit(event, ...rest);
+        void writeMutex.mutex(async () => {
+            await writeFile(filename, line, { flag: 'a' });
+        });
+        return result;
+    };
+    ev.emit = patchedEmit;
+};
+
+/**
+ * Reads an NDJSON file written by {@link captureEventStream} and replays
+ * each event on a new EventEmitter.
+ *
+ * @param filename        Path to the NDJSON file.
+ * @param delayIntervalMs Milliseconds to wait between events (default 0).
+ * @returns `{ ev, task }` — ev is the emitter, task resolves when done.
+ */
+export const readAndEmitEventStream = (filename, delayIntervalMs = 0) => {
+    const ev = new EventEmitter();
+    const fireEvents = async () => {
+        const fileStream = createReadStream(filename);
+        const rl = createInterface({ input: fileStream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            try {
+                const { event, data } = JSON.parse(line);
+                ev.emit(event, data);
+                if (delayIntervalMs)
+                    await delay(delayIntervalMs);
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        fileStream.destroy();
+    };
+    return { ev, task: fireEvents() };
+};

package/lib/Utils/business.js

@@ -200,10 +200,18 @@ export const uploadingNecessaryImages = async (images, waUploadToServer, timeout
         const hasher = createHash('sha256');
         const filePath = join(tmpdir(), 'img' + generateMessageIDV2());
         const encFileWriteStream = createWriteStream(filePath);
+        // Vanz@Fix (bug 61): no 'error' listener meant a write failure (e.g. disk
+        // full) would surface as an unhandled 'error' event instead of rejecting
+        // this promise; and the stream was never closed before unlink() below.
+        const writeStreamError = new Promise((_, reject) => encFileWriteStream.on('error', reject));
         for await (const block of stream) {
             hasher.update(block);
             encFileWriteStream.write(block);
         }
+        await Promise.race([
+            new Promise((resolve) => encFileWriteStream.end(resolve)),
+            writeStreamError
+        ]);
         const sha = hasher.digest('base64');
         const { directPath } = await waUploadToServer(filePath, {
             mediaType: 'product-catalog-image',

package/lib/Utils/button-sender.js

@@ -491,8 +491,15 @@ export function convertToInteractiveMessage(content) {
 			}
 		};
 
+		// Vanz@Fix 30-08-26 --- subtitle was being used only as a fallback for a missing
+		// title, then discarded — if BOTH title and subtitle were provided, subtitle never
+		// made it into the header at all (silently dropped, despite header.subtitle being a
+		// real proto field per MessageBuilder.js's toCard()). Write both independently.
 		if (content.title || content.subtitle) {
-			interactiveMessage.header = { title: content.title ?? content.subtitle ?? '' };
+			interactiveMessage.header = {
+				title: content.title ?? content.subtitle ?? '',
+				...(content.title && content.subtitle ? { subtitle: content.subtitle } : {})
+			};
 		}
 
 		if (content.text) {

package/lib/Utils/chat-control.d.ts

@@ -0,0 +1,159 @@
+/**
+ * Chat Control Utilities
+ *
+ * Source: @innovatorssoft/baileys (chat-control.js)
+ * Rewritten as clean TypeScript with full types and JSDoc.
+ *
+ * Three components:
+ *  - TypingIndicator  — composing / recording presence helpers
+ *  - PinnedMessagesManager — client-side pin tracking
+ *  - ReadReceiptController — configurable automatic read receipts
+ */
+/**
+ * Standard disappearing-message duration constants (in seconds).
+ * Pass to `sock.sendMessage(jid, { disappearingMessagesInChat: DISAPPEARING_DURATIONS.DAYS_7 })`.
+ */
+export declare const DISAPPEARING_DURATIONS: {
+    /** Disable disappearing messages */
+    readonly OFF: 0;
+    /** 24 hours */
+    readonly HOURS_24: 86400;
+    /** 7 days */
+    readonly DAYS_7: 604800;
+    /** 90 days */
+    readonly DAYS_90: 7776000;
+};
+export type DisappearingDuration = (typeof DISAPPEARING_DURATIONS)[keyof typeof DISAPPEARING_DURATIONS];
+type PresenceType = 'composing' | 'recording' | 'paused' | 'available' | 'unavailable';
+type SendPresence = (jid: string, presence: PresenceType) => Promise<void>;
+type TypingOptions = {
+    /** Auto-stop after this many ms (default: no auto-stop) */
+    duration?: number;
+    /** Whether to auto-pause on timeout — default `true` */
+    autoPause?: boolean;
+};
+/**
+ * Manages composing ("typing...") and recording ("recording...") presence
+ * indicators with per-JID timer tracking.
+ *
+ * @example
+ * const typing = createTypingIndicator(
+ *     (jid, presence) => sock.sendPresenceUpdate(presence, jid)
+ * )
+ *
+ * // Simulate typing then send a message
+ * const result = await typing.simulateTyping(jid, 1500, () =>
+ *     sock.sendMessage(jid, { text: 'Hello!' })
+ * )
+ */
+export declare class TypingIndicator {
+    private readonly sendPresence;
+    private readonly timers;
+    constructor(sendPresence: SendPresence);
+    /** Show the "typing..." (composing) indicator for a JID. */
+    startTyping(jid: string, options?: TypingOptions): Promise<void>;
+    /** Show the "recording..." (audio/video) indicator for a JID. */
+    startRecording(jid: string, options?: TypingOptions): Promise<void>;
+    /** Stop any active composing/recording indicator for a JID. */
+    stopTyping(jid: string): Promise<void>;
+    /** Stop all active indicators. */
+    stopAll(): Promise<void>;
+    /**
+     * Show typing for `durationMs`, run `callback`, then stop the indicator.
+     *
+     * @template T
+     * @returns The return value of `callback`
+     *
+     * @example
+     * await typing.simulateTyping(jid, 2000, async () => {
+     *     await sock.sendMessage(jid, { text: 'Here is your answer' })
+     * })
+     */
+    simulateTyping<T>(jid: string, durationMs: number, callback: () => Promise<T> | T): Promise<T>;
+    private clearTimer;
+}
+/** Factory — create a TypingIndicator. */
+export declare const createTypingIndicator: (sendPresence: SendPresence) => TypingIndicator;
+export type PinnedMessage = {
+    messageId: string;
+    jid: string;
+    pinnedAt: Date;
+    pinnedBy?: string;
+    expiresAt?: Date;
+};
+/**
+ * Client-side tracker for pinned messages.
+ * Listen to `messages.update` for `pinInChatMessage` protocol messages and call
+ * `manager.pin(jid, msgId, pinnedBy)` / `manager.unpin(jid, msgId)` accordingly.
+ */
+export declare class PinnedMessagesManager {
+    private readonly store;
+    /**
+     * Record a newly pinned message.
+     * @returns The created pin entry
+     */
+    pin(jid: string, messageId: string, pinnedBy?: string, expiresAt?: Date): PinnedMessage;
+    /**
+     * Remove a pinned message.
+     * @returns `true` if the pin was found and removed, `false` otherwise
+     */
+    unpin(jid: string, messageId: string): boolean;
+    /** Get all pinned messages for a chat. */
+    getPinned(jid: string): PinnedMessage[];
+    /** Check if a message is pinned in a chat. */
+    isPinned(jid: string, messageId: string): boolean;
+    /** Remove all pins for a chat. */
+    clearPins(jid: string): void;
+    /**
+     * Evict pins whose `expiresAt` is in the past.
+     * @returns Number of expired pins removed
+     */
+    clearExpired(): number;
+    /** Total pin count across all chats. */
+    get totalPins(): number;
+}
+/** Factory — create a PinnedMessagesManager. */
+export declare const createPinnedMessagesManager: () => PinnedMessagesManager;
+export type ReadReceiptConfig = {
+    /** Whether to send read receipts at all (default: `true`) */
+    enabled?: boolean;
+    /** JIDs to never send receipts for */
+    excludeJids?: string[];
+    /** Delay before marking as read in ms (default: `0`) */
+    readDelay?: number;
+};
+export type ReadReceiptController = {
+    setConfig(config: Partial<ReadReceiptConfig>): void;
+    getConfig(): Required<ReadReceiptConfig>;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    /**
+     * Mark messages as read, respecting the current config.
+     * No-op if disabled or JID is excluded.
+     */
+    markRead(jid: string, participant: string | null | undefined, messageIds: string[]): Promise<void>;
+    /** Mark messages as read regardless of config. */
+    forceMarkRead(jid: string, participant: string | null | undefined, messageIds: string[]): Promise<void>;
+};
+type SendReadReceipt = (jid: string, participant: string | null | undefined, messageIds: string[]) => Promise<void>;
+/**
+ * Create a read-receipt controller with optional auto-delay and per-JID exclusions.
+ *
+ * @example
+ * const readCtrl = createReadReceiptController(
+ *     (jid, participant, ids) => sock.readMessages(ids.map(id => ({ remoteJid: jid, id, participant }))),
+ *     { enabled: true, readDelay: 500, excludeJids: [spamJid] }
+ * )
+ *
+ * sock.ev.on('messages.upsert', ({ messages }) => {
+ *     for (const msg of messages) {
+ *         const { key } = msg
+ *         if (!key.fromMe)
+ *             readCtrl.markRead(key.remoteJid!, key.participant, [key.id!])
+ *     }
+ * })
+ */
+export declare const createReadReceiptController: (sendReadReceipt: SendReadReceipt, config?: ReadReceiptConfig) => ReadReceiptController;
+export {};
+//# sourceMappingURL=chat-control.d.ts.map