@langitdeveloper/baileys 2.1.9 → 2.2.0

package/lib/Socket/business.js

@@ -246,8 +246,58 @@ const makeBusinessSocket = (config) => {
             deleted: +((productCatalogDelNode === null || productCatalogDelNode === void 0 ? void 0 : productCatalogDelNode.attrs.deleted_count) || 0)
         };
     };
+    /** updates the business profile fields (address/email/description/websites/hours) */
+    const updateBussinesProfile = async (args) => {
+        const node = [];
+        const simpleFields = ['address', 'email', 'description'];
+        node.push(...simpleFields
+            .filter((key) => args[key])
+            .map((key) => ({ tag: key, attrs: {}, content: args[key] })));
+        if (args.websites) {
+            node.push(...args.websites.map((website) => ({
+                tag: 'website',
+                attrs: {},
+                content: website
+            })));
+        }
+        if (args.hours) {
+            node.push({
+                tag: 'business_hours',
+                attrs: { timezone: args.hours.timezone },
+                content: args.hours.days.map((dayConfig) => {
+                    const base = {
+                        tag: 'business_hours_config',
+                        attrs: { day_of_week: dayConfig.day, mode: dayConfig.mode }
+                    };
+                    if (dayConfig.mode === 'specific_hours') {
+                        return {
+                            ...base,
+                            attrs: {
+                                ...base.attrs,
+                                open_time: dayConfig.openTimeInMinutes,
+                                close_time: dayConfig.closeTimeInMinutes
+                            }
+                        };
+                    }
+                    return base;
+                })
+            });
+        }
+        return await query({
+            tag: 'iq',
+            attrs: { to: WABinary_1.S_WHATSAPP_NET, type: 'set', xmlns: 'w:biz' },
+            content: [
+                {
+                    tag: 'business_profile',
+                    attrs: { v: '3', mutation_type: 'delta' },
+                    content: node
+                }
+            ]
+        });
+    };
     return {
         ...sock,
+        updateBussinesProfile,
         logger: config.logger,
         getOrderDetails,
         getCatalog,
@@ -257,4 +307,4 @@ const makeBusinessSocket = (config) => {
         productUpdate
     };
 };
-exports.makeBusinessSocket = makeBusinessSocket;
+exports.makeBusinessSocket = makeBusinessSocket;

package/lib/Socket/chats.js

