@vanzxy/baileys 1.6.2 → 1.6.4

package/lib/Utils/chat-history-helpers.d.ts

@@ -0,0 +1,21 @@
+import type { WAMessage } from '../Types/index.js';
+import type { AnyMediaMessageContent, WAMediaUploadFunction } from '../Types/Message.js';
+import type { ILogger } from './logger.js';
+import type { MediaType } from '../Defaults/index.js';
+/** The object returned by `makeInMemoryStore()` (see lib/Store/make-in-memory-store.js). */
+export interface InMemoryStoreLike {
+    messages?: Record<string, {
+        array: WAMessage[];
+    } | undefined>;
+}
+export declare const getLastMessageInChat: (store: InMemoryStoreLike, jid: string) => WAMessage | undefined;
+export declare const getOldestMessageInChat: (store: InMemoryStoreLike, jid: string) => WAMessage | undefined;
+export declare const copyNForward: (sock: {
+    sendMessage: (jid: string, content: unknown) => Promise<WAMessage | undefined>;
+}, jid: string, message: WAMessage, forceForward?: boolean) => Promise<WAMessage | undefined>;
+export declare const uploadMediaToWhatsApp: (sock: {
+    waUploadToServer: WAMediaUploadFunction;
+}, message: AnyMediaMessageContent, opts?: {
+    logger?: ILogger;
+    mediaTypeOverride?: MediaType;
+}) => Promise<any>;

package/lib/Utils/chat-history-helpers.js

@@ -0,0 +1,71 @@
+/**
+ * Vanz@Add --- ported from Bail-master addons/chat-history-helpers.ts.
+ *
+ * NOTE: Bail-master's original version was written against ITS OWN
+ * `in-memory-store.ts` addon (a plain `Map<jid, WAMessage[]>`), which this fork
+ * does not have. `@vanzxy/baileys` already ships a full `makeInMemoryStore`
+ * (see lib/Store/make-in-memory-store.js), whose `store.messages[jid]` is a
+ * KeyedDB-backed ordered dictionary exposing `.array` — NOT a plain array or
+ * Map. getLastMessageInChat / getOldestMessageInChat below are rewritten
+ * against that shape so they work with this fork's real store out of the box.
+ * copyNForward and uploadMediaToWhatsApp are store-independent and ported as-is.
+ */
+import { generateForwardMessageContent, prepareWAMessageMedia } from './messages.js';
+/**
+ * Get the most recently stored message in a chat.
+ * `store` is the object returned by `makeInMemoryStore()`, kept in sync via
+ * `store.bind(sock.ev)`.
+ */
+export const getLastMessageInChat = (store, jid) => {
+    const list = store.messages?.[jid];
+    const arr = list?.array;
+    if (!arr || arr.length === 0)
+        return undefined;
+    return arr[arr.length - 1];
+};
+/**
+ * Get the oldest stored message in a chat (useful as the `oldestMsgKey`
+ * cursor for `sock.fetchMessageHistory(...)`, which pages backwards from it).
+ */
+export const getOldestMessageInChat = (store, jid) => {
+    const list = store.messages?.[jid];
+    const arr = list?.array;
+    if (!arr || arr.length === 0)
+        return undefined;
+    return arr[0];
+};
+/**
+ * Re-send ("copy-forward") an existing message to a (possibly different) jid.
+ * Thin wrapper around generateForwardMessageContent + sock.sendMessage —
+ * strips the original sender's quoting/context the same way WhatsApp's own
+ * "Forward" action does, and marks the copy as forwarded.
+ *
+ * Usage: await copyNForward(sock, targetJid, originalMessage)
+ */
+export const copyNForward = async (sock, jid, message, forceForward = false) => {
+    const content = generateForwardMessageContent(message, forceForward);
+    return sock.sendMessage(jid, content);
+};
+/**
+ * Upload media directly to WhatsApp's own encrypted media CDN and get back
+ * a ready-to-send message-content object (with mediaKey, url/directPath,
+ * fileEncSha256, etc).
+ *
+ * IMPORTANT: WhatsApp clients only accept media that lives on WhatsApp's own
+ * CDN, encrypted with a mediaKey the recipient can derive — there is no way
+ * to point a WAMessage at an arbitrary third-party URL and have it render.
+ * This wrapper does the real, official upload (same path prepareWAMessageMedia
+ * / sock.waUploadToServer use internally) — it does not accept or return an
+ * arbitrary external URL.
+ *
+ * Usage: const media = await uploadMediaToWhatsApp(sock, { image: buffer })
+ *        await sock.sendMessage(jid, media)
+ */
+export const uploadMediaToWhatsApp = async (sock, message, opts) => {
+    return prepareWAMessageMedia(message, {
+        upload: sock.waUploadToServer,
+        logger: opts?.logger,
+        mediaTypeOverride: opts?.mediaTypeOverride
+    });
+};
+//# sourceMappingURL=chat-history-helpers.js.map

