@realvare/based 2.6.11 → 2.6.23

package/lib/Socket/messages-recv.js

@@ -11,6 +11,7 @@ const WAProto_1 = require("../../WAProto");
 const Defaults_1 = require("../Defaults");
 const Types_1 = require("../Types");
 const Utils_1 = require("../Utils");
+const performance_config_1 = require("../Utils/performance-config");
 const make_mutex_1 = require("../Utils/make-mutex");
 const WABinary_1 = require("../WABinary");
 const groups_1 = require("./groups");
@@ -1048,25 +1049,48 @@ const makeMessagesRecvSocket = (config) => {
             upsertMessage(protoMsg, call.offline ? 'append' : 'notify');
         }
     });
-    ev.on('connection.update', ({ isOnline }) => {
-        if (typeof isOnline !== 'undefined') {
-            sendActiveReceipts = isOnline;
+    ev.on('connection.update', (update) => {
+        const { connection, lastDisconnect } = update;
+
+        if (connection === 'close') {
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            const shouldReconnect = statusCode !== Types_1.DisconnectReason.loggedOut;
+
+            if (shouldReconnect) {
+                logger.info('Connection closed, will handle reconnection automatically');
+            } else {
+                logger.warn('Logged out, manual re-authentication required');
+            }
+        } else if (connection === 'open') {
+            sendActiveReceipts = true;
+        }
+
+        // Update sendActiveReceipts based on connection status
+        if (typeof update.isOnline !== 'undefined') {
+            sendActiveReceipts = update.isOnline;
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
     });
 
-    // Retry logic for stuck pending messages
+    // Enhanced retry logic for stuck pending messages with anti-ban delays
     ev.on('messages.update', (updates) => {
+        const config = getPerformanceConfig();
         updates.forEach(update => {
             if (update.update.status === WAProto_1.proto.WebMessageInfo.Status.PENDING &&
                 Date.now() - (update.update.timestamp || 0) > 30000) { // 30 seconds
-                logger.debug({ key: update.key }, 'retrying stuck pending message');
-                // Retry by re-sending the message
-                getMessage(update.key).then(msg => {
-                    if (msg) {
-                        relayMessage(update.key.remoteJid, msg, { messageId: update.key.id });
+                logger.debug({ key: update.key }, 'retrying stuck pending message with anti-ban delay');
+
+                // Apply anti-ban delay before retry
+                setTimeout(async () => {
+                    try {
+                        const msg = await getMessage(update.key);
+                        if (msg) {
+                            await relayMessage(update.key.remoteJid, msg, { messageId: update.key.id });
+                        }
+                    } catch (err) {
+                        logger.error({ err, key: update.key }, 'failed to retry stuck message');
                     }
-                }).catch(err => logger.error({ err, key: update.key }, 'failed to retry stuck message'));
+                }, config.security?.messageDelay?.min || 1000);
             }
         });
     });

package/lib/Socket/messages-send.js

@@ -16,10 +16,12 @@ const WABinary_1 = require("../WABinary");
 const WAUSync_1 = require("../WAUSync");
 const newsletter_1 = require("./newsletter");
 const rate_limiter_1 = __importDefault(require("../Utils/rate-limiter"));
+const { generateThumbnail } = require("../Utils/thumbnail");
 const makeMessagesSocket = (config) => {
     const { logger, linkPreviewImageThumbnailWidth, generateHighQualityLinkPreview, options: axiosOptions, patchMessageBeforeSending, cachedGroupMetadata, } = config;
     const sock = (0, newsletter_1.makeNewsletterSocket)(config);
     const { ev, authState, processingMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral, } = sock;
+
     const userDevicesCache = config.userDevicesCache || new node_cache_1.default({
         stdTTL: Defaults_1.DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
         useClones: false
@@ -275,6 +277,26 @@ const makeMessagesSocket = (config) => {
         const isStatus = jid === statusJid;
         const isLid = server === 'lid';
         msgId = msgId || (0, Utils_1.generateMessageIDV2)((_a = sock.user) === null || _a === void 0 ? void 0 : _a.id);
+        if(message.contextInfo?.externalAdReply?.thumbnailUrl) {
+            try {
+                const { externalAdReply } = message.contextInfo;
+                const thumbnail = await generateThumbnail(externalAdReply.thumbnailUrl);
+                message.contextInfo.externalAdReply = {
+                    ...externalAdReply,
+                    thumbnail,
+                    renderLargerThumbnail: false,
+                };
+                delete message.contextInfo.externalAdReply.thumbnailUrl;
+                logger?.debug('Successfully generated thumbnail for external ad reply');
+            } catch(err) {
+                logger?.warn({ trace: err.stack, msg: message.contextInfo.externalAdReply }, 'failed to generate thumbnail for external ad reply, keeping thumbnailUrl as fallback');
+                // Ensure renderLargerThumbnail is set to false even on failure
+                if (message.contextInfo.externalAdReply.renderLargerThumbnail === undefined) {
+                    message.contextInfo.externalAdReply.renderLargerThumbnail = false;
+                }
+            }
+        }
+
         useUserDevicesCache = useUserDevicesCache !== false;
         useCachedGroupMetadata = useCachedGroupMetadata !== false && !isStatus;
         const participants = [];
@@ -766,9 +788,9 @@ const makeMessagesSocket = (config) => {
                             parentMessageKey: albumMsg.key
                         }
                     };
-                    await relayMessage(jid, mediaMsg.message, {
+                    await rateLimiter.add(() => relayMessage(jid, mediaMsg.message, {
                         messageId: mediaMsg.key.id
-                    });
+                    }));
                     await new Promise(resolve => setTimeout(resolve, 800));
                 }
             }
@@ -878,7 +900,7 @@ const makeMessagesSocket = (config) => {
                         parentMessageKey: packMsg.key
                     }
                 };
-                await relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id });
+                await rateLimiter.add(() => relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id }));
                 lastMsg = stickerMsg;
                 // Add delay between stickers to avoid rate limiting
                 await new Promise(resolve => setTimeout(resolve, 800));
@@ -1128,9 +1150,9 @@ const makeMessagesSocket = (config) => {
                         expectedVideoCount: album.filter(item => 'video' in item).length
                     }
                 }, { userJid, ...options });
