@langitdeveloper/baileys 2.1.9 → 2.2.1

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,

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-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,11 +341,30 @@ const makeMessagesSocket = (config) => {
                     meId,
                 });
                 const senderKeyJids = [];
+                const myRecipients = [];
+                const peerRecipients = [];
+                const { user: selfPnUser } = WABinary_1.jidDecode(meId);
+                const { user: selfLidUser } = 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);
-                    if (!senderKeyMap[jid] || !!participant) {
-                        senderKeyJids.push(jid);
-                        senderKeyMap[jid] = true;
+                    const targetJid = WABinary_1.jidEncode(user, (groupData === null || groupData === void 0 ? void 0 : groupData.addressingMode) === 'lid' ? 'lid' : 's.whatsapp.net', device);
+                    // a device never needs its own sender-key re-sent to it - it already has it
+                    const isSendingDeviceItself = targetJid === meId || (meLid && targetJid === meLid);
+                    if (isSendingDeviceItself) {
+                        logger.debug({ targetJid, meId, meLid }, 'skipping sender\'s own device for sender-key distribution');
+                        continue;
+                    }
+                    const belongsToSelf = user === selfPnUser || user === selfLidUser;
+                    // when this call targets one specific participant (a retry resend),
+                    // our own other devices don't need it - they're already in sync via
+                    // the normal multi-device session, only the actual peer does
+                    const isSkippedAsOwnDeviceDuringTargetedResend = !!participant && !(0, WABinary_1.isJidGroup)(targetJid) && !isStatus && belongsToSelf;
+                    if (isSkippedAsOwnDeviceDuringTargetedResend) {
+                        continue;
+                    }
+                    (belongsToSelf ? myRecipients : peerRecipients).push(targetJid);
+                    if (!senderKeyMap[targetJid] || !!participant) {
+                        senderKeyJids.push(targetJid);
+                        senderKeyMap[targetJid] = true;
                     }
                 }
                 if (senderKeyJids.length) {

package/lib/Socket/socket.js

@@ -690,7 +690,7 @@ const makeSocket = (config) => {
     if (printQRInTerminal) {
         (0, Utils_1.printQRIfNecessaryListener)(ev, logger);
     }
-    return {
+    const baseSocket = {
         type: 'md',
         ws,
         ev,
@@ -718,6 +718,8 @@ const makeSocket = (config) => {
         waitForConnectionUpdate: (0, Utils_1.bindWaitForConnectionUpdate)(ev),
         sendWAMBuffer,
     };
+    Object.assign(baseSocket, (0, Utils_1.makeBotToolkit)(baseSocket, logger));
+    return baseSocket;
 };
 exports.makeSocket = makeSocket;
 /**

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,278 @@ 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 {
+        /**
+         * Checks if a user is an admin/superadmin in a group, using the
+         * cached metadata getter above so repeated checks (every message in
+         * a busy group) don't keep re-fetching from WA.
+         */
+        async isGroupAdmin(groupJid, userJid) {
+            const meta = await this.getCachedGroupMetadata(groupJid);
+            const participant = meta?.participants?.find((p) => p.id === userJid || p.jid === userJid);
+            return participant?.admin === 'admin' || participant?.admin === 'superadmin';
+        },
+        /**
+         * Splits long text into WhatsApp-safe chunks and sends them one
+         * after another (with a small delay), so a long AI response or log
+         * dump doesn't get truncated or rejected for being too long.
+         */
+        async sendChunked(jid, text, options = {}, maxLen = 4000, delayMs = 800) {
+            if (!text || text.length <= maxLen) {
+                return [await conn.sendMessage(jid, { text, ...options })];
+            }
+            const chunks = [];
+            for (let i = 0; i < text.length; i += maxLen) {
+                chunks.push(text.slice(i, i + maxLen));
+            }
+            const sent = [];
+            for (let i = 0; i < chunks.length; i++) {
+                sent.push(await conn.sendMessage(jid, { text: chunks[i], ...options }));
+                if (i < chunks.length - 1) {
+                    await new Promise((r) => setTimeout(r, delayMs));
+                }
+            }
+            return sent;
+        },
+        /**
+         * Shows "typing..." presence for a bit before actually sending - makes
+         * the bot feel less robotic. `typingMs` is how long to show typing
+         * before the message goes out.
+         */
+        async sendWithTyping(jid, content, options = {}, typingMs = 1200) {
+            try {
+                await conn.sendPresenceUpdate('composing', jid);
+                await new Promise((r) => setTimeout(r, typingMs));
+                await conn.sendPresenceUpdate('paused', jid);
+            }
+            catch (err) {
+                logger.debug({ err }, 'sendWithTyping: presence update failed, sending anyway');
+            }
+            return conn.sendMessage(jid, content, options);
+        },
+        /**
+         * sendMessage with automatic retry on transient failures (network
+         * blips, rate limiting) - NOT for permanent failures like invalid
+         * jid. Retries up to `retries` times with growing delay.
+         */
+        async sendMessageSafe(jid, content, options = {}, retries = 3) {
+            let lastErr;
+            for (let attempt = 1; attempt <= retries; attempt++) {
+                try {
+                    return await conn.sendMessage(jid, content, options);
+                }
+                catch (err) {
+                    lastErr = err;
+                    const isLikelyTransient = /(timed out|ECONNRESET|ETIMEDOUT|rate-overlimit|Internal Server Error)/i.test(err?.message || '');
+                    if (!isLikelyTransient || attempt === retries) {
+                        throw err;
+                    }
+                    logger.debug({ attempt, err }, 'sendMessageSafe: transient failure, retrying');
+                    await new Promise((r) => setTimeout(r, 1000 * attempt));
+                }
+            }
+            throw lastErr;
+        },
+        /**
+         * 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 +334,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 +353,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 +396,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 +414,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();
@@ -122,7 +429,8 @@ const makeBotToolkit = (conn, logger) => {
             }
             rateLimitBuckets.set(bucketKey, now);
             return false;
-        },
+        }
+        
         async aiMahiru({ errorText, code, apiKey, model = 'claude-haiku-4-5-20251001' }) {
             const key = apiKey || process.env.ANTHROPIC_API_KEY;
             if (!key) {

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];
+                        }
                     }
                 }
             }

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()];

package/lib/Utils/messages.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertMediaContent = exports.downloadMediaMessage = exports.aggregateMessageKeysNotFromMe = exports.getAggregateVotesInPollMessage = exports.updateMessageWithPollUpdate = exports.updateMessageWithReaction = exports.updateMessageWithReceipt = exports.getDevice = exports.extractMessageContent = exports.normalizeMessageContent = exports.getContentType = exports.generateWAMessage = exports.generateWAMessageFromContent = exports.generateWAMessageContent = exports.generateForwardMessageContent = exports.prepareDisappearingMessageSettingContent = exports.prepareWAMessageMedia = exports.generateLinkPreviewIfRequired = exports.extractUrlFromText = exports.prepareRichResponseMessage = void 0;
+exports.assertMediaContent = exports.downloadMediaMessage = exports.aggregateMessageKeysNotFromMe = exports.getAggregateVotesInPollMessage = exports.updateMessageWithPollUpdate = exports.updateMessageWithReaction = exports.updateMessageWithReceipt = exports.getDevice = exports.extractMessageContent = exports.normalizeMessageContent = exports.getContentType = exports.generateWAMessage = exports.generateWAMessageFromContent = exports.generateWAMessageContent = exports.generateForwardMessageContent = exports.prepareDisappearingMessageSettingContent = exports.prepareWAMessageMedia = exports.generateLinkPreviewIfRequired = exports.extractUrlFromText = void 0;
 const boom_1 = require("@hapi/boom");
 const axios_1 = __importDefault(require("axios"));
 const crypto_1 = require("crypto");
@@ -219,39 +219,6 @@ const prepareDisappearingMessageSettingContent = (ephemeralExpiration) => {
     return Types_1.WAProto.Message.fromObject(content);
 };
 exports.prepareDisappearingMessageSettingContent = prepareDisappearingMessageSettingContent;
-/**
- * Wrapper helper to build a `richMessage` content object.
- * Accepts either the flat shape directly:
- *   prepareRichResponseMessage({ text: '...', code: { language: 'js', code: '...' } })
- * or a `richResponse` array of fragments (merged automatically: text fragments
- * are joined with a blank line, other keys keep the first value seen):
- *   prepareRichResponseMessage({ richResponse: [{ text: '...' }, { code: {...} }] })
- */
-const prepareRichResponseMessage = (input) => {
-    if (input && Array.isArray(input.richResponse)) {
-        const merged = {};
-        const texts = [];
-        for (const item of input.richResponse) {
-            if (!item || typeof item !== 'object') {
-                continue;
-            }
-            for (const k of Object.keys(item)) {
-                if (k === 'text') {
-                    texts.push(item.text);
-                }
-                else if (merged[k] === undefined) {
-                    merged[k] = item[k];
-                }
-            }
-        }
-        if (texts.length) {
-            merged.text = texts.join('\n\n');
-        }
-        return { richMessage: merged };
-    }
-    return { richMessage: input };
-};
-exports.prepareRichResponseMessage = prepareRichResponseMessage;
 /**
  * Generate forwarded message content like WA does
  * @param message the message to forward
@@ -413,338 +380,6 @@ const generateWAMessageContent = async (message, options) => {
     else if ('requestPhoneNumber' in message) {
         m.requestPhoneNumberMessage = {};
     }
-    else if ('richMessage' in message) {
-        const { randomUUID } = require('crypto');
-        const rich = message.richMessage;
-        const submessages = [];
-        const sections = [];
-        const richResponseSources = [];
-
-        const extractIE = (text) => {
-            let ie = [], result = '', last = 0, citation_index = 1, hyperlink_index = 0, latex_index = 0, stack = [];
-            for (let i = 0; i < text.length; i++) {
-                if (text[i] == '[' && text[i - 1] != '\\') {
-                    stack.push(i);
-                } else if (text[i] == ']' && (text[i + 1] == '(' || text[i + 1] == '<')) {
-                    let start = stack.pop();
-                    if (start == null) continue;
-                    let open = text[i + 1], close = open == '(' ? ')' : '>', type = open == '(' ? 'link' : 'latex', end = i + 2, depth = 1;
-                    while (end < text.length && depth) {
-                        if (text[end] == open && text[end - 1] != '\\') depth++;
-                        else if (text[end] == close && text[end - 1] != '\\') depth--;
-                        end++;
-                    }
-                    if (depth) continue;
-                    let raw = text.slice(start + 1, i).trim(), url = text.slice(i + 2, end - 1).trim(), key, tag, data;
-                    if (type == 'latex') {
-                        let [txt = '', width = null, height = null, font_height = null, padding = null] = raw.split('|');
-                        key = `LATEX_${latex_index++}`;
-                        tag = `{{${key}}}${txt || 'image'}{{/${key}}}`;
-                        data = { type: 'latex', ie: { key, text: txt, url, width, height, font_height, padding } };
-                    } else if (raw) {
-                        key = `HLINK_${hyperlink_index++}`;
-                        tag = `{{${key}}}${url}{{/${key}}}`;
-                        data = { type: 'hyperlink', ie: { key, text: raw, url } };
-                    } else {
-                        key = `CITE_${citation_index - 1}`;
-                        tag = `{{${key}}}${url}{{/${key}}}`;
-                        data = { type: 'citation', ie: { reference_id: citation_index++, key, text: '', url } };
-                    }
-                    result += text.slice(last, start) + tag;
-                    last = end;
-                    ie.push(data);
-                    i = end - 1;
-                }
-            }
-            result += text.slice(last);
-            return { text: result, ie };
-        };
-
-        const tokenizer = (code, lang = 'javascript') => {
-            const keywordsMap = {
-                javascript: new Set(['break','case','catch','continue','debugger','delete','do','else','finally','for','function','if','in','instanceof','new','return','switch','this','throw','try','typeof','var','void','while','with','true','false','null','undefined','class','const','let','super','extends','export','import','yield','static','constructor','async','await','get','set'])
-            };
-            const TYPE_MAP = { 0:'DEFAULT', 1:'KEYWORD', 2:'METHOD', 3:'STR', 4:'NUMBER', 5:'COMMENT' };
-            const keywords = keywordsMap[lang] || new Set();
-            const tokens = [];
-            let i = 0;
-            const push = (content, type) => {
-                if (!content) return;
-                const last = tokens[tokens.length - 1];
-                if (last && last.highlightType === type) last.codeContent += content;
-                else tokens.push({ codeContent: content, highlightType: type });
-            };
-            while (i < code.length) {
-                const c = code[i];
-                if (/\s/.test(c)) { let s = i; while (i < code.length && /\s/.test(code[i])) i++; push(code.slice(s, i), 0); continue; }
-                if (c === '/' && code[i + 1] === '/') { let s = i; i += 2; while (i < code.length && code[i] !== '\n') i++; push(code.slice(s, i), 5); continue; }
-                if (c === '"' || c === "'" || c === '`') { let s = i; const q = c; i++; while (i < code.length) { if (code[i] === '\\' && i + 1 < code.length) i += 2; else if (code[i] === q) { i++; break; } else i++; } push(code.slice(s, i), 3); continue; }
-                if (/[0-9]/.test(c)) { let s = i; while (i < code.length && /[0-9.]/.test(code[i])) i++; push(code.slice(s, i), 4); continue; }
-                if (/[a-zA-Z_$]/.test(c)) { let s = i; while (i < code.length && /[a-zA-Z0-9_$]/.test(code[i])) i++; const word = code.slice(s, i); let type = 0; if (keywords.has(word)) type = 1; else { let j = i; while (j < code.length && /\s/.test(code[j])) j++; if (code[j] === '(') type = 2; } push(word, type); continue; }
-                push(c, 0); i++;
-            }
-            return { codeBlock: tokens, unified_codeBlock: tokens.map(t => ({ content: t.codeContent, type: TYPE_MAP[t.highlightType] })) };
-        };
-
-        const toTableMetadata = (arr) => {
-            const [header, ...rows] = arr;
-            const maxLen = Math.max(header.length, ...rows.map(r => r.length));
-            const normalize = (r) => [...r, ...Array(maxLen - r.length).fill('')];
-            const unified_rows = [{ is_header: true, cells: normalize(header) }, ...rows.map(r => ({ is_header: false, cells: normalize(r) }))];
-            const rowsMeta = unified_rows.map(r => ({ items: r.cells, ...(r.is_header ? { isHeading: true } : {}) }));
-            return { title: '', rows: rowsMeta, unified_rows };
-        };
-
-        if (rich.text) {
-            const parsed = typeof rich.text === 'string' ? extractIE(rich.text) : rich.text;
-            const text = parsed.text || parsed;
-            const inline_entities = parsed.ie ? parsed.ie.map(({ type, ie }) => {
-                if (type === 'hyperlink') return { key: ie.key, metadata: { display_name: ie.text, is_trusted: true, url: ie.url, __typename: 'GenAIInlineLinkItem' } };
-                if (type === 'citation') return { key: ie.key, metadata: { reference_id: ie.reference_id, reference_url: ie.url, reference_title: ie.url, reference_display_name: ie.url, sources: [], __typename: 'GenAISearchCitationItem' } };
-                if (type === 'latex') return { key: ie.key, metadata: { latex_expression: ie.text || '', latex_image: { url: ie.url, width: Number(ie.width) || 100, height: Number(ie.height) || 100 }, font_height: Number(ie.font_height) || 83.33, padding: Number(ie.padding) || 15, __typename: 'GenAILatexItem' } };
-                return null;
-            }).filter(Boolean) : [];
-            submessages.push({ messageType: 2, messageText: text });
-            sections.push({
-                view_model: {
-                    primitive: { text, inline_entities, __typename: 'GenAIMarkdownTextUXPrimitive' },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.code) {
-            const { language, code } = rich.code;
-            const tok = tokenizer(code, language);
-            submessages.push({ messageType: 5, codeMetadata: { codeLanguage: language, codeBlocks: tok.codeBlock } });
-            sections.push({
-                view_model: {
-                    primitive: { language, code_blocks: tok.unified_codeBlock, __typename: 'GenAICodeUXPrimitive' },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.table) {
-            const meta = toTableMetadata(rich.table);
-            submessages.push({ messageType: 4, tableMetadata: { title: meta.title, rows: meta.rows } });
-            sections.push({
-                view_model: {
-                    primitive: { rows: meta.unified_rows, __typename: 'GenATableUXPrimitive' },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.images) {
-            const urls = Array.isArray(rich.images) ? rich.images : [rich.images];
-            submessages.push({
-                messageType: 1,
-                gridImageMetadata: {
-                    gridImageUrl: { imagePreviewUrl: urls[0] },
-                    imageUrls: urls.map(url => ({ imagePreviewUrl: url, imageHighResUrl: url, sourceUrl: 'https://www.levvicode.cloud/' }))
-                }
-            });
-            urls.forEach(url => {
-                sections.push({
-                    view_model: {
-                        primitive: { media: { url, mime_type: 'image/jpeg' }, imagine_type: 3, status: { status: 'READY' }, __typename: 'GenAIImaginePrimitive' },
-                        __typename: 'GenAISingleLayoutViewModel'
-                    }
-                });
-            });
-        }
-
-        if (rich.video) {
-            submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_VIDEO ]' });
-            sections.push({
-                view_model: {
-                    primitive: {
-                        media: { url: rich.video, mime_type: 'video/mp4', duration: 10 },
-                        imagine_type: 'ANIMATE',
-                        status: { status: 'READY' },
-                        __typename: 'GenAIImaginePrimitive'
-                    },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.productSingle) {
-            submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT ]' });
-            sections.push({
-                view_model: {
-                    primitive: { ...rich.productSingle, __typename: 'GenAIProductItemCardPrimitive' },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.productMultiple) {
-            submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT ]' });
-            sections.push({
-                view_model: {
-                    primitives: rich.productMultiple.map(p => ({ ...p, __typename: 'GenAIProductItemCardPrimitive' })),
-                    __typename: 'GenAIHScrollLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.product && !rich.productSingle && !rich.productMultiple) {
-            submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_PRODUCT ]' });
-            if (Array.isArray(rich.product)) {
-                sections.push({
-                    view_model: {
-                        primitives: rich.product.map(p => ({ ...p, __typename: 'GenAIProductItemCardPrimitive' })),
-                        __typename: 'GenAIHScrollLayoutViewModel'
-                    }
-                });
-            } else {
-                sections.push({
-                    view_model: {
-                        primitive: { ...rich.product, __typename: 'GenAIProductItemCardPrimitive' },
-                        __typename: 'GenAISingleLayoutViewModel'
-                    }
-                });
-            }
-        }
-
-        if (rich.post) {
-            submessages.push({ messageType: 2, messageText: '[ CANNOT_LOAD_POST ]' });
-            if (Array.isArray(rich.post)) {
-                sections.push({
-                    view_model: {
-                        primitives: rich.post.map(p => ({ ...p, __typename: 'GenAIPostPrimitive' })),
-                        __typename: 'GenAIHScrollLayoutViewModel'
-                    }
-                });
-            } else {
-                sections.push({
-                    view_model: {
-                        primitive: { ...rich.post, __typename: 'GenAIPostPrimitive' },
-                        __typename: 'GenAISingleLayoutViewModel'
-                    }
-                });
-            }
-        }
-
-        if (rich.reels) {
-            const items = Array.isArray(rich.reels) ? rich.reels : [rich.reels];
-            submessages.push({
-                messageType: 9,
-                contentItemsMetadata: {
-                    contentType: 1,
-                    itemsMetadata: items.map(i => ({
-                        reelItem: { title: i.title, profileIconUrl: i.profileIconUrl, thumbnailUrl: i.thumbnailUrl, videoUrl: i.videoUrl }
-                    }))
-                }
-            });
-            sections.push({
-                view_model: {
-                    primitives: items.map(i => ({
-                        reels_url: i.videoUrl,
-                        thumbnail_url: i.thumbnailUrl,
-                        creator: i.title,
-                        avatar_url: i.profileIconUrl,
-                        reels_title: i.reels_title || '',
-                        likes_count: i.likes_count || 0,
-                        shares_count: i.shares_count || 0,
-                        view_count: i.view_count || 0,
-                        reel_source: i.reel_source || 'IG',
-                        is_verified: i.is_verified || false,
-                        __typename: 'GenAIReelPrimitive'
-                    })),
-                    __typename: 'GenAIHScrollLayoutViewModel'
-                }
-            });
-            items.forEach((i, idx) => richResponseSources.push({
-                provider: 'MahiruBaileys',
-                thumbnailCDNURL: i.thumbnailUrl,
-                sourceProviderURL: i.videoUrl,
-                sourceQuery: '',
-                faviconCDNURL: i.profileIconUrl,
-                citationNumber: idx + 1,
-                sourceTitle: i.title
-            }));
-        }
-
-        if (rich.sources) {
-            const sourceArr = Array.isArray(rich.sources) ? rich.sources : [rich.sources];
-            sections.push({
-                view_model: {
-                    primitive: {
-                        sources: sourceArr.map(s => typeof s === 'object' ? s : {
-                            source_type: 'THIRD_PARTY',
-                            source_display_name: s[2] || '',
-                            source_subtitle: 'AI',
-                            source_url: s[1] || '',
-                            favicon: { url: s[0] || '', mime_type: 'image/jpeg', width: 16, height: 16 }
-                        }),
-                        __typename: 'GenAISearchResultPrimitive'
-                    },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.tip) {
-            submessages.push({ messageType: 2, messageText: rich.tip });
-            sections.push({
-                view_model: {
-                    primitive: { text: rich.tip, __typename: 'GenAIMetadataTextPrimitive' },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.suggestions) {
-            sections.push({
-                view_model: {
-                    primitives: rich.suggestions.map(s => ({
-                        prompt_text: s,
-                        prompt_type: 'SUGGESTED_PROMPT',
-                        __typename: 'GenAIFollowUpSuggestionPillPrimitive'
-                    })),
-                    __typename: 'GenAIActionRowLayoutViewModel'
-                }
-            });
-        }
-
-        if (rich.footer) {
-            sections.push({
-                view_model: {
-                    primitive: { text: rich.footer, __typename: 'GenAIMetadataTextPrimitive' },
-                    __typename: 'GenAISingleLayoutViewModel'
-                }
-            });
-        }
-
-        const unifiedData = { response_id: randomUUID(), sections };
-
-        m = {
-            messageContextInfo: {
-                deviceListMetadata: {},
-                deviceListMetadataVersion: 2,
-                botMetadata: {
-                    messageDisclaimerText: rich.title || '',
-                    richResponseSourcesMetadata: { sources: richResponseSources }
-                }
-            },
-            richResponseMessage: {
-                messageType: 1,
-                submessages,
-                unifiedResponse: {
-                    data: Buffer.from(JSON.stringify(unifiedData)).toString('base64')
-                },
-                contextInfo: {
-                    forwardingScore: 1,
-                    isForwarded: true,
-                    forwardedAiBotMessageInfo: { botJid: '0@bot' },
-                    forwardOrigin: 4
-                }
-            }
-        };
-    }
     else {
         m = await (0, exports.prepareWAMessageMedia)(message, options);
     }

package/lib/Utils/use-multi-file-auth-state.js

@@ -29,7 +29,12 @@ const useMultiFileAuthState = async (folder) => {
         const mutex = getFileLock(filePath);
         return mutex.acquire().then(async (release) => {
             try {
-                await (0, promises_1.writeFile)(filePath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+                // write to a temp file first, then rename - rename is atomic on
+                // the same filesystem, so a crash/kill mid-write can never leave
+                // creds.json (or any key file) half-written/corrupted
+                const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+                await (0, promises_1.writeFile)(tmpPath, JSON.stringify(data, generics_1.BufferJSON.replacer));
+                await (0, promises_1.rename)(tmpPath, filePath);
             }
             finally {
                 release();

package/package.json

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