package/lib/Utils/index.d.ts

@@ -22,3 +22,14 @@ export * from "./browser-utils.js";
 export * from "./companion-reg-client-utils.js";
 export * from "./identity-change-handler.js";
 export * from "./stanza-ack.js";
+export * from "./anti-delete.js";
+export * from "./message-search.js";
+export * from "./chat-history-helpers.js";
+export * from "./scheduling.js";
+export * from "./auto-reply.js";
+export * from "./templates.js";
+export * from "./vcard.js";
+export * from "./media-messages.js";
+export * from "./stickerpack.js";
+export * from "./media-set.js";
+export * from "./status.js";

package/lib/Utils/index.js

@@ -18,9 +18,25 @@ export * from './event-buffer.js';
 export * from './process-message.js';
 export * from './rich-message-utils.js';
 export * from './MessageBuilder.js';
+export * from './A2UI.js';
+export * from './PersistentStore.js';
+export * from './message-kind.js';
 export * from './message-retry-manager.js';
 export * from './browser-utils.js';
 export * from './companion-reg-client-utils.js';
 export * from './identity-change-handler.js';
 export * from './stanza-ack.js';
+export * from './button-helper-utils.js';
+export * from './button-sender.js';
+export * from './anti-delete.js';
+export * from './message-search.js';
+export * from './chat-history-helpers.js';
+export * from './scheduling.js';
+export * from './auto-reply.js';
+export * from './templates.js';
+export * from './vcard.js';
+export * from './media-messages.js';
+export * from './stickerpack.js';
+export * from './media-set.js';
+export * from './status.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/media-messages.d.ts

@@ -0,0 +1,18 @@
+import type { WAMediaUpload } from '../Types/index.js';
+export declare const generateProfilePictureFull: (img: Buffer | string) => Promise<{
+    img: Buffer;
+}>;
+export declare const changeprofileFull: (img: Buffer | string) => Promise<{
+    img: Buffer;
+}>;
+export declare const generateProfilePictureFP: (buffer: Buffer | string) => Promise<{
+    img: Buffer;
+    preview: Buffer;
+}>;
+export declare const generatePP: (buffer: Buffer | string) => Promise<{
+    img: Buffer;
+    preview: Buffer;
+}>;
+export declare const generateProfilePicturee: (mediaUpload: WAMediaUpload) => Promise<{
+    img: Buffer;
+}>;

package/lib/Utils/media-messages.js