-                await relayMessage(jid, albumMsg.message, {
+                await rateLimiter.add(() => relayMessage(jid, albumMsg.message, {
                     messageId: albumMsg.key.id
-                });
+                }));
                 for (const i in album) {
                     const media = album[i];
                     if ('image' in media) {
@@ -1291,18 +1313,17 @@ const makeMessagesSocket = (config) => {
                         messageId: (0, Utils_1.generateMessageIDV2)((_c = sock.user) === null || _c === void 0 ? void 0 : _c.id),
                         ...options,
                     });
-                    // Associate sticker with the pack message
-                    stickerMsg.message.messageContextInfo = {
-                        messageSecret: (0, crypto_1.randomBytes)(32),
-                        messageAssociation: {
-                            associationType: 1,
-                            parentMessageKey: packMsg.key
-                        }
-                    };
-                    await relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id });
-                    lastMsg = stickerMsg;
-                    // Add delay between stickers to avoid rate limiting
-                    await new Promise(resolve => setTimeout(resolve, 800));
+                // Associate sticker with the pack message
+                stickerMsg.message.messageContextInfo = {
+                    messageSecret: (0, crypto_1.randomBytes)(32),
+                    messageAssociation: {
+                        associationType: 1,
+                        parentMessageKey: packMsg.key
+                    }
+                };
+                await rateLimiter.add(() => relayMessage(jid, stickerMsg.message, { messageId: stickerMsg.key.id }));
+                lastMsg = stickerMsg;
+                await new Promise(resolve => setTimeout(resolve, 800));
                 }
                 return lastMsg;
             }

package/lib/Types/Socket.d.ts