@@ -591,6 +591,10 @@ const makeChatsSocket = (config) => {
     const profilePictureUrl = async (jid, type = 'preview', timeoutMs) => {
         var _a;
         jid = (0, WABinary_1.jidNormalizedUser)(jid);
+        if ((0, WABinary_1.isJidNewsLetter)(jid)) {
+            const metadata = await sock.newsletterMetadata('JID', jid);
+            return (metadata === null || metadata === void 0 ? void 0 : metadata.picture) ? (0, Utils_1.getUrlFromDirectPath)(metadata.picture) : undefined;
+        }
         const result = await query({
             tag: 'iq',
             attrs: {
@@ -962,8 +966,91 @@ const makeChatsSocket = (config) => {
             }
         }
     });
+    /** resolves the LID jid for a regular phone-number jid via a USync query */
+    const getLidUser = async (jid) => {
+        if (!jid) {
+            throw new boom_1.Boom('Please input a jid user');
+        }
+        if (!(0, WABinary_1.isJidUser)(jid)) {
+            throw new boom_1.Boom('Invalid JID: Not a user JID!');
+        }
+        const targetJid = (0, WABinary_1.jidNormalizedUser)(jid);
+        const usyncQuery = new WAUSync_1.USyncQuery().withLIDProtocol().withUser(new WAUSync_1.USyncUser().withId(targetJid));
+        const result = await sock.executeUSyncQuery(usyncQuery);
+        return result?.list?.[0]?.lid || null;
+    };
+    /** fetches per-jid disappearing-message duration via USync (so you know it without opening the chat) */
+    const fetchDisappearingDuration = async (...jids) => {
+        const usyncQuery = new WAUSync_1.USyncQuery().withDisappearingModeProtocol();
+        for (const jid of jids) {
+            usyncQuery.withUser(new WAUSync_1.USyncUser().withId(jid));
+        }
+        const result = await sock.executeUSyncQuery(usyncQuery);
+        return result ? result.list : undefined;
+    };
+    /** creates a WhatsApp call link (audio or video) you can share/send like any URL */
+    const createCallLink = async (type, event, timeoutMs) => {
+        const callType = type?.toLowerCase();
+        if (!callType || (callType !== 'audio' && callType !== 'video')) {
+            throw new Error('Make sure the type is audio or video!');
+        }
+        const result = await query({
+            tag: 'call',
+            attrs: { id: generateMessageTag(), to: '@call' },
+            content: [
+                {
+                    tag: 'link_create',
+                    attrs: { media: callType },
+                    content: event ? [{ tag: 'event', attrs: {}, content: JSON.stringify(event) }] : undefined
+                }
+            ]
+        }, timeoutMs);
+        const linkCreateNode = (0, WABinary_1.getBinaryNodeChild)(result, 'link_create');
+        const linkNode = (0, WABinary_1.getBinaryNodeChild)(linkCreateNode, 'link');
+        return linkNode ? (0, WABinary_1.getBinaryNodeChildString)(linkCreateNode, 'link') || linkNode?.content?.toString() : undefined;
+    };
+    /** fetches the list of official WA AI bots available (Meta AI etc.) */
+    const getBotListV2 = async () => {
+        const resp = await query({
+            tag: 'iq',
+            attrs: { xmlns: 'bot', to: WABinary_1.S_WHATSAPP_NET, type: 'get' },
+            content: [{ tag: 'bot', attrs: { v: '2' } }]
+        });
+        const botNode = (0, WABinary_1.getBinaryNodeChild)(resp, 'bot');
+        const botList = [];
+        for (const section of (0, WABinary_1.getBinaryNodeChildren)(botNode, 'section')) {
+            if (section.attrs.type === 'all') {
+                for (const bot of (0, WABinary_1.getBinaryNodeChildren)(section, 'bot')) {
+                    botList.push({ jid: bot.attrs.jid, personaId: bot.attrs['persona_id'] });
+                }
+            }
+        }
+        return botList;
+    };
+    const updateMessagesPrivacy = async (value) => { await privacyQuery('messages', value); };
+    const updateCallPrivacy = async (value) => { await privacyQuery('calladd', value); };
+    const updateDisableLinkPreviewsPrivacy = (isPreviewsDisabled) => chatModify({ disableLinkPreviews: { isPreviewsDisabled } }, '');
+    const addOrEditContact = (jid, contact) => chatModify({ contact }, jid);
+    const removeContact = (jid) => chatModify({ contact: null }, jid);
+    const addLabel = (jid, labels) => chatModify({ addLabel: { ...labels } }, jid);
+    const clearMessage = (jid, key, timeStamp) => chatModify({ delete: true, lastMessages: [{ key, messageTimestamp: timeStamp }] }, jid);
+    const addOrEditQuickReply = (quickReply) => chatModify({ quickReply }, '');
+    const removeQuickReply = (timestamp) => chatModify({ quickReply: { timestamp, deleted: true } }, '');
     return {
         ...sock,
+        getLidUser,
+        fetchDisappearingDuration,
+        createCallLink,
+        getBotListV2,
+        updateMessagesPrivacy,
+        updateCallPrivacy,
+        updateDisableLinkPreviewsPrivacy,
+        addOrEditContact,
+        removeContact,
+        addLabel,
+        clearMessage,
+        addOrEditQuickReply,
+        removeQuickReply,
         processingMutex,
         fetchPrivacySettings,
         upsertMessage,

package/lib/Socket/dugong.js

@@ -632,6 +632,27 @@ class kikyy {
 
         return msg;
     }
+
+    /**
+     * Sends multiple status updates as a "slide" sequence to the same
+     * audience, one after another - e.g. sendStatusAlbum([{ image: {...} },
+     * { video: {...} }, { text: 'last slide' }], jids). Returns the array
+     * of sent message objects, in the same order they were sent.
+     */
+    async sendStatusAlbum(contents, jids = [], delayMs = 1200) {
+        if (!Array.isArray(contents) || !contents.length) {
+            throw new Error('sendStatusAlbum: contents must be a non-empty array');
+        }
+        const results = [];
+        for (let i = 0; i < contents.length; i++) {
+            const sent = await this.sendStatusWhatsApp(contents[i], jids);
+            results.push(sent);
+            if (i < contents.length - 1) {
+                await Utils_1.delay(delayMs);
+            }
+        }
+        return results;
+    }
 }
 
 module.exports = kikyy;

package/lib/Socket/messages-recv.js

@@ -1142,4 +1142,4 @@ const makeMessagesRecvSocket = (config) => {
         requestPlaceholderResend,
     };
 };
-exports.makeMessagesRecvSocket = makeMessagesRecvSocket;
+exports.makeMessagesRecvSocket = makeMessagesRecvSocket;

package/lib/Socket/messages-send.js

@@ -261,6 +261,7 @@ const makeMessagesSocket = (config) => {
     };
     const relayMessage = async (jid, message, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, cachedGroupMetadata, useCachedGroupMetadata, statusJidList, AI = true }) => {
         const meId = authState.creds.me.id;
+        const meLid = authState.creds.me.lid;
         let shouldIncludeDeviceIdentity = false;
         let didPushAdditional = false
         const { user, server } = WABinary_1.jidDecode(jid);
@@ -340,8 +341,16 @@ const makeMessagesSocket = (config) => {
                     meId,
                 });
                 const senderKeyJids = [];