@@ -0,0 +1,71 @@
+/**
+ * Vanz@Add --- ported from Bail-master addons/media-messages.ts.
+ * Jimp-based profile-picture image generators (square + panoramic/wide).
+ * Deduplicated aliases kept intact: generateProfilePictureFull ===
+ * changeprofileFull, generateProfilePictureFP === generatePP (source had
+ * these as byte-identical pairs under different names).
+ */
+import { Jimp, JimpMime } from 'jimp';
+const toBuffer = async (stream) => {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    stream.destroy?.();
+    return Buffer.concat(chunks);
+};
+/**
+ * Generates a panoramic/wide profile picture buffer — landscape images are
+ * scaled down to a 720px-wide target, portrait images to a 324px-wide
+ * target, preserving aspect ratio throughout.
+ */
+const generateWideProfilePicture = async (img) => {
+    const jimp = await Jimp.read(img);
+    const width = jimp.bitmap.width;
+    const height = jimp.bitmap.height;
+    const ratio = width > height ? width / 720 : width / 324;
+    const targetWidth = Math.round(width / ratio);
+    const targetHeight = Math.round(height / ratio);
+    const buffer = await jimp.resize({ w: targetWidth, h: targetHeight }).getBuffer(JimpMime.jpeg, { quality: 100 });
+    return { img: buffer };
+};
+export const generateProfilePictureFull = generateWideProfilePicture;
+export const changeprofileFull = generateWideProfilePicture;
+/**
+ * Generates a square profile picture buffer (main image, scaled to fit
+ * within 720x720) plus a normalized preview buffer.
+ */
+const generateSquareProfilePicture = async (buffer) => {
+    const jimp = await Jimp.read(buffer);
+    const img = await jimp.clone().scaleToFit({ w: 720, h: 720 }).getBuffer(JimpMime.jpeg);
+    const preview = await jimp.clone().normalize().getBuffer(JimpMime.jpeg);
+    return { img, preview };
+};
+export const generateProfilePictureFP = generateSquareProfilePicture;
+export const generatePP = generateSquareProfilePicture;
+/**
+ * Generates a profile picture buffer from a flexible input source — a raw
+ * Buffer, a `{ url }` media-upload descriptor, or a `{ stream }`
+ * media-upload descriptor. Resizes the longer dimension down to 720px,
+ * preserving aspect ratio on the other.
+ */
+export const generateProfilePicturee = async (mediaUpload) => {
+    let bufferOrFilePath;
+    if (Buffer.isBuffer(mediaUpload)) {
+        bufferOrFilePath = mediaUpload;
+    }
+    else if ('url' in mediaUpload) {
+        bufferOrFilePath = mediaUpload.url.toString();
+    }
+    else {
+        bufferOrFilePath = await toBuffer(mediaUpload.stream);
+    }
+    const jimp = await Jimp.read(bufferOrFilePath);
+    const { width, height } = jimp.bitmap;
+    const resized = width > height
+        ? jimp.resize({ w: 720, h: Math.round((height / width) * 720) })
+        : jimp.resize({ w: Math.round((width / height) * 720), h: 720 });
+    const img = await resized.getBuffer(JimpMime.jpeg, { quality: 100 });
+    return { img };
+};
+//# sourceMappingURL=media-messages.js.map

package/lib/Utils/media-set.d.ts

@@ -0,0 +1,13 @@
+import type { AnyMessageContent } from '../Types/index.js';
+import type makeWASocket from '../Socket/index.js';
+type WASocket = ReturnType<typeof makeWASocket>;
+export declare const updateProfilePictureFull: (jid: string, content: Buffer | string, sock: WASocket) => Promise<any>;
+export declare const updateProfilePictureFull2: (jid: string, content: Buffer | string, sock: WASocket) => Promise<any>;
+type GroupStatusContent = AnyMessageContent & {
+    backgroundColor?: string;
+};
+export declare const groupStatus: (jid: string, content: GroupStatusContent, sock: WASocket) => Promise<any>;
+export declare const groupStatusV2: (jids: string[], content: GroupStatusContent, sock: WASocket) => Promise<any[]>;
+export declare const groupSetMemberLabel: (jid: string, memberLabel: string, sock: WASocket) => Promise<any>;
+export declare const groupLabel: (jid: string, text: string, sock: WASocket) => Promise<void>;
+export {};

package/lib/Utils/media-set.js

