@realvare/based 2.5.1 → 2.5.5

package/lib/Utils/performance-config.js

@@ -1,150 +1,153 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PerformanceConfig = exports.setPerformanceConfig = exports.getPerformanceConfig = void 0;
-
-/**
- * Configurazione performance per ottimizzazioni LID/JID
- */
-class PerformanceConfig {
-    constructor() {
-        // Cache settings
-        this.cache = {
-            lidCache: {
-                ttl: 5 * 60 * 1000, // 5 minuti
-                maxSize: 10000,
-                cleanupInterval: 2 * 60 * 1000 // 2 minuti
-            },
-            jidCache: {
-                ttl: 5 * 60 * 1000, // 5 minuti
-                maxSize: 10000,
-                cleanupInterval: 2 * 60 * 1000 // 2 minuti
-            },
-            lidToJidCache: {
-                ttl: 5 * 60 * 1000, // 5 minuti
-                maxSize: 5000,
-                cleanupInterval: 3 * 60 * 1000 // 3 minuti
-            }
-        };
-        
-        // Performance settings
-        this.performance = {
-            enableCache: true,
-            enableLogging: false,
-            enableMetrics: false,
-            batchSize: 100,
-            maxRetries: 3,
-            retryDelay: 1000
-        };
-        
-        // Debug settings
-        this.debug = {
-            enableLidLogging: process.env.DEBUG_LID === 'true',
-            enablePerformanceLogging: process.env.DEBUG_PERFORMANCE === 'true',
-            enableErrorLogging: true,
-            logLevel: process.env.LOG_LEVEL || 'error'
-        };
-    }
-    
-    /**
-     * Aggiorna configurazione cache
-     */
-    updateCacheConfig(cacheType, config) {
-        if (this.cache[cacheType]) {
-            this.cache[cacheType] = { ...this.cache[cacheType], ...config };
-        }
-    }
-    
-    /**
-     * Aggiorna configurazione performance
-     */
-    updatePerformanceConfig(config) {
-        this.performance = { ...this.performance, ...config };
-    }
-    
-    /**
-     * Aggiorna configurazione debug
-     */
-    updateDebugConfig(config) {
-        this.debug = { ...this.debug, ...config };
-    }
-    
-    /**
-     * Verifica se il logging è abilitato per un livello specifico
-     */
-    shouldLog(level) {
-        const levels = ['error', 'warn', 'info', 'debug'];
-        const currentLevelIndex = levels.indexOf(this.debug.logLevel);
-        const requestedLevelIndex = levels.indexOf(level);
-        return requestedLevelIndex <= currentLevelIndex;
-    }
-}
-
-// Istanza globale della configurazione
-let globalConfig = new PerformanceConfig();
-
-/**
- * Ottieni la configurazione performance globale
- */
-const getPerformanceConfig = () => globalConfig;
-exports.getPerformanceConfig = getPerformanceConfig;
-
-/**
- * Imposta una nuova configurazione performance
- */
-const setPerformanceConfig = (config) => {
-    if (config instanceof PerformanceConfig) {
-        globalConfig = config;
-    } else {
-        // Merge con configurazione esistente
-        if (config.cache) {
-            Object.keys(config.cache).forEach(key => {
-                globalConfig.updateCacheConfig(key, config.cache[key]);
-            });
-        }
-        if (config.performance) {
-            globalConfig.updatePerformanceConfig(config.performance);
-        }
-        if (config.debug) {
-            globalConfig.updateDebugConfig(config.debug);
-        }
-    }
-};
-exports.setPerformanceConfig = setPerformanceConfig;
-
-/**
- * Utility per logging condizionale
- */
-class Logger {
-    static error(message, ...args) {
-        if (globalConfig.shouldLog('error')) {
-            console.error(`[LID/JID Error] ${message}`, ...args);
-        }
-    }
-    
-    static warn(message, ...args) {
-        if (globalConfig.shouldLog('warn')) {
-            console.warn(`[LID/JID Warning] ${message}`, ...args);
-        }
-    }
-    
-    static info(message, ...args) {
-        if (globalConfig.shouldLog('info')) {
-            console.info(`[LID/JID Info] ${message}`, ...args);
-        }
-    }
-    
-    static debug(message, ...args) {
-        if (globalConfig.shouldLog('debug')) {
-            console.debug(`[LID/JID Debug] ${message}`, ...args);
-        }
-    }
-    
-    static performance(message, ...args) {
-        if (globalConfig.debug.enablePerformanceLogging) {
-            console.log(`[LID/JID Performance] ${message}`, ...args);
-        }
-    }
-}
-
-exports.Logger = Logger;
-exports.PerformanceConfig = PerformanceConfig;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceConfig = exports.setPerformanceConfig = exports.getPerformanceConfig = void 0;
+
+/**
+ * Configurazione performance per ottimizzazioni LID/JID
+ */
+class PerformanceConfig {
+    constructor() {
+        // Cache settings
+        this.cache = {
+            lidCache: {
+                ttl: 5 * 60 * 1000, // 5 minuti
+                maxSize: 10000,
+                cleanupInterval: 2 * 60 * 1000 // 2 minuti
+            },
+            jidCache: {
+                ttl: 5 * 60 * 1000, // 5 minuti
+                maxSize: 10000,
+                cleanupInterval: 2 * 60 * 1000 // 2 minuti
+            },
+            lidToJidCache: {
+                ttl: 5 * 60 * 1000, // 5 minuti
+                maxSize: 5000,
+                cleanupInterval: 3 * 60 * 1000 // 3 minuti
+            }
+        };
+        
+        // Performance settings
+        this.performance = {
+            enableCache: true,
+            enableLogging: false,
+            enableMetrics: false,
+            batchSize: 100,
+            maxRetries: 5,
+            retryDelay: 1000,
+            retryBackoffMultiplier: 1.5,
+            maxRetryDelay: 30000,
+            memoryThreshold: 0.85 // 85% memory usage threshold
+        };
+        
+        // Debug settings
+        this.debug = {
+            enableLidLogging: process.env.DEBUG_LID === 'true',
+            enablePerformanceLogging: process.env.DEBUG_PERFORMANCE === 'true',
+            enableErrorLogging: true,
+            logLevel: process.env.LOG_LEVEL || 'error'
+        };
+    }
+    
+    /**
+     * Aggiorna configurazione cache
+     */
+    updateCacheConfig(cacheType, config) {
+        if (this.cache[cacheType]) {
+            this.cache[cacheType] = { ...this.cache[cacheType], ...config };
+        }
+    }
+    
+    /**
+     * Aggiorna configurazione performance
+     */
+    updatePerformanceConfig(config) {
+        this.performance = { ...this.performance, ...config };
+    }
+    
+    /**
+     * Aggiorna configurazione debug
+     */
+    updateDebugConfig(config) {
+        this.debug = { ...this.debug, ...config };
+    }
+    
+    /**
+     * Verifica se il logging è abilitato per un livello specifico
+     */
+    shouldLog(level) {
+        const levels = ['error', 'warn', 'info', 'debug'];
+        const currentLevelIndex = levels.indexOf(this.debug.logLevel);
+        const requestedLevelIndex = levels.indexOf(level);
+        return requestedLevelIndex <= currentLevelIndex;
+    }
+}
+
+// Istanza globale della configurazione
+let globalConfig = new PerformanceConfig();
+
+/**
+ * Ottieni la configurazione performance globale
+ */
+const getPerformanceConfig = () => globalConfig;
+exports.getPerformanceConfig = getPerformanceConfig;
+
+/**
+ * Imposta una nuova configurazione performance
+ */
+const setPerformanceConfig = (config) => {
+    if (config instanceof PerformanceConfig) {
+        globalConfig = config;
+    } else {
+        // Merge con configurazione esistente
+        if (config.cache) {
+            Object.keys(config.cache).forEach(key => {
+                globalConfig.updateCacheConfig(key, config.cache[key]);
+            });
+        }
+        if (config.performance) {
+            globalConfig.updatePerformanceConfig(config.performance);
+        }
+        if (config.debug) {
+            globalConfig.updateDebugConfig(config.debug);
+        }
+    }
+};
+exports.setPerformanceConfig = setPerformanceConfig;
+
+/**
+ * Utility per logging condizionale
+ */
+class Logger {
+    static error(message, ...args) {
+        if (globalConfig.shouldLog('error')) {
+            console.error(`[LID/JID Error] ${message}`, ...args);
+        }
+    }
+    
+    static warn(message, ...args) {
+        if (globalConfig.shouldLog('warn')) {
+            console.warn(`[LID/JID Warning] ${message}`, ...args);
+        }
+    }
+    
+    static info(message, ...args) {
+        if (globalConfig.shouldLog('info')) {
+            console.info(`[LID/JID Info] ${message}`, ...args);
+        }
+    }
+    
+    static debug(message, ...args) {
+        if (globalConfig.shouldLog('debug')) {
+            console.debug(`[LID/JID Debug] ${message}`, ...args);
+        }
+    }
+    
+    static performance(message, ...args) {
+        if (globalConfig.debug.enablePerformanceLogging) {
+            console.log(`[LID/JID Performance] ${message}`, ...args);
+        }
+    }
+}
+
+exports.Logger = Logger;
+exports.PerformanceConfig = PerformanceConfig;

