@nexustechpro/baileys 2.0.2 → 2.0.6

package/lib/Utils/history.js

@@ -1,84 +1,92 @@
-import { promisify } from 'util';
-import { inflate } from 'zlib';
-import { proto } from '../../WAProto/index.js';
-import { WAMessageStubType } from '../Types/index.js';
-import { toNumber } from './generics.js';
-import { normalizeMessageContent } from './messages.js';
-import { downloadContentFromMessage } from './messages-media.js';
-const inflatePromise = promisify(inflate);
-export const downloadHistory = async (msg, options) => {
-    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
-    const bufferArray = [];
-    for await (const chunk of stream) {
-        bufferArray.push(chunk);
-    }
-    let buffer = Buffer.concat(bufferArray);
-    // decompress buffer
-    buffer = await inflatePromise(buffer);
-    const syncData = proto.HistorySync.decode(buffer);
-    return syncData;
-};
-export const processHistoryMessage = (item) => {
-    const messages = [];
-    const contacts = [];
-    const chats = [];
-    switch (item.syncType) {
-        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
-        case proto.HistorySync.HistorySyncType.RECENT:
-        case proto.HistorySync.HistorySyncType.FULL:
-        case proto.HistorySync.HistorySyncType.ON_DEMAND:
-            for (const chat of item.conversations) {
-                contacts.push({
-                    id: chat.id,
-                    name: chat.name || undefined,
-                    lid: chat.lidJid || undefined,
-                    phoneNumber: chat.pnJid || undefined
-                });
-                const msgs = chat.messages || [];
-                delete chat.messages;
-                for (const item of msgs) {
-                    const message = item.message;
-                    messages.push(message);
-                    if (!chat.messages?.length) {
-                        // keep only the most recent message in the chat array
-                        chat.messages = [{ message }];
-                    }
-                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
-                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
-                    }
-                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
-                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
-                        message.messageStubParameters?.[0]) {
-                        contacts.push({
-                            id: message.key.participant || message.key.remoteJid,
-                            verifiedName: message.messageStubParameters?.[0]
-                        });
-                    }
-                }
-                chats.push({ ...chat });
-            }
-            break;
-        case proto.HistorySync.HistorySyncType.PUSH_NAME:
-            for (const c of item.pushnames) {
-                contacts.push({ id: c.id, notify: c.pushname });
-            }
-            break;
-    }
-    return {
-        chats,
-        contacts,
-        messages,
-        syncType: item.syncType,
-        progress: item.progress
-    };
-};
-export const downloadAndProcessHistorySyncNotification = async (msg, options) => {
-    const historyMsg = await downloadHistory(msg, options);
-    return processHistoryMessage(historyMsg);
-};
-export const getHistoryMsg = (message) => {
-    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
-    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
-    return anyHistoryMsg;
-};
+import { promisify } from 'util';
+import { inflate } from 'zlib';
+import { proto } from '../../WAProto/index.js';
+import { WAMessageStubType } from '../Types/index.js';
+import { isJidUser } from '../WABinary/index.js';
+import { toNumber } from './generics.js';
+import { normalizeMessageContent } from './messages.js';
+import { downloadContentFromMessage } from './messages-media.js';
+const inflatePromise = promisify(inflate);
+export const downloadHistory = async (msg, options) => {
+    const stream = await downloadContentFromMessage(msg, 'md-msg-hist', { options });
+    const bufferArray = [];
+    for await (const chunk of stream) {
+        bufferArray.push(chunk);
+    }
+    let buffer = Buffer.concat(bufferArray);
+    // decompress buffer
+    buffer = await inflatePromise(buffer);
+    const syncData = proto.HistorySync.decode(buffer);
+    return syncData;
+};
+export const processHistoryMessage = (item) => {
+    const messages = [];
+    const contacts = [];
+    const chats = [];
+    switch (item.syncType) {
+        case proto.HistorySync.HistorySyncType.INITIAL_BOOTSTRAP:
+        case proto.HistorySync.HistorySyncType.RECENT:
+        case proto.HistorySync.HistorySyncType.FULL:
+        case proto.HistorySync.HistorySyncType.ON_DEMAND:
+            for (const chat of item.conversations) {
+                contacts.push({
+                    id: chat.id,
+                    name: chat.name || undefined,
+                    lid: chat.lidJid || undefined,
+                    phoneNumber: chat.pnJid || undefined,
+                    jid: isJidUser(chat.id) ? chat.id : undefined
+                });
+                const msgs = chat.messages || [];
+                delete chat.messages;
+                delete chat.archived;
+                delete chat.muteEndTime;
+                delete chat.pinned;
+                for (const item of msgs) {
+                    const message = item.message;
+                    messages.push(message);
+                    if (!chat.messages?.length) {
+                        // keep only the most recent message in the chat array
+                        chat.messages = [{ message }];
+                    }
+                    if (!message.key.fromMe && !chat.lastMessageRecvTimestamp) {
+                        chat.lastMessageRecvTimestamp = toNumber(message.messageTimestamp);
+                    }
+                    if ((message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_BSP ||
+                        message.messageStubType === WAMessageStubType.BIZ_PRIVACY_MODE_TO_FB) &&
+                        message.messageStubParameters?.[0]) {
+                        contacts.push({
+                            id: message.key.participant || message.key.remoteJid,
+                            verifiedName: message.messageStubParameters?.[0]
+                        });
+                    }
+                }
+                if (isJidUser(chat.id) && chat.readOnly && chat.archived) {
+                    delete chat.readOnly;
+                }
+                chats.push({ ...chat });
+            }
+            break;
+        case proto.HistorySync.HistorySyncType.PUSH_NAME:
+            for (const c of item.pushnames) {
+                contacts.push({ id: c.id, notify: c.pushname });
+            }
+            break;
+    }
+    return {
+        chats,
+        contacts,
+        messages,
+        syncType: item.syncType,
+        progress: item.progress
+    };
+};
+export const downloadAndProcessHistorySyncNotification = async (msg, options) => {
+    const historyMsg = await downloadHistory(msg, options);
+    return processHistoryMessage(historyMsg);
+};
+export const getHistoryMsg = (message) => {
+    const normalizedContent = !!message ? normalizeMessageContent(message) : undefined;
+    const anyHistoryMsg = normalizedContent?.protocolMessage?.historySyncNotification;
+    return anyHistoryMsg;
+};
 //# sourceMappingURL=history.js.map