+                const { user: mePnUser } = WABinary_1.jidDecode(meId);
+                const { user: meLidUser } = meLid ? WABinary_1.jidDecode(meLid) : { user: null };
                 for (const { user, device } of devices) {
                     const jid = WABinary_1.jidEncode(user, (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) === 'lid' ? 'lid' : 's.whatsapp.net', device);
+                    // skip the exact device that sent this message - it already has the content
+                    const isExactSenderDevice = jid === meId || (meLid && jid === meLid);
+                    if (isExactSenderDevice) {
+                        logger.debug({ jid, meId, meLid }, 'Skipping exact sender device (whatsmeow pattern)');
+                        continue;
+                    }
                     if (!senderKeyMap[jid] || !!participant) {
                         senderKeyJids.push(jid);
                         senderKeyMap[jid] = true;
@@ -828,4 +837,4 @@ const makeMessagesSocket = (config) => {
         }
     }
 };
-exports.makeMessagesSocket = makeMessagesSocket;
+exports.makeMessagesSocket = makeMessagesSocket;

package/lib/Utils/bot-toolkit.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeBotToolkit = void 0;
+/**
+ * A grab-bag of small, self-contained quality-of-life features that don't
+ * exist in upstream Baileys or other forks. None of this touches the core
+ * decrypt/encrypt/socket pipeline - it's all additive, attached to the
+ * socket's return object.
+ */
 const makeBotToolkit = (conn, logger) => {
     const startedAt = Date.now();
     const seenMessageIds = new Map(); // id -> timestamp, used for dedup
@@ -17,7 +23,207 @@ const makeBotToolkit = (conn, logger) => {
             }
         }
     };