package/lib/Utils/retry.js

@@ -1,66 +1,66 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.retryWithBackoff = void 0;
-
-async function sleep(ms, signal) {
-    return new Promise((resolve, reject) => {
-        const t = setTimeout(resolve, ms);
-        if (signal) {
-            const onAbort = () => {
-                clearTimeout(t);
-                reject(Object.assign(new Error('aborted'), { code: 'ABORT_ERR' }));
-            };
-            if (signal.aborted) {
-                onAbort();
-                return;
-            }
-            signal.addEventListener('abort', onAbort, { once: true });
-        }
-    });
-}
-
-function computeDelay(attempt, baseMs, maxMs, jitter) {
-    const exp = Math.min(maxMs, baseMs * Math.pow(2, attempt));
-    if (!jitter) return exp;
-    // full jitter strategy: random between 0 and exp
-    const rand = Math.random() * exp;
-    return Math.min(maxMs, rand);
-}
-
-async function retryWithBackoff(fn, opts = {}) {
-	const {
-		retries = 3,
-		baseMs = 300,
-		maxMs = 5000,
-		jitter = true,
-        timeoutPerAttemptMs,
-        signal,
-		onRetry,
-		shouldRetry
-	} = opts;
-	let lastErr;
-	for (let attempt = 0; attempt <= retries; attempt++) {
-		try {
-            if (timeoutPerAttemptMs && timeoutPerAttemptMs > 0) {
-                const ctrl = new AbortController();
-                const timer = setTimeout(() => ctrl.abort(), timeoutPerAttemptMs);
-                try {
-                    return await fn({ signal: ctrl.signal });
-                } finally {
-                    clearTimeout(timer);
-                }
-            }
-            return await fn({ signal });
-		} catch (err) {
-			lastErr = err;
-			if (attempt === retries) break;
-			if (shouldRetry && !shouldRetry(err)) break;
-			if (onRetry) {
-				try { onRetry(err, attempt + 1); } catch {}
-			}
-            await sleep(computeDelay(attempt, baseMs, maxMs, jitter), signal);
-		}
-	}
-	throw lastErr;
-}
-exports.retryWithBackoff = retryWithBackoff;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryWithBackoff = void 0;
+
+async function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, ms);
+        if (signal) {
+            const onAbort = () => {
+                clearTimeout(t);
+                reject(Object.assign(new Error('aborted'), { code: 'ABORT_ERR' }));
+            };
+            if (signal.aborted) {
+                onAbort();
+                return;
+            }
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+    });
+}
+
+function computeDelay(attempt, baseMs, maxMs, jitter) {
+    const exp = Math.min(maxMs, baseMs * Math.pow(2, attempt));
+    if (!jitter) return exp;
+    // full jitter strategy: random between 0 and exp
+    const rand = Math.random() * exp;
+    return Math.min(maxMs, rand);
+}
+
+async function retryWithBackoff(fn, opts = {}) {
+	const {
+		retries = 3,
+		baseMs = 300,
+		maxMs = 5000,
+		jitter = true,
+        timeoutPerAttemptMs,
+        signal,
+		onRetry,
+		shouldRetry
+	} = opts;
+	let lastErr;
+	for (let attempt = 0; attempt <= retries; attempt++) {
+		try {
+            if (timeoutPerAttemptMs && timeoutPerAttemptMs > 0) {
+                const ctrl = new AbortController();
+                const timer = setTimeout(() => ctrl.abort(), timeoutPerAttemptMs);
+                try {
+                    return await fn({ signal: ctrl.signal });
+                } finally {
+                    clearTimeout(timer);
+                }
+            }
+            return await fn({ signal });
+		} catch (err) {
+			lastErr = err;
+			if (attempt === retries) break;
+			if (shouldRetry && !shouldRetry(err)) break;
+			if (onRetry) {
+				try { onRetry(err, attempt + 1); } catch {}
+			}
+            await sleep(computeDelay(attempt, baseMs, maxMs, jitter), signal);
+		}
+	}
+	throw lastErr;
+}
+exports.retryWithBackoff = retryWithBackoff;