package/lib/Utils/index.js

@@ -1,21 +1,26 @@
-export * from './generics.js';
-export * from './decode-wa-message.js';
-export * from './messages.js';
-export * from './messages-media.js';
-export * from './validate-connection.js';
-export * from './crypto.js';
-export * from './signal.js';
-export * from './noise-handler.js';
-export * from './history.js';
-export * from './chat-utils.js';
-export * from './lt-hash.js';
-export * from './auth-utils.js';
-export * from './baileys-event-stream.js';
-export * from './use-multi-file-auth-state.js';
-export * from './link-preview.js';
-export * from './event-buffer.js';
-export * from './process-message.js';
-export * from './message-retry-manager.js';
-export * from './browser-utils.js';
-export * from './identity-chnage-handler.js';
+export * from './generics.js';
+export * from './decode-wa-message.js';
+export * from './messages.js';
+export * from './messages-media.js';
+export * from './validate-connection.js';
+export * from './crypto.js';
+export * from './signal.js';
+export * from './make-mutex.js';
+export * from './noise-handler.js';
+export * from './history.js';
+export * from './chat-utils.js';
+export * from './lt-hash.js';
+export * from './auth-utils.js';
+export * from './baileys-event-stream.js';
+export * from './use-multi-file-auth-state.js';
+export * from './link-preview.js';
+export * from './event-buffer.js';
+export * from './process-message.js';
+export * from './message-retry-manager.js';
+export * from './browser-utils.js';
+export * from './identity-chnage-handler.js';
+export * from './key-store.js';
+export * from './reporting-utils.js';
+export * from './companion-reg-client-utils.js';
+export * from './tc-token-utils.js';
 //# sourceMappingURL=index.js.map

package/lib/Utils/key-store.js

@@ -0,0 +1,17 @@
+// ─── Key Store Helpers ─────────────────────────────────────────────────────────
+// Single source of truth for blob key names — change here, changes everywhere
+export const SESSION_INDEX_KEY = 'index'
+export const DEVICE_LIST_INDEX_KEY = 'index'
+
+// Migrates old _index blob to new index key in-place, returns the batch data
+export const migrateIndexKey = async (keys, type) => {
+    const oldKey = '_index'
+    const newKey = 'index'
+    const oldData = await keys.get(type, [oldKey])
+    if (oldData?.[oldKey] && typeof oldData[oldKey] === 'object') { // only migrate if old blob actually exists and has data
+        await keys.set({ [type]: { [newKey]: oldData[oldKey], [oldKey]: null } })
+        return oldData[oldKey]
+    }
+    const newData = await keys.get(type, [newKey])
+    return newData?.[newKey] || {}
+}

package/lib/Utils/link-preview.js

