@codexverified/baileys 2.7.5

package/lib/Utils/jid-display-normalization.js

@@ -0,0 +1,209 @@
+import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser, jidDecode } from '../WABinary/index.js';
+
+const createLidPnDebug = (logger) => {
+    const enabled = process.env.LID_PN_DEBUG === '1' || process.env.LID_PN_DEBUG === 'true';
+    return (phase, payload) => {
+        if (!enabled) {
+            return;
+        }
+        logger?.debug({ ...payload, phase }, 'lid->pn normalization trace');
+    };
+};
+
+const fallbackPnFromLidJid = (jid) => {
+    const decoded = jidDecode(jid);
+    const rawUser = decoded?.user || (typeof jid === 'string' ? jid.split('@')[0] : '');
+    const user = rawUser.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    return `${user}@s.whatsapp.net`;
+};
+
+const toDisplayPnJid = (jid) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    const decoded = jidDecode(jid);
+    if (!decoded?.user) {
+        return jid;
+    }
+    if (!isPnUser(jid) && !isHostedPnUser(jid)) {
+        return jid;
+    }
+    const user = decoded.user.split(':')[0];
+    if (!user) {
+        return jid;
+    }
+    const server = decoded.server === 'hosted' ? 'hosted' : 's.whatsapp.net';
+    return `${user}@${server}`;
+};
+
+const buildLidPnHints = (key) => {
+    const hints = new Map();
+    if (!key) {
+        return hints;
+    }
+    const addHint = (lid, pn) => {
+        if (!isLidUser(lid) && !isHostedLidUser(lid)) {
+            return;
+        }
+        if (!isPnUser(pn) && !isHostedPnUser(pn)) {
+            return;
+        }
+        hints.set(lid, pn);
+        const lidDecoded = jidDecode(lid);
+        const pnDecoded = jidDecode(pn);
+        if (lidDecoded?.user && pnDecoded?.user) {
+            hints.set(`${lidDecoded.user}@lid`, `${pnDecoded.user}@s.whatsapp.net`);
+        }
+    };
+    addHint(key.participant, key.participantAlt);
+    addHint(key.remoteJid, key.remoteJidAlt);
+    addHint(key.participantAlt, key.participant);
+    addHint(key.remoteJidAlt, key.remoteJid);
+    return hints;
+};
+
+const mergeGroupDataHints = (hints, groupData, debug) => {
+    if (!groupData?.participants?.length) {
+        return;
+    }
+    debug?.('groupData-size', { participants: groupData.participants.length });
+    for (const participant of groupData.participants) {
+        const lidCandidate = participant?.lid;
+        const idCandidate = participant?.id;
+        const pnCandidate = participant?.phoneNumber;
+        const lid =
+            ((isLidUser(lidCandidate) || isHostedLidUser(lidCandidate)
+                ? lidCandidate
+                : undefined)) ||
+            ((isLidUser(idCandidate) || isHostedLidUser(idCandidate) ? idCandidate : undefined));
+        const pn =
+            ((isPnUser(pnCandidate) || isHostedPnUser(pnCandidate)
+                ? pnCandidate
+                : undefined)) ||
+            ((isPnUser(idCandidate) || isHostedPnUser(idCandidate) ? idCandidate : undefined));
+        if (!lid || !pn) {
+            continue;
+        }
+        if (
+            (isLidUser(lid) || isHostedLidUser(lid)) &&
+            (isPnUser(pn) || isHostedPnUser(pn))
+        ) {
+            const displayPn = toDisplayPnJid(pn);
+            hints.set(lid, displayPn);
+            const lidDecoded = jidDecode(lid);
+            if (lidDecoded?.user) {
+                hints.set(`${lidDecoded.user}@lid`, displayPn);
+            }
+            debug?.('group-hint', { lid, pn: displayPn });
+        }
+    }
+};
+
+const normalizeToPnJid = async (jid, hints, signalRepository, debug) => {
+    if (!jid || typeof jid !== 'string') {
+        return jid;
+    }
+    if (!isLidUser(jid) && !isHostedLidUser(jid)) {
+        return jid;
+    }
+    debug?.('input', { lid: jid });
+    const hinted = hints.get(jid);
+    if (hinted) {
+        const normalized = toDisplayPnJid(hinted);
+        debug?.('hint-exact', { lid: jid, hinted, normalized });
+        return normalized;
+    }
+    const decoded = jidDecode(jid);
+    if (decoded?.user) {
+        const userHint = hints.get(`${decoded.user}@lid`);
+        if (userHint) {
+            const normalized = toDisplayPnJid(userHint);
+            debug?.('hint-user', { lid: jid, userHint, normalized });
+            return normalized;
+        }
+    }
+    const mapped = await signalRepository?.lidMapping?.getPNForLID?.(jid);
+    if (mapped) {
+        const normalized = toDisplayPnJid(mapped);
+        debug?.('mapping', { lid: jid, mapped, normalized });
+        return normalized;
+    }
+    const fallback = fallbackPnFromLidJid(jid);
+    debug?.('fallback', { lid: jid, fallback });
+    return fallback;
+};
+
+const normalizeMentionedJidsToPn = async (node, hints, signalRepository, debug) => {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            await normalizeMentionedJidsToPn(item, hints, signalRepository, debug);
+        }
+        return;
+    }
+    if (Array.isArray(node.mentionedJid)) {
+        const before = [...node.mentionedJid];
+        node.mentionedJid = await Promise.all(
+            node.mentionedJid.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug))
+        );
+        debug?.('mentions', { before, after: node.mentionedJid });
+    }
+    if (typeof node.participant === 'string') {
+        const before = node.participant;
+        node.participant = await normalizeToPnJid(node.participant, hints, signalRepository, debug);
+        if (before !== node.participant) {
+            debug?.('participant-field', { before, after: node.participant });
+        }
+    }
+    if (typeof node.remoteJid === 'string') {
+        const before = node.remoteJid;
+        node.remoteJid = await normalizeToPnJid(node.remoteJid, hints, signalRepository, debug);
+        if (before !== node.remoteJid) {
+            debug?.('remoteJid-field', { before, after: node.remoteJid });
+        }
+    }
+    for (const value of Object.values(node)) {
+        if (value && typeof value === 'object') {
+            await normalizeMentionedJidsToPn(value, hints, signalRepository, debug);
+        }
+    }
+};
+
+export const normalizeMentionedJidsForSend = async (mentions, groupData, signalRepository, logger) => {
+    if (!Array.isArray(mentions)) {
+        return mentions;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = new Map();
+    mergeGroupDataHints(hints, groupData, debug);
+    const normalized = await Promise.all(mentions.map(jid => normalizeToPnJid(jid, hints, signalRepository, debug)));
+    debug('send-mentions-result', { before: mentions, after: normalized });
+    return normalized;
+};
+
+export const normalizeMessageForDisplayJids = async (messageInfo, signalRepository, logger, groupData) => {
+    if (!messageInfo?.key) {
+        return messageInfo;
+    }
+    const debug = createLidPnDebug(logger);
+    const hints = buildLidPnHints(messageInfo.key);
+    mergeGroupDataHints(hints, groupData, debug);
+    const beforeKey = { ...messageInfo.key };
+    messageInfo.key.participant = await normalizeToPnJid(messageInfo.key.participant, hints, signalRepository, debug);
+    messageInfo.key.participantAlt = await normalizeToPnJid(
+        messageInfo.key.participantAlt,
+        hints,
+        signalRepository,
+        debug
+    );
+    messageInfo.key.remoteJid = await normalizeToPnJid(messageInfo.key.remoteJid, hints, signalRepository, debug);
+    messageInfo.key.remoteJidAlt = await normalizeToPnJid(messageInfo.key.remoteJidAlt, hints, signalRepository, debug);
+    await normalizeMentionedJidsToPn(messageInfo.message, hints, signalRepository, debug);
+    debug('display-key-result', { before: beforeKey, after: messageInfo.key });
+    return messageInfo;
+};

package/lib/Utils/link-preview.js

@@ -0,0 +1,84 @@
+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 {
+        // retries
+        const 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;
+                    return true;
+                }
+                else {
+                    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) {
+                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;
+            }
+            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;
+        }
+    }
+};

package/lib/Utils/logger.js

@@ -0,0 +1,2 @@
+import P from 'pino';
+export default P({ timestamp: () => `,"time":"${new Date().toJSON()}"` });

package/lib/Utils/lt-hash.js

@@ -0,0 +1,7 @@
+import { LTHashAntiTampering } from 'whatsapp-rust-bridge';
+/**
+ * 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.
+ */
+export const LT_HASH_ANTI_TAMPERING = new LTHashAntiTampering();

package/lib/Utils/make-mutex.js

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