package/lib/WABinary/decode.js

@@ -148,19 +148,33 @@ const decodeDecompressedBinaryNode = (buffer, opts, indexRef = { index: 0 }) =>
         }
     };
     const readJidPair = () => {
-        const i = readString(readByte());
-        const j = readString(readByte());
-        if (j) {
-            return (i || '') + '@' + j;
+        try {
+            const i = readString(readByte());
+            const j = readString(readByte());
+            if (typeof j === 'string' && j.length > 0) {
+                return (i || '') + '@' + j;
+            }
+            throw new Error(`invalid jid pair: ${i || '<empty>'}, ${j || '<empty>'}`);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse JID pair: ${err && err.message ? err.message : err}`);
         }
-        throw new Error('invalid jid pair: ' + i + ', ' + j);
     };
     const readAdJid = () => {
-        const rawDomainType = readByte();
-        const domainType = Number(rawDomainType);
-        const device = readByte();
-        const user = readString(readByte());
-        return (0, jid_utils_1.jidEncode)(user, domainType === 0 || domainType === 128 ? 's.whatsapp.net' : 'lid', device);
+        try {
+            const rawDomainType = readByte();
+            const domainType = Number(rawDomainType);
+            if (Number.isNaN(domainType))
+                throw new Error('invalid domain type');
+            const device = readByte();
+            const user = readString(readByte());
+            if (typeof user !== 'string')
+                throw new Error('invalid user in AD JID');
+            return (0, jid_utils_1.jidEncode)(user, domainType === 0 || domainType === 128 ? 's.whatsapp.net' : 'lid', device);
+        }
+        catch (err) {
+            throw new Error(`Failed to parse AD_JID: ${err && err.message ? err.message : err}`);
+        }
     };
     const readString = (tag) => {
         if (tag >= 1 && tag < SINGLE_BYTE_TOKENS.length) {

package/lib/WABinary/encode.js

@@ -78,6 +78,9 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         pushBytes(bytes);
     };
     const writeJid = ({ domainType, device, user, server }) => {
+        if (typeof user !== 'string' || typeof server !== 'string') {
+            throw new Error(`Invalid JID to write: user=${String(user)}, server=${String(server)}`);
+        }
         if (typeof device !== 'undefined') {
             pushByte(TAGS.AD_JID);
             pushByte(domainType || 0);
@@ -126,8 +129,11 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
         throw new Error(`Invalid hex char "${char}"`);
     };
     const writePackedBytes = (str, type) => {
+        if (typeof str !== 'string') {
+            throw new Error('writePackedBytes expects a string');
+        }
         if (str.length > TAGS.PACKED_MAX) {
-            throw new Error('Too many bytes to pack');
+            throw new Error(`Too many bytes to pack: ${str.length} > ${TAGS.PACKED_MAX}`);
         }
         pushByte(type === 'nibble' ? TAGS.NIBBLE_8 : TAGS.HEX_8);
         let roundedLength = Math.ceil(str.length / 2.0);
@@ -179,6 +185,14 @@ const encodeBinaryNodeInner = ({ tag, attrs, content }, opts, buffer) => {
             pushByte(TAGS.LIST_EMPTY);
             return;
         }
+        if (typeof str !== 'string') {
+            // allow decoded JID objects below, but not other types
+            const decoded = (0, jid_utils_1.jidDecode)(str);
+            if (!decoded) {
+                throw new Error(`writeString expects string or decodable JID, got ${typeof str}`);
+            }
+            // fallthrough to handle decoded JID
+        }
         const tokenIndex = TOKEN_MAP[str];
         if (tokenIndex) {
             if (typeof tokenIndex.dict === 'number') {