@@ -1,99 +1,108 @@
-import { prepareWAMessageMedia } from './messages.js';
-import { extractImageThumb, getHttpStream } from './messages-media.js';
-const THUMBNAIL_WIDTH_PX = 192;
-/** Fetches an image and generates a thumbnail for it */
-const getCompressedJpegThumbnail = async (url, { thumbnailWidth, fetchOpts }) => {
-    const stream = await getHttpStream(url, fetchOpts);
-    const result = await extractImageThumb(stream, thumbnailWidth);
-    return result;
-};
-/**
- * Given a piece of text, checks for any URL present, generates link preview for the same and returns it
- * Return undefined if the fetch failed or no URL was found
- * @param text first matched URL in text
- * @returns the URL info required to generate link preview
- */
-export const getUrlInfo = async (text, opts = {
-    thumbnailWidth: THUMBNAIL_WIDTH_PX,
-    fetchOpts: { timeout: 3000 }
-}) => {
-    try {
-        // Fix 1: use let so retries can actually increment
-        let retries = 0
-        const maxRetry = 5
-        const { getLinkPreview } = await import('link-preview-js')
-        let previewLink = text
-        if (!text.startsWith('https://') && !text.startsWith('http://')) {
-            previewLink = 'https://' + previewLink
-        }
-        const info = await getLinkPreview(previewLink, {
-            ...opts.fetchOpts,
-            followRedirects: 'follow',
-            handleRedirects: (baseURL, forwardedURL) => {
-                const urlObj = new URL(baseURL)
-                const forwardedURLObj = new URL(forwardedURL)
-                if (retries >= maxRetry) return false
-                if (
-                    forwardedURLObj.hostname === urlObj.hostname ||
-                    forwardedURLObj.hostname === 'www.' + urlObj.hostname ||
-                    'www.' + forwardedURLObj.hostname === urlObj.hostname
-                ) {
-                    retries += 1  // Fix 1: actually increment
-                    return true
-                }
-                return false
-            },
-            headers: opts.fetchOpts?.headers
-        })
-
-        if (info && 'title' in info && info.title) {
-            const [image] = info.images
-            const urlInfo = {
-                'canonical-url': info.url,
-                'matched-text': text,
-                title: info.title,
-                description: info.description,
-                originalThumbnailUrl: image
-            }
-
-            if (opts.uploadImage) {
-                try {
-                    const { imageMessage } = await prepareWAMessageMedia({ image: { url: image } }, {
-                        upload: opts.uploadImage,
-                        mediaTypeOverride: 'thumbnail-link',
-                        options: opts.fetchOpts
-                    })
-                    urlInfo.jpegThumbnail = imageMessage?.jpegThumbnail
-                        ? Buffer.from(imageMessage.jpegThumbnail)
-                        : undefined
-                    urlInfo.highQualityThumbnail = imageMessage || undefined
-                } catch (error) {
-                    opts.logger?.warn({ err: error.message, url: image }, 'failed to upload link preview thumbnail, falling back to compressed')
-                    // Fix 2: fallback to compressed thumbnail instead of giving up entirely
-                    try {
-                        urlInfo.jpegThumbnail = image
-                            ? (await getCompressedJpegThumbnail(image, opts)).buffer
-                            : undefined
-                    } catch (fallbackErr) {
-                        opts.logger?.debug({ err: fallbackErr.stack }, 'fallback thumbnail also failed')
-                    }
-                }
-            } else {
-                try {
-                    urlInfo.jpegThumbnail = image
-                        ? (await getCompressedJpegThumbnail(image, opts)).buffer
-                        : undefined
-                } catch (error) {
-                    opts.logger?.debug({ err: error.stack, url: previewLink }, 'error in generating thumbnail')
-                }
-            }
-
-            return urlInfo
-        }
-    } catch (error) {
-        if (!error.message.includes('receive a valid')) {
-            throw error
-        }
-    }
-}
+import { promises as dnsPromises } from 'dns'
+import { getLinkPreview } from 'link-preview-js'
+import { prepareWAMessageMedia } from './messages.js'
+import { extractImageThumb, getHttpStream } from './messages-media.js'
+
+const THUMBNAIL_WIDTH_PX = 192
+const MAX_REDIRECTS = 5
+const PREVIEW_TIMEOUT = 5000
+// Concurrency pool — max simultaneous link preview fetches
+const MAX_CONCURRENT = 20
+let _active = 0
+const _queue = []
+const _drain = () => {
+    if (_queue.length === 0 || _active >= MAX_CONCURRENT) return
+    _active++
+    const { fn, resolve, reject } = _queue.shift()
+    fn().then(resolve).catch(reject).finally(() => { _active--; _drain() })
+}
+const _enqueue = fn => new Promise((resolve, reject) => { _queue.push({ fn, resolve, reject }); _drain() })
+
+/** Fetches a remote image and compresses it to a JPEG thumbnail buffer */
+const _compressedThumb = async (url, opts) => {
+    const stream = await getHttpStream(url, opts.fetchOpts)
+    const result = await extractImageThumb(stream, opts.thumbnailWidth ?? THUMBNAIL_WIDTH_PX)
+    return result.buffer
+}
+
+/** Resolves jpegThumbnail + highQualityThumbnail from an image URL, never throws */
+const _resolveThumbnail = async (image, opts) => {
+    if (!image) return {}
+    if (opts.uploadImage) {
+        try {
+            const { imageMessage } = await prepareWAMessageMedia(
+                { image: { url: image } },
+                { upload: opts.uploadImage, mediaTypeOverride: 'thumbnail-link', options: opts.fetchOpts }
+            )
+            return {
+                jpegThumbnail: imageMessage?.jpegThumbnail ? Buffer.from(imageMessage.jpegThumbnail) : undefined,
+                highQualityThumbnail: imageMessage ?? undefined
+            }
+        } catch (err) {
+            opts.logger?.warn({ err: err.message, url: image }, 'upload failed, falling back to compressed thumb')
+        }
+    }
+    // Fallback: local compression (also used when no uploadImage provided)
+    try {
+        return { jpegThumbnail: await _compressedThumb(image, opts) }
+    } catch (err) {
+        opts.logger?.debug({ err: err.stack }, 'compressed thumb failed')
+        return {}
+    }
+}
+
+/**
+ * Extracts link preview info from a text string or URL.
+ * Queued for concurrency control — never throws on preview failure.
+ * @param {string} text - Raw text or URL to preview
+ * @param {object} opts - Options: thumbnailWidth, fetchOpts, uploadImage, logger
+ * @returns {Promise<object|undefined>} urlInfo or undefined if no valid URL/title found
+ */
+export const getUrlInfo = (text, opts = {}) => _enqueue(async () => {
+    const fetchOpts = opts.fetchOpts ?? { timeout: PREVIEW_TIMEOUT }
+    const thumbnailWidth = opts.thumbnailWidth ?? THUMBNAIL_WIDTH_PX
+    const resolvedOpts = { ...opts, fetchOpts, thumbnailWidth }
+    try {
+        let retries = 0
+        const previewLink = (text.startsWith('https://') || text.startsWith('http://')) ? text : 'https://' + text
+        const info = await getLinkPreview(previewLink, {
+            ...fetchOpts,
+            followRedirects: 'manual',
+            handleRedirects: (baseURL, forwardedURL) => {
+                if (retries >= MAX_REDIRECTS) return false
+                const base = new URL(baseURL)
+                const fwd = new URL(forwardedURL)
+                const sameHost = fwd.hostname === base.hostname || fwd.hostname === 'www.' + base.hostname || 'www.' + fwd.hostname === base.hostname
+                if (sameHost) { retries++; return true }
+                return false
+            },
+            resolveDNSHost: async (url) => {
+                const hostname = new URL(url).hostname
+                try {
+                    const { address } = await dnsPromises.lookup(hostname)
+                    return address
+                } catch {
+                    return hostname
+                }
+            },
+            headers: fetchOpts.headers
+        })
+        if (!info || !('title' in info) || !info.title) return undefined
+        const [image] = info.images ?? []
+        const thumbs = await _resolveThumbnail(image, resolvedOpts)
+        return {
+            'canonical-url': info.url,
+            'matched-text': text,
+            title: info.title,
+            description: info.description,
+            originalThumbnailUrl: image,
+            ...thumbs
+        }
+    } catch (err) {
+        // Suppress "no valid URL" and missing module errors; re-throw everything else
+        if (!err.message?.includes('receive a valid') && err.code !== 'ERR_MODULE_NOT_FOUND' && err.code !== 'MODULE_NOT_FOUND') {
+            throw err
+        }
+    }
+})
 //# sourceMappingURL=link-preview.js.map