@@ -29,7 +29,7 @@ export type SocketConfig = {
     connectTimeoutMs: number;
     /** Default timeout for queries, undefined for no timeout */
     defaultQueryTimeoutMs: number | undefined;
-    /** ping-pong interval for WS connection */
+    /** ping- inpongterval for WS connection */
     keepAliveIntervalMs: number;
     /** should baileys use the mobile api instead of the multi device api
     * @deprecated This feature has been removed

package/lib/Utils/cache-manager.js

@@ -7,20 +7,24 @@ class CacheManager {
         const config = getPerformanceConfig();
         this.caches = {};
         this.memoryCheckInterval = null;
-        
+        this.msgStore = null;
+
         // Inizializza le cache con TTL
         Object.entries(config.cache).forEach(([name, options]) => {
             this.caches[name] = new NodeCache({
-                stdTTL: options.ttl / 1000, // Converti da ms a secondi
+                stdTTL: options.ttl / 1000,
                 checkperiod: options.cleanupInterval / 1000,
                 maxKeys: options.maxSize
             });
         });
-        
+
         if (config.performance.enableMetrics) {
             this.startMemoryMonitoring(config.performance.memoryThreshold);
         }
     }
+    setMessageStore(msgStore) {
+        this.msgStore = msgStore;
+    }
     
     startMemoryMonitoring(threshold) {
         this.memoryCheckInterval = setInterval(() => {

package/lib/Utils/logger.js

@@ -4,4 +4,56 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const pino_1 = __importDefault(require("pino"));
-exports.default = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+const { getPerformanceConfig } = require('./performance-config');
+const defaultLogger = (0, pino_1.default)({ timestamp: () => `,"time":"${new Date().toJSON()}"` });
+class EnhancedLogger {
+    constructor() {
+        this.config = getPerformanceConfig();
+    }
+
+    static error(...args) {
+        if (defaultLogger.isLevelEnabled('error')) {
+            defaultLogger.error(...args);
+        }
+        // Additional error tracking if enabled
+        if (this.config?.debug?.enableErrorTracking) {
+            // Could send to external monitoring service
+            console.error('[ERROR TRACK]', ...args);
+        }
+    }
+
+    static warn(...args) {
+        if (defaultLogger.isLevelEnabled('warn')) {
+            defaultLogger.warn(...args);
+        }
+    }
+
+    static info(...args) {
+        if (this.config?.debug?.enableInfoLogging && defaultLogger.isLevelEnabled('info')) {
+            defaultLogger.info(...args);
+        }
+    }
+
+    static debug(...args) {
+        if (this.config?.debug?.enableDebugLogging && defaultLogger.isLevelEnabled('debug')) {
+            defaultLogger.debug(...args);
+        }
+    }
+    static createBaileysLogger(level = 'info', prefix = 'Based') {
+        return {
+            level,
+            debug: (...args) => this.debug(`[${prefix}]`, ...args),
+            info: (...args) => this.info(`[${prefix}]`, ...args),
+            warn: (...args) => this.warn(`[${prefix}]`, ...args),
+            error: (...args) => this.error(`[${prefix}]`, ...args),
+            trace: (...args) => this.debug(`[${prefix} TRACE]`, ...args),
+            child: (bindings) => ({
+                ...this.createBaileysLogger(level, prefix),
+                bindings
+            })
+        };
+    }
+}
+
+exports.EnhancedLogger = EnhancedLogger;
+exports.default = defaultLogger;

package/lib/Utils/messages-media.js

@@ -69,7 +69,7 @@ const getImageProcessingLibrary = async () => {
             return jimp;
         })(),
         (async () => {
-            const sharp = await (Promise.resolve().then(() => __importStar(require('sharp'))).catch(() => { }));
+            const sharp = await (Promise.resolve().then(() => __importStar(require('@img/sharp-wasm32'))).catch(() => { }));
             return sharp;
         })()
     ]);

package/lib/Utils/messages.js

@@ -275,8 +275,8 @@ const generateWAMessageContent = async (message, options) => {
 
         // Ensure renderLargerThumbnail is set for better display across platforms
         if (externalAdReply.renderLargerThumbnail === undefined) {
-            externalAdReply.renderLargerThumbnail = true;
-            options.logger?.debug('Set renderLargerThumbnail=true for improved cross-platform display');
+            externalAdReply.renderLargerThumbnail = false;
+            options.logger?.debug('Set renderLargerThumbnail=false for improved cross-platform display');
         }
 
         // Update the contextInfo with modified externalAdReply
@@ -1194,187 +1194,50 @@ const assertMediaContent = (content) => {
     return mediaContent;
 };
 exports.assertMediaContent = assertMediaContent;
-
-// Cache per ottimizzare le conversioni LID/JID
-const lidCache = new Map();
-const jidCache = new Map();
-const CACHE_TTL = 5 * 60 * 1000; // 5 minuti
-const MAX_CACHE_SIZE = 10000; // Massimo 10k entries
-
-// Funzione per pulire cache scadute
-const cleanExpiredCache = (cache) => {
-    const now = Date.now();
-    for (const [key, value] of cache.entries()) {
-        if (now - value.timestamp > CACHE_TTL) {
-            cache.delete(key);
-        }
-    }
-    
-    // Se la cache è troppo grande, rimuovi le entry più vecchie
-    if (cache.size > MAX_CACHE_SIZE) {
-        const entries = Array.from(cache.entries());
-        entries.sort((a, b) => a[1].timestamp - b[1].timestamp);
-        const toRemove = entries.slice(0, Math.floor(MAX_CACHE_SIZE * 0.2));
-        toRemove.forEach(([key]) => cache.delete(key));
-    }
+const getNormalizedJid = (jid) => {
+    if (!jid) return jid;
+    return (0, WABinary_1.jidNormalizedUser)(jid);
 };
+exports.getNormalizedJid = getNormalizedJid;
 
-// Pulisci cache ogni 2 minuti
-setInterval(() => {
-    cleanExpiredCache(lidCache);
-    cleanExpiredCache(jidCache);
-}, 2 * 60 * 1000);
+const isLidFormat = (jid) => {
+    return (0, WABinary_1.isLidUser)(jid);
+};
+exports.isLidFormat = isLidFormat;
 
+// Legacy compatibility functions - deprecated, use native APIs
 const toJid = (id) => {
-    try {
-        if (!id || typeof id !== 'string') {
-            return '';
-        }
-        
-        // Controlla cache
-        if (jidCache.has(id)) {
-            const cached = jidCache.get(id);
-            if (Date.now() - cached.timestamp < CACHE_TTL) {
-                return cached.result;
-            } else {
-                jidCache.delete(id);
-            }
-        }
-        
-        let result = '';
-        
-        if (id.endsWith('@lid')) {
-            result = id.replace('@lid', '@s.whatsapp.net');
-        } else if (id.includes('@')) {
-            result = id;
-        } else {
-            result = `${id}@s.whatsapp.net`;
-        }
-        
-        // Salva in cache
-        jidCache.set(id, {
-            result,
-            timestamp: Date.now()
-        });
-        
-        return result;
-    } catch (error) {
-        console.error('Error in toJid:', error.message, 'Input:', id);
-        return id || '';
-    }
+    console.warn('toJid is deprecated. Use getNormalizedJid instead.');
+    return getNormalizedJid(id);
 };
 exports.toJid = toJid;
 
 const getSenderLid = (message) => {
-    try {
-        if (!message?.key) {
-            throw new Error('Invalid message: missing key property');
-        }
-        
-        const sender = message.key.participant || message.key.remoteJid;
-        if (!sender) {
-            throw new Error('Invalid message: missing sender information');
-        }
-        
-        // Controlla cache
-        if (lidCache.has(sender)) {
-            const cached = lidCache.get(sender);
-            if (Date.now() - cached.timestamp < CACHE_TTL) {
-                return cached.result;
-            } else {
-                lidCache.delete(sender);
-            }
-        }
-        
-        const decoded = (0, WABinary_1.jidDecode)(sender);
-        if (!decoded?.user) {
-            throw new Error(`Invalid JID format: ${sender}`);
-        }
-        
-        const user = decoded.user;
-        const lid = (0, WABinary_1.jidEncode)(user, 'lid');
-        
-        const result = { 
-            jid: sender, 
-            lid,
-            isValid: true,
-            user,
-            timestamp: Date.now()
-        };
-        
-        // Log solo in debug mode
-        if (process.env.DEBUG_LID === 'true') {
-            console.log('sender lid:', lid, 'user:', user);
-        }
-        
-        // Salva in cache
-        lidCache.set(sender, {
-            result,
-            timestamp: Date.now()
-        });
-        
-        return result;
-        
-    } catch (error) {
-        console.error('Error in getSenderLid:', error.message, 'Message:', message?.key);
-        
-        // Ritorna un oggetto di fallback valido
-        return {
-            jid: message?.key?.remoteJid || 'unknown',
-            lid: 'unknown@lid',
-            isValid: false,
-            user: 'unknown',
-            error: error.message,
-            timestamp: Date.now()
-        };
-    }
-};
-exports.getSenderLid = getSenderLid;
+    console.warn('getSenderLid is deprecated. Use getNormalizedJid and isLidFormat instead.');
+    const sender = message?.key?.participant || message?.key?.remoteJid;
+    if (!sender) return null;
 
-// Utility functions per performance e debugging
-const getCacheStats = () => {
+    const normalized = getNormalizedJid(sender);
     return {
-        lidCache: {
-            size: lidCache.size,
-            maxSize: MAX_CACHE_SIZE,
-            ttl: CACHE_TTL
-        },
-        jidCache: {
-            size: jidCache.size,
-            maxSize: MAX_CACHE_SIZE,
-            ttl: CACHE_TTL
-        }
+        jid: sender,
+        lid: normalized,
+        isValid: true,
+        user: (0, WABinary_1.jidDecode)(normalized)?.user || 'unknown'
     };
 };
-exports.getCacheStats = getCacheStats;
-
-const clearCache = () => {
-    lidCache.clear();
-    jidCache.clear();
-    console.log(chalk.bold.magenta('- 🎐 | Cache cancellata correttamente'));
-};
-exports.clearCache = clearCache;
+exports.getSenderLid = getSenderLid;
 
 const validateJid = (jid) => {
+    console.warn('validateJid is deprecated. Use native Baileys validation.');
     if (!jid || typeof jid !== 'string') {
         return { isValid: false, error: 'Invalid JID: must be a non-empty string' };
     }
-    
-    const parts = jid.split('@');
-    if (parts.length !== 2) {
-        return { isValid: false, error: 'Invalid JID format: must contain exactly one @' };
-    }
-    
-    const [user, server] = parts;
-    if (!user || !server) {
-        return { isValid: false, error: 'Invalid JID: user and server parts cannot be empty' };
-    }
-    
-    const validServers = ['s.whatsapp.net', 'g.us', 'broadcast', 'newsletter', 'lid', 'c.us'];
-    if (!validServers.includes(server)) {
-        return { isValid: false, error: `Invalid server: ${server}. Must be one of: ${validServers.join(', ')}` };
+
+    try {
+        const decoded = (0, WABinary_1.jidDecode)(jid);
+        return { isValid: !!decoded };
+    } catch {
+        return { isValid: false, error: 'Invalid JID format' };
     }
-    
-    return { isValid: true };
 };
 exports.validateJid = validateJid;

package/lib/Utils/performance-config.js

@@ -7,41 +7,39 @@ exports.PerformanceConfig = exports.setPerformanceConfig = exports.getPerformanc
  */
 class PerformanceConfig {
     constructor() {
-        // Cache settings
         this.cache = {
             lidCache: {
-                ttl: 5 * 60 * 1000, // 5 minuti
+                ttl: 5 * 60 * 1000,
                 maxSize: 10000,
-                cleanupInterval: 2 * 60 * 1000 // 2 minuti
+                cleanupInterval: 2 * 60 * 1000
             },
             jidCache: {
-                ttl: 5 * 60 * 1000, // 5 minuti
+                ttl: 5 * 60 * 1000,
                 maxSize: 10000,
-                cleanupInterval: 2 * 60 * 1000 // 2 minuti
+                cleanupInterval: 2 * 60 * 1000
             },
             lidToJidCache: {
-                ttl: 5 * 60 * 1000, // 5 minuti
+                ttl: 5 * 60 * 1000,
                 maxSize: 5000,
-                cleanupInterval: 3 * 60 * 1000 // 3 minuti
+                cleanupInterval: 3 * 60 * 1000
             }
         };
         
-        // Performance settings - Conservative defaults for anti-ban protection
         this.performance = {
             enableCache: true,
             enableLogging: false,
             enableMetrics: true,
-            batchSize: 20, // Reduced from 50 for anti-ban
-            maxRetries: 3, // Reduced from 5 for anti-ban
-            retryDelay: 5000,
-            retryBackoffMultiplier: 1.5,
-            maxRetryDelay: 60000,
+            batchSize: 30,
+            maxRetries: 3,
+            retryDelay: 8000,
+            retryBackoffMultiplier: 2.0,
+            maxRetryDelay: 120000,
             maxMsgRetryCount: 3,
-            memoryThreshold: 0.85, // 85% memory usage threshold
-            // Anti-ban specific settings
-            markOnlineOnConnect: false, // Don't appear always online
-            syncFullHistory: false, // Limit initial sync
-            keepAliveIntervalMs: 30000 // Maintain connection without excess
+            memoryThreshold: 0.85,
+            markOnlineOnConnect: false,
+            syncFullHistory: true,
+            keepAliveIntervalMs: 30000,
+            enableNativeLidCache: true
         };
         
         // Debug settings

package/lib/Utils/thumbnail.js

@@ -0,0 +1,35 @@
+const sharp = require('@img/sharp-wasm32');
+const fs = require('fs/promises');
+const fetch = require('node-fetch');
+
+/**
+ * Generates an optimized JPEG thumbnail buffer for externalAdReply.
+ * @param {string | Buffer} imagePathOrBuffer - Path to image file, Buffer, or URL.
+ * @param {number} [size=150] - Target square size (default 150 for balance between quality and load time).
+ * @param {number} [quality=85] - JPEG quality (1-100, default 85).
+ * @returns {Promise<Buffer>} - Optimized thumbnail buffer.
+ */
+async function generateThumbnail(imagePathOrBuffer, size = 150, quality = 85) {
+  let input;
+
+  if (typeof imagePathOrBuffer === 'string') {
+    if (imagePathOrBuffer.startsWith('http')) {
+      // Fetch from URL
+      const response = await fetch(imagePathOrBuffer);
+      input = Buffer.from(await response.arrayBuffer());
+    } else {
+      // Local file
+      input = await fs.readFile(imagePathOrBuffer);
+    }
+  } else {
+    input = imagePathOrBuffer;
+  }
+
+  return sharp(input)
+    .resize(size, size, { fit: 'cover', kernel: sharp.kernel.lanczos3 }) // Lanczos for sharp resizing
+    .sharpen() // Optional: Adds slight sharpness to counter blurring
+    .jpeg({ quality, mozjpeg: true }) // Use high-quality JPEG compression
+    .toBuffer();
+}
+
+module.exports = { generateThumbnail };

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

@@ -88,7 +88,11 @@ const useMultiFileAuthState = async (folder) => {
         await (0, promises_1.mkdir)(folder, { recursive: true });
     }
     const fixFileName = (file) => { var _a; return (_a = file === null || file === void 0 ? void 0 : file.replace(/\//g, '__')) === null || _a === void 0 ? void 0 : _a.replace(/:/g, '-'); };
-    const creds = await readData('creds.json') || (0, auth_utils_1.initAuthCreds)();
+    let creds = await readData('creds.json');
+    if (!creds) {
+        creds = (0, auth_utils_1.initAuthCreds)();
+    }
+
     return {
         state: {
             creds,