@japofc/baileys 2.1.0

package/lib/Utils/make-mutex.js

@@ -0,0 +1,32 @@
+import { Mutex as AsyncMutex } from 'async-mutex';
+export const makeMutex = () => {
+    const mutex = new AsyncMutex();
+    return {
+        mutex(code) {
+            return mutex.runExclusive(code);
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = new Map();
+    return {
+        async mutex(key, task) {
+            let entry = map.get(key);
+            if (!entry) {
+                entry = { mutex: new AsyncMutex(), refCount: 0 };
+                map.set(key, entry);
+            }
+            entry.refCount++;
+            try {
+                return await entry.mutex.runExclusive(task);
+            }
+            finally {
+                entry.refCount--;
+                // only delete it if this is still the current entry
+                if (entry.refCount === 0 && map.get(key) === entry) {
+                    map.delete(key);
+                }
+            }
+        }
+    };
+};

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,70 @@
+/**
+ * JAP@Add --- part of the @japofc/baileys utils (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 };
+};

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,171 @@
+/**
+ * JAP@Add --- part of the @japofc/baileys utils (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';
+// JAP@Fix: unixTimestampSeconds is not re-exported by messages.js (it only imports
+// it internally from generics.js for its own use) — pull it from generics.js directly.
+import { generateWAMessageContent, generateWAMessageFromContent } from './messages.js';
+import { unixTimestampSeconds } from './generics.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),
+                    // JAP@Fix (bug 67): this used Date.now() (milliseconds) while the
+                    // sibling groupSetMemberLabel() correctly uses unixTimestampSeconds()
+                    // for the same proto field — WA's *Timestamp fields are unix-seconds,
+                    // so this was sending a timestamp ~1000x too large.
+                    labelTimestamp: unixTimestampSeconds() || Date.now()
+                }
+            }
+        }, {
+            additionalNodes: [
+                {
+                    tag: 'meta',
+                    attrs: {
+                        tag_reason: 'user_update',
+                        appdata: 'member_tag'
+                    },
+                    content: undefined
+                }
+            ]
+        });
+    }
+    catch {
+        // intentionally swallowed — matches source behavior
+    }
+};

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

@@ -0,0 +1,32 @@
+/** Companion "addon kind" for list / native-flow style messages. */
+export type WaButtonAddonKind = 'list' | 'interactive' | 'payment_info' | 'order_details';
+
+/**
+ * Resolves which kind of button/list addon an outgoing message carries.
+ * Returns null if the message has no button/list/native-flow content.
+ */
+export declare const resolveButtonAddonKind: (message: any) => WaButtonAddonKind | null;
+
+export type InteractiveReplyKind =
+    | 'buttons_response'
+    | 'list_response'
+    | 'native_flow_response'
+    | 'template_button_reply'
+    | null;
+
+/** Normalized shape returned by parseInteractiveReply. */
+export interface NormalizedInteractiveReply {
+    kind: InteractiveReplyKind;
+    /** The button/row/native-flow id the user selected. */
+    id: string | null;
+    /** Visible text of the selection, if present. */
+    displayText: string | null;
+    /** Parsed paramsJson for native-flow responses, or null. */
+    params: Record<string, any> | null;
+}
+
+/**
+ * Reads whatever a user tapped (button, list row, or native-flow reply) and
+ * returns one consistent shape. Safe against malformed paramsJson.
+ */
+export declare const parseInteractiveReply: (message: any) => NormalizedInteractiveReply;

package/lib/Utils/message-kind.js

@@ -0,0 +1,136 @@
+/**
+ * Evernight AI — lib/Utils/message-kind.js / Creator : J.AP
+ *
+ * Addon-kind resolution for this package's message-content shape.
+ * The normalized reply parser below covers 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.
+ * Implements resolveButtonAddonKind-style resolution for button addon payloads.
+ * @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;
+};

package/lib/Utils/message-retry-manager.d.ts

@@ -0,0 +1,79 @@
+export const RetryReason: any;
+export class MessageRetryManager {
+    constructor(logger: any, maxMsgRetryCount: any);
+    logger: any;
+    recentMessagesMap: any;
+    messageKeyIndex: Map<any, any>;
+    sessionRecreateHistory: any;
+    retryCounters: any;
+    baseKeys: any;
+    pendingPhoneRequests: {};
+    maxMsgRetryCount: any;
+    statistics: {
+        totalRetries: number;
+        successfulRetries: number;
+        failedRetries: number;
+        mediaRetries: number;
+        sessionRecreations: number;
+        phoneRequests: number;
+    };
+    /**
+     * Add a recent message to the cache for retry handling
+     */
+    addRecentMessage(to: any, id: any, message: any): void;
+    /**
+     * Get a recent message from the cache
+     */
+    getRecentMessage(to: any, id: any): any;
+    /**
+     * Check if a session should be recreated based on retry count, history, and error code.
+     * MAC errors (codes 4 and 7) trigger immediate session recreation regardless of timeout.
+     */
+    shouldRecreateSession(jid: any, hasSession: any, errorCode: any): {
+        reason: string;
+        recreate: boolean;
+    };
+    /**
+     * Parse error code from retry receipt's retry node.
+     * Returns undefined if no error code is present.
+     */
+    parseRetryErrorCode(errorAttr: any): any;
+    /**
+     * Check if an error code indicates a MAC failure
+     */
+    isMacError(errorCode: any): boolean;
+    /**
+     * Increment retry counter for a message
+     */
+    incrementRetryCount(messageId: any): any;
+    /**
+     * Get retry count for a message
+     */
+    getRetryCount(messageId: any): any;
+    /**
+     * Check if message has exceeded maximum retry attempts
+     */
+    hasExceededMaxRetries(messageId: any): boolean;
+    /**
+     * Mark retry as successful
+     */
+    markRetrySuccess(messageId: any): void;
+    /**
+     * Mark retry as failed
+     */
+    markRetryFailed(messageId: any): void;
+    /**
+     * Schedule a phone request with delay
+     */
+    schedulePhoneRequest(messageId: any, callback: any, delay?: number): void;
+    /**
+     * Cancel pending phone request
+     */
+    cancelPendingPhoneRequest(messageId: any): void;
+    clear(): void;
+    saveBaseKey(addr: any, msgId: any, baseKey: any): void;
+    hasSameBaseKey(addr: any, msgId: any, baseKey: any): boolean;
+    deleteBaseKey(addr: any, msgId: any): void;
+    keyToString(key: any): string;
+    removeRecentMessage(messageId: any): void;
+}