package/lib/Utils/logger.js

@@ -1,3 +1,3 @@
-import P from 'pino';
-export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
 //# sourceMappingURL=logger.js.map

package/lib/Utils/lt-hash.js

@@ -1,48 +1,48 @@
-import { hkdf } from './crypto.js';
-/**
- * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
- * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
- * if the same series of mutations was made sequentially.
- */
-const o = 128;
-class LTHash {
-    constructor(e) {
-        this.salt = e;
-    }
-    async add(e, t) {
-        for (const item of t) {
-            e = await this._addSingle(e, item);
-        }
-        return e;
-    }
-    async subtract(e, t) {
-        for (const item of t) {
-            e = await this._subtractSingle(e, item);
-        }
-        return e;
-    }
-    async subtractThenAdd(e, addList, subtractList) {
-        const subtracted = await this.subtract(e, subtractList);
-        return this.add(subtracted, addList);
-    }
-    async _addSingle(e, t) {
-        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
-    }
-    async _subtractSingle(e, t) {
-        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
-        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
-    }
-    performPointwiseWithOverflow(e, t, op) {
-        const n = new DataView(e);
-        const i = new DataView(t);
-        const out = new ArrayBuffer(n.byteLength);
-        const s = new DataView(out);
-        for (let offset = 0; offset < n.byteLength; offset += 2) {
-            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
-        }
-        return out;
-    }
-}
-export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');
+import { hkdf } from './crypto.js';
+/**
+ * LT Hash is a summation based hash algorithm that maintains the integrity of a piece of data
+ * over a series of mutations. You can add/remove mutations and it'll return a hash equal to
+ * if the same series of mutations was made sequentially.
+ */
+const o = 128;
+class LTHash {
+    constructor(e) {
+        this.salt = e;
+    }
+    async add(e, t) {
+        for (const item of t) {
+            e = await this._addSingle(e, item);
+        }
+        return e;
+    }
+    async subtract(e, t) {
+        for (const item of t) {
+            e = await this._subtractSingle(e, item);
+        }
+        return e;
+    }
+    async subtractThenAdd(e, addList, subtractList) {
+        const subtracted = await this.subtract(e, subtractList);
+        return this.add(subtracted, addList);
+    }
+    async _addSingle(e, t) {
+        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a + b);
+    }
+    async _subtractSingle(e, t) {
+        const derived = new Uint8Array(hkdf(Buffer.from(t), o, { info: this.salt })).buffer;
+        return this.performPointwiseWithOverflow(e, derived, (a, b) => a - b);
+    }
+    performPointwiseWithOverflow(e, t, op) {
+        const n = new DataView(e);
+        const i = new DataView(t);
+        const out = new ArrayBuffer(n.byteLength);
+        const s = new DataView(out);
+        for (let offset = 0; offset < n.byteLength; offset += 2) {
+            s.setUint16(offset, op(n.getUint16(offset, true), i.getUint16(offset, true)), true);
+        }
+        return out;
+    }
+}
+export const LT_HASH_ANTI_TAMPERING = new LTHash('WhatsApp Patch Integrity');
 //# sourceMappingURL=lt-hash.js.map