+    const pollTallies = new Map(); // pollMsgId -> { question, options, votes: Map<voterJid, optionIndex[]>, listening }
+    const groupMetaCache = new Map(); // jid -> { data, fetchedAt }
+    const GROUP_META_TTL_MS = 60 * 1000;
     return {
+        /**
+         * Downloads any URL into a Buffer - the one-liner you end up writing
+         * in every plugin that needs to grab an image/file from the internet
+         * before sending it.
+         */
+        async getBuffer(url, opts = {}) {
+            const res = await fetch(url, opts);
+            if (!res.ok) {
+                throw new Error(`getBuffer: HTTP ${res.status} fetching ${url}`);
+            }
+            const arrBuf = await res.arrayBuffer();
+            return Buffer.from(arrBuf);
+        },
+        /**
+         * Downloads a URL and sends it as the right message type automatically,
+         * based on the response's content-type (falls back to sniffing the
+         * file extension in the URL if the server doesn't send one).
+         *   await conn.sendFileFromUrl(jid, 'https://example.com/cat.png', { caption: 'meow' })
+         */
+        async sendFileFromUrl(jid, url, options = {}) {
+            const res = await fetch(url);
+            if (!res.ok) {
+                throw new Error(`sendFileFromUrl: HTTP ${res.status} fetching ${url}`);
+            }
+            const contentType = res.headers.get('content-type') || '';
+            const buffer = Buffer.from(await res.arrayBuffer());
+            let contentKey = 'document';
+            if (contentType.startsWith('image/') || /\.(jpe?g|png|webp|gif)$/i.test(url)) {
+                contentKey = 'image';
+            }
+            else if (contentType.startsWith('video/') || /\.(mp4|mkv|mov)$/i.test(url)) {
+                contentKey = 'video';
+            }
+            else if (contentType.startsWith('audio/') || /\.(mp3|ogg|wav|m4a)$/i.test(url)) {
+                contentKey = 'audio';
+            }
+            const content = { [contentKey]: buffer, ...options };
+            if (contentKey === 'document' && !content.mimetype) {
+                content.mimetype = contentType || 'application/octet-stream';
+            }
+            return conn.sendMessage(jid, content, options.messageOptions || {});
+        },
+        /** human-readable uptime string, e.g. "2h 14m 9s", for status/.ping commands */
+        uptimeString() {
+            const ms = Date.now() - startedAt;
+            const s = Math.floor(ms / 1000) % 60;
+            const m = Math.floor(ms / 60000) % 60;
+            const h = Math.floor(ms / 3600000);
+            return `${h}h ${m}m ${s}s`;
+        },
+        /**
+         * Cached groupMetadata - avoids hammering WA's servers when you call
+         * groupMetadata() repeatedly for the same group in a short window
+         * (e.g. every message handler checking admin status). Falls back to
+         * a real fetch automatically once the cache entry goes stale.
+         */
+        async getCachedGroupMetadata(jid, ttlMs = GROUP_META_TTL_MS) {
+            const cached = groupMetaCache.get(jid);
+            const now = Date.now();
+            if (cached && now - cached.fetchedAt < ttlMs) {
+                return cached.data;
+            }
+            const data = await conn.groupMetadata(jid);
+            groupMetaCache.set(jid, { data, fetchedAt: now });
+            return data;
+        },
+        /** drops a single group (or the whole cache if no jid given) from getCachedGroupMetadata's cache */
+        invalidateGroupMetadataCache(jid) {
+            if (jid) {
+                groupMetaCache.delete(jid);
+            }
+            else {
+                groupMetaCache.clear();
+            }
+        },
+        /**
+         * Scans message text for @628xxx-style mentions and returns the jids
+         * it found, so you don't have to write the regex yourself every time
+         * you want to build a mentions-enabled message.
+         *   const mentions = conn.parseMentions('hai @6281234567890 apa kabar')
+         *   conn.sendMessage(jid, { text, mentions })
+         */
+        parseMentions(text) {
+            if (!text) {
+                return [];
+            }
+            const matches = text.match(/@(\d{5,16})/g) || [];
+            return matches.map((m) => `${m.slice(1)}@s.whatsapp.net`);
+        },
+        /**
+         * Normalizes a loosely-formatted phone number into a proper WA jid.
+         * Strips spaces/dashes/plus/parens, and turns a leading "0" into "62"
+         * (change defaultCountryCode if most of your users aren't Indonesian).
+         *   conn.formatJid('0812-3456-7890') -> '6281234567890@s.whatsapp.net'
+         *   conn.formatJid('+62 812 3456 7890') -> '6281234567890@s.whatsapp.net'
+         */
+        formatJid(numberOrJid, defaultCountryCode = '62') {
+            if (!numberOrJid) {
+                return null;
+            }
+            if (numberOrJid.includes('@')) {
+                return numberOrJid;
+            }
+            let digits = numberOrJid.replace(/[^\d]/g, '');
+            if (digits.startsWith('0')) {
+                digits = defaultCountryCode + digits.slice(1);
+            }
+            return `${digits}@s.whatsapp.net`;
+        },
+        /**
+         * Unwraps a view-once message (any version) and returns the real
+         * underlying content (imageMessage/videoMessage/audioMessage), so you
+         * can download/save it before it's gone. Returns null if the message
+         * isn't a view-once wrapper.
+         */
+        extractViewOnce(message) {
+            if (!message) {
+                return null;
+            }
+            const wrapped = message.viewOnceMessage?.message
+                || message.viewOnceMessageV2?.message
+                || message.viewOnceMessageV2Extension?.message
+                || null;
+            if (!wrapped) {
+                return null;
+            }
+            const innerType = Object.keys(wrapped)[0];
+            return { type: innerType, content: wrapped[innerType], message: wrapped };
+        },
+        /**
+         * Downloads whatever media is in a message (image/video/audio/sticker/
+         * document), automatically unwrapping view-once first if needed.
+         * Returns { buffer, type } or null if there's no media to download.
+         */
+        async downloadAnyMedia(message) {
+            let target = message;
+            const unwrapped = (message?.viewOnceMessage?.message)
+                || (message?.viewOnceMessageV2?.message)
+                || (message?.viewOnceMessageV2Extension?.message);
+            if (unwrapped) {
+                target = unwrapped;
+            }
+            const mediaTypes = ['imageMessage', 'videoMessage', 'audioMessage', 'stickerMessage', 'documentMessage', 'documentWithCaptionMessage'];
+            const foundType = mediaTypes.find((t) => target?.[t]);
+            if (!foundType) {
+                return null;
+            }
+            const { downloadMediaMessage } = require('./messages');
+            const buffer = await downloadMediaMessage({ message: target }, 'buffer', {});
+            return { buffer, type: foundType };
+        },
+        /**
+         * Starts auto-tracking votes for a poll you just sent, so you don't have
+         * to manually call getAggregateVotesInPollMessage yourself every time.
+         * `pollMsg` is the message object returned by sendMessage() for a poll.
+         * Returns a live snapshot getter; call .stop() to stop tracking it.
+         */
+        trackPoll(pollMsg) {
+            var _a, _b, _c;
+            const pollMsgId = pollMsg?.key?.id;
+            if (!pollMsgId) {
+                throw new Error('trackPoll: pollMsg.key.id is missing');
+            }
+            const pollCreation = (_c = (_b = (_a = pollMsg.message) === null || _a === void 0 ? void 0 : _a.pollCreationMessage) !== null && _b !== void 0 ? _b : pollMsg.message?.pollCreationMessageV3) !== null && _c !== void 0 ? _c : pollMsg.message?.pollCreationMessageV2;
+            const options = (pollCreation?.options || []).map((o) => o.optionName);
+            const state = { question: pollCreation?.name || '', options, voters: new Map() };
+            pollTallies.set(pollMsgId, state);
+            const onUpdate = (updates) => {
+                for (const { key, update } of updates) {
+                    const pollUpdates = update?.pollUpdates;
+                    if (!pollUpdates || key?.id !== pollMsgId) {
+                        continue;
+                    }
+                    try {
+                        const { getAggregateVotesInPollMessage } = require('./messages');
+                        const tally = getAggregateVotesInPollMessage({ message: pollMsg.message, pollUpdates }, conn.authState?.creds?.me?.id);
+                        state.lastTally = tally;
+                    }
+                    catch (err) {
+                        logger.error({ err }, 'trackPoll: failed to aggregate votes');
+                    }
+                }
+            };
+            conn.ev.on('messages.update', onUpdate);
+            return {
+                getResults: () => state.lastTally || options.map((name) => ({ name, voters: [] })),
+                stop: () => {
+                    conn.ev.off('messages.update', onUpdate);
+                    pollTallies.delete(pollMsgId);
+                }
+            };
+        },
+        /**
+         * One-stop JID inspector: decodes a jid and tells you exactly what
+         * kind of address it is, without having to juggle isJidGroup/isLidUser/
+         * isJidUser/jidDecode yourself every time.
+         */
         resolveJid(jid) {
             var _a;
             const { isJidUser, isLidUser, isJidGroup, isJidBroadcast, isJidStatusBroadcast, isJidNewsLetter, isHostedPnUser, isHostedLidUser, jidDecode: decode } = require('../WABinary');
@@ -57,6 +263,11 @@ const makeBotToolkit = (conn, logger) => {
                 isPn: kind === 'pn' || kind === 'hosted-pn'
             };
         },
+        /**
+         * Returns a one-shot snapshot of the connection's health - useful for a
+         * `.status` style command without having to manually gather state from
+         * five different places.
+         */
         healthCheck() {
             var _a, _b, _c, _d, _e, _f;
             const wsState = (_b = (_a = conn.ws) === null || _a === void 0 ? void 0 : _a.socket) === null || _b === void 0 ? void 0 : _b.readyState;
@@ -71,6 +282,19 @@ const makeBotToolkit = (conn, logger) => {
                 rateLimitBucketsTracked: rateLimitBuckets.size
             };
         },
+        /**
+         * Like `conn.ev.on`, but the handler is isolated: a throw or rejection
+         * is caught & logged instead of bubbling up, and an optional timeout
+         * guards against a handler that hangs forever (e.g. a stuck network
+         * call inside a plugin) from quietly blocking that listener's "lane".
+         *
+         * @param event   event name, e.g. 'messages.upsert'
+         * @param handler (data) => any | Promise<any>
+         * @param opts.timeoutMs  if set, logs a warning if the handler doesn't
+         *                        settle within this time (does NOT kill it -
+         *                        JS can't cancel a running sync/async function -
+         *                        it's a "hey this looks stuck" signal only)
+         */
         onSafe(event, handler, opts = {}) {
             const { timeoutMs } = opts;
             const wrapped = (data) => {
@@ -101,6 +325,12 @@ const makeBotToolkit = (conn, logger) => {
             conn.ev.on(event, wrapped);
             return () => conn.ev.off(event, wrapped);
         },
+        /**
+         * Returns true if this message id has already been seen recently
+         * (within DEDUP_TTL_MS). Marks it as seen either way. Use at the top
+         * of your messages.upsert handler to skip WA's occasional duplicate
+         * delivery (reconnect races etc.) without writing your own cache.
+         */
         isDuplicateMessage(messageId) {
             if (!messageId) {
                 return false;
@@ -113,6 +343,12 @@ const makeBotToolkit = (conn, logger) => {
             }
             return seen;
         },
+        /**
+         * Simple per-(jid, key) cooldown helper. Returns true if the action
+         * is currently rate-limited (i.e. you should NOT proceed), false if
+         * it's OK to go ahead (and marks the timestamp).
+         *   if (conn.isRateLimited(m.chat, 'menu', 5000)) return;
+         */
         isRateLimited(jid, key, windowMs) {
             const bucketKey = `${jid}:${key}`;
             const now = Date.now();
@@ -123,6 +359,19 @@ const makeBotToolkit = (conn, logger) => {
             rateLimitBuckets.set(bucketKey, now);
             return false;
         },
+        /**
+         * Asks an Anthropic model to help debug an error / snippet against
+         * THIS fork's actual Baileys source, so suggestions are grounded in
+         * what's really in your codebase instead of generic upstream advice.
+         * Wire this up to whatever command prefix you like in your own bot
+         * dispatcher (e.g. `.aimahiru`) - this function only does the actual
+         * call + prompt shaping, not command parsing.
+         *
+         * @param input.errorText   the error/stack trace the user is hitting
+         * @param input.code        the snippet of their bot code, if any
+         * @param input.apiKey      Anthropic API key (or set ANTHROPIC_API_KEY env)
+         * @param input.model       defaults to a Haiku-class model for speed/cost
+         */
         async aiMahiru({ errorText, code, apiKey, model = 'claude-haiku-4-5-20251001' }) {
             const key = apiKey || process.env.ANTHROPIC_API_KEY;
             if (!key) {
@@ -162,4 +411,4 @@ const makeBotToolkit = (conn, logger) => {
         }
     };
 };
-exports.makeBotToolkit = makeBotToolkit;
+exports.makeBotToolkit = makeBotToolkit;

package/lib/Utils/decode-wa-message.js

@@ -233,9 +233,45 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
                         }
                     }
                     catch (err) {
-                        logger.error({ key: fullMessage.key, err }, 'failed to decrypt message');
-                        fullMessage.messageStubType = WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT;
-                        fullMessage.messageStubParameters = [err.message];
+                        // self-heal: if decrypt failed using the PN/LID jid we picked,
+                        // and the other identity (LID<->PN) has a session, try that
+                        // before giving up - this recovers automatically from the
+                        // "picked the wrong identity" case without waiting for a
+                        // retry-receipt round-trip.
+                        let healed = false;
+                        if ((attrs.type === 'pkmsg' || attrs.type === 'msg') && (repository === null || repository === void 0 ? void 0 : repository.lidMapping)) {
+                            try {
+                                const altJid = (0, WABinary_1.isLidUser)(decryptionJid)
+                                    ? await repository.lidMapping.getPNForLID(decryptionJid)
+                                    : await repository.lidMapping.getLIDForPN(decryptionJid);
+                                if (altJid && altJid !== decryptionJid) {
+                                    logger.debug({ from: decryptionJid, altJid }, 'decrypt failed, retrying with alternate PN/LID identity');
+                                    const retryBuffer = await repository.decryptMessage({
+                                        jid: altJid,
+                                        type: attrs.type,
+                                        ciphertext: content
+                                    });
+                                    let msg = WAProto_1.proto.Message.decode((0, generics_1.unpadRandomMax16)(retryBuffer));
+                                    msg = ((_a = msg.deviceSentMessage) === null || _a === void 0 ? void 0 : _a.message) || msg;
+                                    await processSenderKeyDistribution(msg);
+                                    if (fullMessage.message) {
+                                        Object.assign(fullMessage.message, msg);
+                                    }
+                                    else {
+                                        fullMessage.message = msg;
+                                    }
+                                    healed = true;
+                                }
+                            }
+                            catch (healErr) {
+                                logger.debug({ healErr }, 'self-heal retry with alternate identity also failed');
+                            }
+                        }
+                        if (!healed) {
+                            logger.error({ key: fullMessage.key, err }, 'failed to decrypt message');
+                            fullMessage.messageStubType = WAProto_1.proto.WebMessageInfo.StubType.CIPHERTEXT;
+                            fullMessage.messageStubParameters = [err.message];
+                        }
                     }
                 }
             }
@@ -247,4 +283,4 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
         }
     };
 };
