@realvare/based 2.7.62 → 2.7.71

package/lib/Utils/event-buffer.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeEventBuffer = void 0;
 const events_1 = __importDefault(require("events"));
 const Types_1 = require("../Types");
+const WABinary_1 = require("../WABinary");
 const generics_1 = require("./generics");
 const messages_1 = require("./messages");
 const process_message_1 = require("./process-message");
@@ -87,6 +88,7 @@ const makeEventBuffer = (logger) => {
             };
         },
         emit(event, evData) {
+            normalizeEventJids(evData);
             if (buffersInProgress && BUFFERABLE_EVENT_SET.has(event)) {
                 append(data, historyCache, event, evData, logger);
                 return true;
@@ -116,6 +118,62 @@ const makeEventBuffer = (logger) => {
     };
 };
 exports.makeEventBuffer = makeEventBuffer;
+const LID_FIELD_DENYLIST = new Set([
+    'remoteLid',
+    'participantLid',
+    'subjectOwnerLid',
+    'ownerLid',
+    'descOwnerLid',
+    'lid',
+]);
+const shouldNormalizeField = (key) => {
+    if (!key || typeof key !== 'string') {
+        return true;
+    }
+    if (LID_FIELD_DENYLIST.has(key)) {
+        return false;
+    }
+    if (key.endsWith('Lid')) {
+        return false;
+    }
+    return true;
+};
+const normalizeEventJids = (data) => {
+    try {
+        normalizeAny(data, undefined);
+    }
+    catch (_e) {
+    }
+};
+const normalizeAny = (value, key) => {
+    if (typeof value === 'string') {
+        if ((0, WABinary_1.isLid)(value) && shouldNormalizeField(key)) {
+            return (0, WABinary_1.lidToJid)(value) || value;
+        }
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            const nv = normalizeAny(v, undefined);
+            if (nv !== v) {
+                value[i] = nv;
+            }
+        }
+        return value;
+    }
+    for (const k of Object.keys(value)) {
+        const v = value[k];
+        const nv = normalizeAny(v, k);
+        if (nv !== v) {
+            value[k] = nv;
+        }
+    }
+    return value;
+};
 const makeBufferData = () => {
     return {
         historySets: {
@@ -274,6 +332,10 @@ function append(data, historyCache, event, eventData, logger) {
         case 'contacts.update':
             const contactUpdates = eventData;
             for (const update of contactUpdates) {
+                // Skip if update is undefined or has no id
+                if (!update || !update.id) {
+                    continue;
+                }
                 const id = update.id;
                 // merge into prior upsert
                 const upsert = data.historySets.contacts[id] || data.contactUpserts[id];
@@ -358,7 +420,31 @@ function append(data, historyCache, event, eventData, logger) {
                 }
             }
             else {
-                // TODO: add support
+                // Handle delete all messages from a specific chat
+                const { jid } = deleteData;
+                // Remove all messages, updates, and reactions for this chat
+                for (const keyStr in data.messageUpserts) {
+                    if (keyStr.includes(jid)) {
+                        delete data.messageUpserts[keyStr];
+                    }
+                }
+                for (const keyStr in data.messageUpdates) {
+                    if (keyStr.includes(jid)) {
+                        delete data.messageUpdates[keyStr];
+                    }
+                }
+                for (const keyStr in data.messageReactions) {
+                    if (keyStr.includes(jid)) {
+                        delete data.messageReactions[keyStr];
+                    }
+                }
+                for (const keyStr in data.messageDeletes) {
+                    if (keyStr.includes(jid)) {
+                        delete data.messageDeletes[keyStr];
+                    }
+                }
+                // Store the delete all event
+                data.messageDeletes[`all:${jid}`] = { jid, all: true };
             }
             break;
         case 'messages.reaction':
@@ -394,6 +480,10 @@ function append(data, historyCache, event, eventData, logger) {
         case 'groups.update':
             const groupUpdates = eventData;
             for (const update of groupUpdates) {
+                // Skip if update is undefined or has no id
+                if (!update || !update.id) {
+                    continue;
+                }
                 const id = update.id;
                 const groupUpdate = data.groupUpdates[id] || {};
                 if (!data.groupUpdates[id]) {
@@ -477,7 +567,18 @@ function consolidateEvents(data) {
     }
     const messageDeleteList = Object.values(data.messageDeletes);
     if (messageDeleteList.length) {
-        map['messages.delete'] = { keys: messageDeleteList };
+        // Separate individual message deletions from delete all events
+        const individualDeletes = messageDeleteList.filter(item => !('all' in item && item.all));
+        const deleteAllEvents = messageDeleteList.filter(item => ('all' in item && item.all));
+        
+        if (individualDeletes.length) {
+            map['messages.delete'] = { keys: individualDeletes };
+        }
+        
+        // Emit delete all events separately
+        for (const deleteAllEvent of deleteAllEvents) {
+            map[`messages.delete.all.${deleteAllEvent.jid}`] = { jid: deleteAllEvent.jid, all: true };
+        }
     }
     const messageReactionList = Object.values(data.messageReactions).flatMap(({ key, reactions }) => reactions.flatMap(reaction => ({ key, reaction })));
     if (messageReactionList.length) {

package/lib/Utils/generics.js

@@ -66,11 +66,10 @@ const PLATFORM_MAP = {
     'sunos': 'Solaris'
 };
 exports.Browsers = {
-    ubuntu: (browser) => ['Ubuntu', browser, '22.04.4'],
-    macOS: (browser) => ['Mac OS', browser, '14.4.1'],
-    baileys: (browser) => ['Baileys', browser, '6.5.0'],
-    windows: (browser) => ['Windows', browser, '10.0.22631'],
-    /** The appropriate browser based on your OS & release */
+    ubuntu: (browser) => ['Ubuntu', browser, '24.04.1'],
+    macOS: (browser) => ['Mac OS', browser, '15.2.0'],
+    baileys: (browser) => ['Baileys', browser, '6.7.9'],
+    windows: (browser) => ['Windows', browser, '10.0.26100'],
     appropriate: (browser) => [PLATFORM_MAP[(0, os_1.platform)()] || 'Ubuntu', browser, (0, os_1.release)()]
 };
 const getPlatformId = (browser) => {
@@ -259,7 +258,7 @@ const printQRIfNecessaryListener = (ev, logger) => {
 };
 exports.printQRIfNecessaryListener = printQRIfNecessaryListener;
 const fetchLatestBaileysVersion = async (options = {}) => {
-    const URL = 'https://github.com/realvare/baileyz/lib/Defaults/baileys-version.json';
+    const URL = 'https://github.com/realvare/based/lib/Defaults/baileys-version.json';
     try {
         const result = await axios_1.default.get(URL, {
             ...options,

package/lib/Utils/index.d.ts

@@ -15,3 +15,8 @@ export * from './use-multi-file-auth-state';
 export * from './link-preview';
 export * from './event-buffer';
 export * from './process-message';
+export * from './performance-config';
+export { isValidJid, normalizeJid } from './jid-validation';
+export * from './newsletter-utils';
+export * from './logger';
+export * from './cache-manager';

package/lib/Utils/index.js

@@ -32,4 +32,7 @@ __exportStar(require("./link-preview"), exports);
 __exportStar(require("./event-buffer"), exports);
 __exportStar(require("./process-message"), exports);
 __exportStar(require("./performance-config"), exports);
+__exportStar(require("./jid-validation"), exports);
 __exportStar(require("./newsletter-utils"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./cache-manager"), exports);

package/lib/Utils/jid-validation.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidJid: (jid: string) => boolean;
+export declare const normalizeJid: (jid: string) => string;

package/lib/Utils/jid-validation.js

@@ -37,8 +37,9 @@ const normalizeJid = (jid) => {
     if (!jid) return jid;
 
     // Convert LID to standard JID format
-    if (jid.endsWith('@lid')) {
-        return jid.replace('@lid', '@s.whatsapp.net');
+    if ((0, WABinary_1.isLid)(jid)) {
+        const converted = (0, WABinary_1.lidToJid)(jid);
+        return converted || jid;
     }
 
     // Ensure consistent format
@@ -55,25 +56,56 @@ exports.normalizeJid = normalizeJid;
 const getSenderLid = (msg) => {
     try {
         if (!msg || typeof msg !== 'object') {
-            return { jid: undefined, lid: undefined, isValid: false };
+            return {
+                jid: '',
+                lid: '',
+                isValid: false,
+                user: '',
+                timestamp: Date.now(),
+                error: 'Invalid message object'
+            };
         }
 
         // Extract from different possible fields
         const jid = msg.key?.remoteJid || msg.remoteJid || msg.from;
         const lid = msg.key?.participant || msg.participant || msg.lid;
 
+        if (!jid || typeof jid !== 'string') {
+            return {
+                jid: '',
+                lid: typeof lid === 'string' ? lid : '',
+                isValid: false,
+                user: '',
+                timestamp: Date.now(),
+                error: 'Missing or invalid JID'
+            };
+        }
+
         // Validate and normalize
         const normalizedJid = normalizeJid(jid);
         const isValid = isValidJid(normalizedJid);
 
+        const decoded = (0, WABinary_1.jidDecode)(normalizedJid);
+        const user = decoded?.user || normalizedJid.split('@')[0] || '';
+
         return {
             jid: normalizedJid,
-            lid: lid,
-            isValid: isValid
+            lid: typeof lid === 'string' ? lid : '',
+            isValid: isValid,
+            user,
+            timestamp: Date.now(),
+            ...(isValid ? {} : { error: 'Invalid JID format' })
         };
     } catch (error) {
         performance_config_1.Logger.error('Error in getSenderLid:', error);
-        return { jid: undefined, lid: undefined, isValid: false };
+        return {
+            jid: '',
+            lid: '',
+            isValid: false,
+            user: '',
+            timestamp: Date.now(),
+            error: 'Error extracting sender information'
+        };
     }
 };
 
@@ -88,9 +120,10 @@ const toJid = (lid) => {
     if (!lid) return lid;
 
     try {
-        // Simple conversion from LID to JID format
-        if (lid.endsWith('@lid')) {
-            return lid.replace('@lid', '@s.whatsapp.net');
+        // Convert LID to JID format
+        if ((0, WABinary_1.isLid)(lid)) {
+            const converted = (0, WABinary_1.lidToJid)(lid);
+            return converted || lid;
         }
 
         // If already in JID format, return as-is
@@ -142,7 +175,7 @@ const validateJid = (jid) => {
             return { isValid: false, error: `Invalid domain: ${domain}` };
         }
 
-        return { isValid: true, error: null };
+        return { isValid: true };
 
     } catch (error) {
         performance_config_1.Logger.error('Error in validateJid:', error);

package/lib/Utils/link-preview.js

@@ -70,46 +70,56 @@ const getUrlInfo = async (text, opts = {
 }) => {
     var _a;
     try {
-        // retries
-        const retries = 0;
-        const maxRetry = 5;
-        const { getLinkPreview } = await Promise.resolve().then(() => __importStar(require('link-preview-js')));
+        const { unfurl } = await Promise.resolve().then(() => __importStar(require('unfurl.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;
+        const requestHeaders = (() => {
+            const headers = opts.fetchOpts?.headers;
+            if (!headers || typeof headers !== 'object') {
+                return undefined;
+            }
+            const out = {};
+            for (const [key, value] of Object.entries(headers)) {
+                if (typeof value === 'undefined' || value === null) {
+                    continue;
                 }
-                if (forwardedURLObj.hostname === urlObj.hostname
-                    || forwardedURLObj.hostname === 'www.' + urlObj.hostname
-                    || 'www.' + forwardedURLObj.hostname === urlObj.hostname) {
-                    retries + 1;
-                    return true;
+                if (Array.isArray(value)) {
+                    out[key] = value.map(v => v.toString()).join(', ');
                 }
                 else {
-                    return false;
+                    out[key] = value.toString();
                 }
-            },
-            headers: opts.fetchOpts
+            }
+            return out;
+        })();
+        const info = await unfurl(previewLink, {
+            timeout: opts.fetchOpts?.timeout,
+            headers: requestHeaders,
+            follow: 5
         });
-        if (info && 'title' in info && info.title) {
-            const [image] = info.images;
-            opts.logger?.debug({ url: previewLink, title: info.title, imageCount: info.images.length }, 'Fetched link preview info');
+        const title = info?.title || info?.open_graph?.title || info?.twitter_card?.title;
+        if (title) {
+            const images = [];
+            if (info?.open_graph?.images?.length) {
+                images.push(...info.open_graph.images.map(img => img === null || img === void 0 ? void 0 : img.url).filter(Boolean));
+            }
+            if (info?.twitter_card?.images?.length) {
+                images.push(...info.twitter_card.images.map(img => img === null || img === void 0 ? void 0 : img.url).filter(Boolean));
+            }
+            const [image] = images;
+            const description = info?.description || info?.open_graph?.description || info?.twitter_card?.description;
+            const canonicalUrl = info?.canonical_url || info?.open_graph?.url || previewLink;
+            opts.logger?.debug({ url: previewLink, title, imageCount: images.length }, 'Fetched link preview info');
             const urlInfo = {
-                'canonical-url': info.url,
+                'canonical-url': canonicalUrl,
                 'matched-text': text,
-                title: info.title,
-                description: info.description,
+                title,
+                description,
                 originalThumbnailUrl: image
             };
-            if (opts.uploadImage) {
+            if (opts.uploadImage && image) {
                 const { imageMessage } = await (0, messages_1.prepareWAMessageMedia)({ image: { url: image } }, {
                     upload: opts.uploadImage,
                     mediaTypeOverride: 'thumbnail-link',
@@ -134,7 +144,7 @@ const getUrlInfo = async (text, opts = {
         }
     }
     catch (error) {
-        if (!error.message.includes('receive a valid')) {
+        if (!error.message.includes('receive a valid') && !error.message.includes('Invalid URL')) {
             throw error;
         }
     }

package/lib/Utils/messages-media.d.ts

@@ -16,7 +16,7 @@ export declare function vid2jpg(videoUrl: string): Promise<string>;
  * Modified for customization and improvements
  */
 export declare const extractVideoThumb: (videoPath: string) => Promise<Buffer<ArrayBufferLike>>;
-export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number) => Promise<{
+export declare const extractImageThumb: (bufferOrFilePath: Readable | Buffer | string, width?: number, quality?: number) => Promise<{
     buffer: Buffer<ArrayBufferLike>;
     original: {
         width: number;

package/lib/Utils/messages-media.js

@@ -63,24 +63,11 @@ const crypto_1 = require("./crypto");
 const generics_1 = require("./generics");
 const getTmpFilesDirectory = () => (0, os_1.tmpdir)();
 const getImageProcessingLibrary = async () => {
-    const [_jimp, sharp] = await Promise.all([
-        (async () => {
-            const jimp = await (Promise.resolve().then(() => __importStar(require('jimp'))).catch(() => { }));
-            return jimp;
-        })(),
-        (async () => {
-            const sharp = await (Promise.resolve().then(() => __importStar(require('sharp'))).catch(() => { }));
-            return sharp;
-        })()
-    ]);
-    if (sharp) {
-        return { sharp };
-    }
-    const jimp = (_jimp === null || _jimp === void 0 ? void 0 : _jimp.default) || _jimp;
+    const jimp = await (Promise.resolve().then(() => __importStar(require('jimp'))).catch(() => { }));
     if (jimp) {
-        return { jimp };
+        return { jimp: jimp.default || jimp };
     }
-    throw new boom_1.Boom('No image processing library available');
+    throw new boom_1.Boom('Jimp image processing library not available');
 };
 const hkdfInfoKey = (type) => {
     const hkdfInfo = Defaults_1.MEDIA_HKDF_KEY_MAPPING[type];
@@ -273,46 +260,25 @@ const extractVideoThumb = async (videoPath, time = '00:00:00', size = { width: 2
     });
 };
 exports.extractVideoThumb = extractVideoThumb;
-const extractImageThumb = async (bufferOrFilePath, width = 32) => {
-    var _a, _b;
+const extractImageThumb = async (bufferOrFilePath, width = 32, quality = 50) => {
     if (bufferOrFilePath instanceof stream_1.Readable) {
         bufferOrFilePath = await (0, exports.toBuffer)(bufferOrFilePath);
     }
     const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
-        const img = lib.sharp.default(bufferOrFilePath);
-        const dimensions = await img.metadata();
-        const buffer = await img
-            .resize(width)
-            .jpeg({ quality: 50 })
-            .toBuffer();
-        return {
-            buffer,
-            original: {
-                width: dimensions.width,
-                height: dimensions.height,
-            },
-        };
-    }
-    else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
-        const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO } = lib.jimp;
-        const jimp = await read(bufferOrFilePath);
-        const dimensions = {
-            width: jimp.getWidth(),
-            height: jimp.getHeight()
-        };
-        const buffer = await jimp
-            .quality(50)
-            .resize(width, AUTO, RESIZE_BILINEAR)
-            .getBufferAsync(MIME_JPEG);
-        return {
-            buffer,
-            original: dimensions
-        };
-    }
-    else {
-        throw new boom_1.Boom('No image processing library available');
-    }
+    const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO } = lib.jimp;
+    const jimp = await read(bufferOrFilePath);
+    const dimensions = {
+        width: jimp.getWidth(),
+        height: jimp.getHeight()
+    };
+    const buffer = await jimp
+        .quality(quality)
+        .resize(width, AUTO, RESIZE_BILINEAR)
+        .getBufferAsync(MIME_JPEG);
+    return {
+        buffer,
+        original: dimensions
+    };
 };
 exports.extractImageThumb = extractImageThumb;
 const encodeBase64EncodedStringForUpload = (b64) => (encodeURIComponent(b64
@@ -424,6 +390,9 @@ const getStream = async (item, opts) => {
     if ('stream' in item) {
         return { stream: item.stream, type: 'readable' };
     }
+    if (!item || !item.url) {
+        throw new Error('Invalid media item: missing url property');
+    }
     if (item.url.toString().startsWith('http://') || item.url.toString().startsWith('https://')) {
         return { stream: await (0, exports.getHttpStream)(item.url, opts), type: 'remote' };
     }
@@ -876,4 +845,4 @@ const MEDIA_RETRY_STATUS_MAP = {
 };
 function __importStar(arg0) {
     throw new Error('Function not implemented.');
-}
+}