@@ -0,0 +1,165 @@
+/**
+ * Vanz@Add --- ported from Bail-master addons/media-set.ts.
+ * Profile-picture setters (full/panoramic variants) and group-status /
+ * member-label senders. Depends on this fork's own media-messages.js
+ * (also ported this batch) and its existing generateWAMessageContent /
+ * generateWAMessageFromContent / unixTimestampSeconds / S_WHATSAPP_NET.
+ *
+ * NOTE ON DUPLICATE-LOOKING SETTERS: `updateProfilePictureFull` and
+ * `updateProfilePictureFull2` are genuinely different, not duplicates —
+ * the first sends the `img` buffer from `generateProfilePictureFP`
+ * (scaled-to-fit 720x720 main image), the second sends the `preview`
+ * buffer from `generatePP` (normalized preview). Both are kept.
+ */
+import { randomBytes } from 'node:crypto';
+import { generateWAMessageContent, generateWAMessageFromContent, unixTimestampSeconds } from './messages.js';
+import { S_WHATSAPP_NET } from '../WABinary/index.js';
+import { generatePP, generateProfilePictureFP } from './media-messages.js';
+/** Update the profile picture for yourself or a group — sends the main (scaled-to-fit) image. */
+export const updateProfilePictureFull = async (jid, content, sock) => {
+    const { query } = sock;
+    const { img } = await generateProfilePictureFP(content);
+    const media = await query({
+        tag: 'iq',
+        attrs: {
+            target: jid,
+            to: S_WHATSAPP_NET,
+            type: 'set',
+            xmlns: 'w:profile:picture'
+        },
+        content: [
+            {
+                tag: 'picture',
+                attrs: { type: 'image' },
+                content: img
+            }
+        ]
+    });
+    return media;
+};
+/** Update the profile picture for yourself or a group — sends the normalized preview image. */
+export const updateProfilePictureFull2 = async (jid, content, sock) => {
+    const { query } = sock;
+    const { preview } = await generatePP(content);
+    const media = await query({
+        tag: 'iq',
+        attrs: {
+            target: jid,
+            to: S_WHATSAPP_NET,
+            type: 'set',
+            xmlns: 'w:profile:picture'
+        },
+        content: [
+            {
+                tag: 'picture',
+                attrs: { type: 'image' },
+                content: preview
+            }
+        ]
+    });
+    return media;
+};
+/** Send a group status (status update visible only within a group's members). */
+export const groupStatus = async (jid, content, sock) => {
+    const { backgroundColor, ...rest } = content;
+    const inside = await generateWAMessageContent(rest, {
+        upload: sock.waUploadToServer,
+        backgroundColor
+    });
+    const messageSecret = randomBytes(32);
+    const m = generateWAMessageFromContent(jid, {
+        messageContextInfo: { messageSecret },
+        groupStatusMessageV2: {
+            message: {
+                ...inside,
+                messageContextInfo: { messageSecret }
+            }
+        }
+    }, {});
+    await sock.relayMessage(jid, m.message, { messageId: m.key.id });
+    return m;
+};
+/** Send the same group status to multiple groups at once. */
+export const groupStatusV2 = async (jids, content, sock) => {
+    const { backgroundColor, ...rest } = content;
+    const inside = await generateWAMessageContent(rest, {
+        upload: sock.waUploadToServer,
+        backgroundColor
+    });
+    const messageSecret = randomBytes(32);
+    const results = [];
+    for (const id of jids) {
+        const m = generateWAMessageFromContent(id, {
+            messageContextInfo: { messageSecret },
+            groupStatusMessageV2: {
+                message: {
+                    ...inside,
+                    messageContextInfo: { messageSecret }
+                }
+            }
+        }, {});
+        await sock.relayMessage(id, m.message, { messageId: m.key.id });
+        results.push(m);
+    }
+    return results;
+};
+/**
+ * Set/update a member's label in a group (awaits the relay and returns the result).
+ * Label is truncated to 30 characters (WA's limit).
+ */
+export const groupSetMemberLabel = async (jid, memberLabel, sock) => {
+    const result = await sock.relayMessage(jid, {
+        protocolMessage: {
+            type: 30,
+            memberLabel: {
+                label: memberLabel.slice(0, 30),
+                labelTimestamp: unixTimestampSeconds() || Date.now()
+            }
+        }
+    }, {
+        additionalNodes: [
+            {
+                tag: 'meta',
+                attrs: {
+                    tag_reason: 'user_update',
+                    appdata: 'member_tag'
+                },
+                content: undefined
+            }
+        ]
+    });
+    return result;
+};
+/**
+ * Set/update a member's label in a group — fire-and-forget variant (errors
+ * are swallowed, matching the source's behavior; prefer
+ * `groupSetMemberLabel` if you need to await/observe failures).
+ */
+export const groupLabel = async (jid, text, sock) => {
+    try {
+        void sock.relayMessage(jid, {
+            protocolMessage: {
+                type: 30,
+                memberLabel: {
+                    label: text.slice(0, 30),
+                    labelTimestamp: Date.now()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    }
+    catch {
+        // intentionally swallowed — matches source behavior
+    }
+};
+//# sourceMappingURL=media-set.js.map

package/lib/Utils/message-kind.js

@@ -0,0 +1,139 @@
+/**
+ * Evernight AI — lib/Utils/message-kind.js / Creator : Vanzxy🍃
+ *
+ * Addon-kind resolution logic adapted from zapo-js (MIT, © vinikjkkj)
+ * <https://github.com/vinikjkkj/zapo>, ported to this Baileys fork's
+ * message-content shape. The normalized reply parser below is original,
+ * written to cover this fork's own buttonsResponseMessage /
+ * listResponseMessage / interactiveResponseMessage / templateButtonReplyMessage
+ * send-side shapes (see messages.js).
+ */
+
+/**
+ * Unwraps ephemeral/viewOnce/edited wrappers to get at the real content.
+ * Mirrors the wrapper set already handled by normalizeMessageContent()
+ * in messages.js, kept local here to avoid a circular import.
+ */
+const unwrapMessage = (message) => {
+    let content = message;
+    for (let i = 0; i < 5; i++) {
+        const inner = content?.ephemeralMessage?.message ||
+            content?.viewOnceMessage?.message ||
+            content?.viewOnceMessageV2?.message ||
+            content?.viewOnceMessageV2Extension?.message ||
+            content?.documentWithCaptionMessage?.message ||
+            content?.editedMessage?.message;
+        if (!inner) {
+            break;
+        }
+        content = inner;
+    }
+    return content;
+};
+
+/**
+ * Companion "addon kind" for list / native-flow style messages.
+ * Ported from zapo-js's resolveButtonAddonKind (src/message/encode/content.ts).
+ * @typedef {'list' | 'interactive' | 'payment_info' | 'order_details'} WaButtonAddonKind
+ */
+
+const resolveNativeFlowAddonKind = (nativeFlow) => {
+    const firstButtonName = nativeFlow?.buttons?.[0]?.name;
+    if (firstButtonName === 'payment_info')
+        return 'payment_info';
+    if (firstButtonName === 'review_and_pay')
+        return 'order_details';
+    return 'interactive';
+};
+
+/**
+ * Resolves which kind of button/list addon an outgoing message carries.
+ * Returns null if the message has no button/list/native-flow content.
+ * @param {import('../../WAProto').proto.IMessage} message
+ * @returns {WaButtonAddonKind | null}
+ */
+export const resolveButtonAddonKind = (message) => {
+    const msg = unwrapMessage(message);
+    if (!msg)
+        return null;
+    if (msg.listMessage)
+        return 'list';
+    if (msg.buttonsMessage)
+        return 'interactive';
+    const nativeFlow = msg.interactiveMessage?.nativeFlowMessage;
+    if (nativeFlow)
+        return resolveNativeFlowAddonKind(nativeFlow);
+    return null;
+};
+
+/**
+ * Normalized shape returned by parseInteractiveReply, regardless of which
+ * underlying WhatsApp reply type produced it.
+ * @typedef {Object} NormalizedInteractiveReply
+ * @property {'buttons_response'|'list_response'|'native_flow_response'|'template_button_reply'|null} kind
+ * @property {string|null} id - the button/row/native-flow id the user selected
+ * @property {string|null} displayText - visible text of the selection, if present
+ * @property {Object|null} params - parsed paramsJson for native-flow responses, or null
+ */
+
+/**
+ * Reads whatever a user tapped (button, list row, or native-flow reply) and
+ * returns one consistent shape, so plugin authors don't need a different
+ * branch per response type. Safe against malformed paramsJson (returns null
+ * instead of throwing).
+ * @param {import('../../WAProto').proto.IMessage} message
+ * @returns {NormalizedInteractiveReply}
+ */
+export const parseInteractiveReply = (message) => {
+    const msg = unwrapMessage(message);
+    const empty = { kind: null, id: null, displayText: null, params: null };
+    if (!msg)
+        return empty;
+    if (msg.buttonsResponseMessage) {
+        const r = msg.buttonsResponseMessage;
+        return {
+            kind: 'buttons_response',
+            id: r.selectedButtonId || null,
+            displayText: r.selectedDisplayText || null,
+            params: null
+        };
+    }
+    if (msg.listResponseMessage) {
+        const r = msg.listResponseMessage;
+        return {
+            kind: 'list_response',
+            id: r.singleSelectReply?.selectedRowId || null,
+            displayText: r.title || r.description || null,
+            params: null
+        };
+    }
+    if (msg.interactiveResponseMessage) {
+        const r = msg.interactiveResponseMessage;
+        let params = null;
+        if (r.nativeFlowResponseMessage?.paramsJson) {
+            try {
+                params = JSON.parse(r.nativeFlowResponseMessage.paramsJson);
+            }
+            catch {
+                params = null;
+            }
+        }
+        return {
+            kind: 'native_flow_response',
+            id: params?.id ?? r.nativeFlowResponseMessage?.name ?? null,
+            displayText: r.body?.text || null,
+            params
+        };
+    }
+    if (msg.templateButtonReplyMessage) {
+        const r = msg.templateButtonReplyMessage;
+        return {
+            kind: 'template_button_reply',
+            id: r.selectedId || null,
+            displayText: r.selectedDisplayText || null,
+            params: null
+        };
+    }
+    return empty;
+};
+//# sourceMappingURL=message-kind.js.map

package/lib/Utils/message-search.d.ts

@@ -0,0 +1,44 @@
+import type { WAMessage } from '../Types/index.js';
+export type SearchMessageType = 'text' | 'image' | 'video' | 'document' | 'audio' | 'sticker' | 'location' | 'contact' | 'other';
+export interface SearchOptions {
+    jid?: string;
+    fromDate?: Date;
+    toDate?: Date;
+    fromSender?: string;
+    fromMe?: boolean;
+    messageTypes?: SearchMessageType[];
+    limit?: number;
+    caseSensitive?: boolean;
+}
+export interface SearchResult {
+    message: WAMessage;
+    matchedText: string;
+    matchPosition: number;
+    relevanceScore: number;
+}
+export interface RegexSearchOptions {
+    jid?: string;
+    fromSender?: string;
+    fromMe?: boolean;
+    messageTypes?: SearchMessageType[];
+    limit?: number;
+}
+export declare const extractMessageText: (message: WAMessage) => string;
+export declare const calculateRelevance: (query: string, text: string, position: number) => number;
+export declare const searchMessages: (messages: WAMessage[], query: string, options?: SearchOptions) => SearchResult[];
+export declare const searchMessagesRegex: (messages: WAMessage[], pattern: RegExp, options?: RegexSearchOptions) => SearchResult[];
+export declare class MessageSearchManager {
+    private messages;
+    private messageIndex;
+    addMessages(messages: WAMessage[]): void;
+    removeMessages(messageIds: string[]): void;
+    clear(): void;
+    get count(): number;
+    search(query: string, options?: SearchOptions): SearchResult[];
+    searchRegex(pattern: RegExp, options?: RegexSearchOptions): SearchResult[];
+    getByJid(jid: string): WAMessage[];
+    getBySender(sender: string): WAMessage[];
+    getByType(type: SearchMessageType): WAMessage[];
+    getById(id: string): WAMessage | undefined;
+}
+export declare const createMessageSearch: () => MessageSearchManager;