-exports.decryptMessageNode = decryptMessageNode;
+exports.decryptMessageNode = decryptMessageNode;

package/lib/Utils/generics.js

@@ -32,6 +32,14 @@ exports.Browsers = (browser) => {
     const osRelease = os_1.release();
     return [osName, browser, osRelease];
 };
+// explicit named variants, e.g. Browsers.windows('Chrome') instead of relying
+// on auto-detecting the host OS - useful when you want a stable, specific
+// browser signature regardless of what the bot is actually running on.
+exports.Browsers.ubuntu = (browser) => ['Ubuntu', browser, '22.04.4'];
+exports.Browsers.macOS = (browser) => ['Mac OS', browser, '14.4.1'];
+exports.Browsers.windows = (browser) => ['Windows', browser, '10.0.22631'];
+exports.Browsers.baileys = (browser) => ['Baileys', browser, '6.5.0'];
+exports.Browsers.appropriate = exports.Browsers;
 
 const getPlatformId = (browser) => {
     const platformType = WAProto_1.proto.DeviceProps.PlatformType[browser.toUpperCase()];
@@ -495,4 +503,4 @@ exports.bytesToCrockford = bytesToCrockford;
 const encodeNewsletterMessage = (message) => {
 	return WAProto_1.proto.Message.encode(message).finish()
 }
-exports.encodeNewsletterMessage = encodeNewsletterMessage;
+exports.encodeNewsletterMessage = encodeNewsletterMessage;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@langitdeveloper/baileys",
-    "version": "2.1.9",
+    "version": "2.2.0",
     "description": "WhatsApp API Modification By Langit",
     "keywords": [
         "whatsapp",