package/lib/Utils/make-mutex.js

@@ -1,40 +1,40 @@
-export const makeMutex = () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let task = Promise.resolve();
-    let taskTimeout;
-    return {
-        mutex(code) {
-            task = (async () => {
-                // wait for the previous task to complete
-                // if there is an error, we swallow so as to not block the queue
-                try {
-                    await task;
-                }
-                catch { }
-                try {
-                    // execute the current task
-                    const result = await code();
-                    return result;
-                }
-                finally {
-                    clearTimeout(taskTimeout);
-                }
-            })();
-            // we replace the existing task, appending the new piece of execution to it
-            // so the next task will have to wait for this one to finish
-            return task;
-        }
-    };
-};
-export const makeKeyedMutex = () => {
-    const map = {};
-    return {
-        mutex(key, task) {
-            if (!map[key]) {
-                map[key] = makeMutex();
-            }
-            return map[key].mutex(task);
-        }
-    };
-};
+export const makeMutex = () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let task = Promise.resolve();
+    let taskTimeout;
+    return {
+        mutex(code) {
+            task = (async () => {
+                // wait for the previous task to complete
+                // if there is an error, we swallow so as to not block the queue
+                try {
+                    await task;
+                }
+                catch { }
+                try {
+                    // execute the current task
+                    const result = await code();
+                    return result;
+                }
+                finally {
+                    clearTimeout(taskTimeout);
+                }
+            })();
+            // we replace the existing task, appending the new piece of execution to it
+            // so the next task will have to wait for this one to finish
+            return task;
+        }
+    };
+};
+export const makeKeyedMutex = () => {
+    const map = {};
+    return {
+        mutex(key, task) {
+            if (!map[key]) {
+                map[key] = makeMutex();
+            }
+            return map[key].mutex(task);
+        }
+    };
+};
 //# sourceMappingURL=make-mutex.js.map