violetics 7.0.12-alpha → 7.0.13-alpha

package/lib/Socket/Client/websocket.js

@@ -5,11 +5,7 @@ export class WebSocketClient extends AbstractSocketClient {
     constructor() {
         super(...arguments);
         this.socket = null;
-        this.reconnectAttempts = 0;
-        this.maxReconnectAttempts = this.config.maxReconnectAttempts || 5;
-        this.reconnectDelay = this.config.reconnectDelay || 1000;
-        this.maxReconnectDelay = this.config.maxReconnectDelay || 30000;
-        this.reconnecting = false;
+        this.socketListeners = new Map();
     }
     get isOpen() {
         return this.socket?.readyState === WebSocket.OPEN;
@@ -24,10 +20,9 @@ export class WebSocketClient extends AbstractSocketClient {
         return this.socket?.readyState === WebSocket.CONNECTING;
     }
     connect() {
-        if (this.socket && !this.isClosed) {
+        if (this.socket) {
             return;
         }
-        this.reconnecting = false;
         this.socket = new WebSocket(this.url, {
             origin: DEFAULT_ORIGIN,
             headers: this.config.options?.headers,
@@ -38,74 +33,29 @@ export class WebSocketClient extends AbstractSocketClient {
         this.socket.setMaxListeners(0);
         const events = ['close', 'error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response'];
         for (const event of events) {
-            this.socket?.on(event, (...args) => this.emit(event, ...args));
+            const handler = (...args) => this.emit(event, ...args);
+            this.socketListeners.set(event, handler);
+            this.socket?.on(event, handler);
         }
-        
-        // Handle close to attempt reconnect
-        this.socket.on('close', (code, reason) => {
-            this.emit('close', code, reason);
-            this.attemptReconnect(code, reason);
-        });
     }
-    
-    async attemptReconnect(code, reason) {
-        // Don't reconnect if intentionally closed or max attempts reached
-        if (this.reconnecting || code === 1000 || this.reconnectAttempts >= this.maxReconnectAttempts) {
-            return;
-        }
-        
-        this.reconnecting = true;
-        const delay = Math.min(
-            this.reconnectDelay * Math.pow(2, this.reconnectAttempts),
-            this.maxReconnectDelay
-        );
-        
-        this.emit('reconnecting', {
-            attempt: this.reconnectAttempts + 1,
-            maxAttempts: this.maxReconnectAttempts,
-            delay,
-            code,
-            reason: reason?.toString() || 'Connection closed'
-        });
-        
-        await new Promise(resolve => setTimeout(resolve, delay));
-        
-        this.reconnectAttempts++;
-        this.reconnecting = false;
-        
-        // Reconnect
-        this.connect();
-    }
-    
     async close() {
-        this.reconnecting = false;
-        this.reconnectAttempts = 0;
-        
         if (!this.socket) {
             return;
         }
+        for (const [event, handler] of this.socketListeners) {
+            this.socket.removeListener(event, handler);
+        }
+        this.socketListeners.clear();
         const closePromise = new Promise(resolve => {
             this.socket?.once('close', resolve);
         });
-        this.socket.close(1000, 'Intentional close');
+        this.socket.close();
         await closePromise;
         this.socket = null;
     }
-    
     send(str, cb) {
         this.socket?.send(str, cb);
         return Boolean(this.socket);
     }
-    
-    get connectionStats() {
-        return {
-            isOpen: this.isOpen,
-            isClosed: this.isClosed,
-            isConnecting: this.isConnecting,
-            reconnectAttempts: this.reconnectAttempts,
-            maxReconnectAttempts: this.maxReconnectAttempts,
-            isReconnecting: this.reconnecting
-        };
-    }
 }
 //# sourceMappingURL=websocket.js.map

package/lib/Socket/chats.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { Boom } from '@hapi/boom';
 import { proto } from '../../WAProto/index.js';
 import { DEFAULT_CACHE_TTLS, PROCESSABLE_HISTORY_TYPES } from '../Defaults/index.js';
@@ -29,9 +29,10 @@ export const makeChatsSocket = (config) => {
     // Timeout for AwaitingInitialSync state
     let awaitingSyncTimeout;
     const placeholderResendCache = config.placeholderResendCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000, // 1 hour
+            allowStale: false
         });
     if (!config.placeholderResendCache) {
         config.placeholderResendCache = placeholderResendCache;

package/lib/Socket/messages-recv.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import Long from 'long';
@@ -18,31 +18,28 @@ export const makeMessagesRecvSocket = (config) => {
     /** this mutex ensures that each retryRequest will wait for the previous one to finish */
     const retryMutex = makeMutex();
     const msgRetryCache = config.msgRetryCounterCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false,
-            checkperiod: 300, // Check every 5 min
-            maxKeys: 10000 // Limit to prevent memory bloat
+        new LRUCache({
+            max: 10000,
+            ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000,
+            allowStale: false
         });
     const callOfferCache = config.callOfferCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER, // 5 mins
-            useClones: false,
-            checkperiod: 60,
-            maxKeys: 5000
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.CALL_OFFER * 1000,
+            allowStale: false
         });
     const placeholderResendCache = config.placeholderResendCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false,
-            checkperiod: 300,
-            maxKeys: 5000
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.MSG_RETRY * 1000,
+            allowStale: false
         });
     // Debounce identity-change session refreshes per JID to avoid bursts
-    const identityAssertDebounce = new NodeCache({ 
-        stdTTL: 10, 
-        useClones: false,
-        maxKeys: 1000
+    const identityAssertDebounce = new LRUCache({ 
+        max: 1000, 
+        ttl: 10000,
+        allowStale: false
     });
     let sendActiveReceipts = false;
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
@@ -1677,12 +1674,16 @@ export const makeMessagesRecvSocket = (config) => {
             sendActiveReceipts = isOnline;
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
-        // Clean up caches on disconnect
+        // Clean up caches on disconnect - LRU cache will expire naturally, but we can reset
         if (connection === 'close' || connection === 'loggedOut') {
-            msgRetryCache.flush();
-            placeholderResendCache.flush();
-            identityAssertDebounce.flush();
-            logger.debug('flushed message caches on disconnect');
+            try {
+                // LRU cache doesn't have clear(), but TTL handles expiration
+                // We can reset by creating new cache instances if needed
+                // For now just log that disconnection happened
+                logger.debug('connection closed, caches will expire via TTL');
+            } catch (e) {
+                logger.warn({ err: e }, 'error in cache cleanup');
+            }
         }
     });
     return {

package/lib/Socket/messages-send.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { Boom } from '@hapi/boom';
 import { randomBytes } from 'crypto';
 import { proto } from '../../WAProto/index.js';
@@ -20,13 +20,15 @@ export const makeMessagesSocket = (config) => {
     const sock = makeNewsletterSocket(config);
     const { ev, authState, messageMutex, signalRepository, upsertMessage, query, fetchPrivacySettings, sendNode, groupMetadata, groupToggleEphemeral } = sock;
     const userDevicesCache = config.userDevicesCache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES, // 5 minutes
-            useClones: false
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.USER_DEVICES * 1000, // 5 minutes
+            allowStale: false
         });
-    const peerSessionsCache = new NodeCache({
-        stdTTL: DEFAULT_CACHE_TTLS.USER_DEVICES,
-        useClones: false
+    const peerSessionsCache = new LRUCache({
+        max: 5000,
+        ttl: DEFAULT_CACHE_TTLS.USER_DEVICES * 1000,
+        allowStale: false
     });
     // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null;

package/lib/Socket/socket.js

@@ -280,6 +280,8 @@ export const makeSocket = (config) => {
     let keepAliveReq;
     let qrTimer;
     let closed = false;
+    let consecutivePingFailures = 0;
+    const MAX_PING_FAILURES = 3;
     /** log & process any unexpected errors */
     const onUnexpectedError = (err, msg) => {
         logger.error({ err }, `unexpected error in '${msg}'`);
@@ -490,44 +492,32 @@ export const makeSocket = (config) => {
             return;
         }
         closed = true;
-        
-        const disconnectReason = error?.output?.statusCode;
-        const isLogout = disconnectReason === DisconnectReason.loggedOut;
-        
-        logger.info({ 
-            trace: error?.stack, 
-            reason: disconnectReason,
-            isLogout 
-        }, error ? 'connection errored' : 'connection closed');
-        
-        clearInterval(keepAliveReq);
+        logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
+        clearTimeout(keepAliveReq);
         clearTimeout(qrTimer);
-        
-        // Clean up event listeners but preserve reconnect listener
-        ws.removeAllListeners('close');
-        ws.removeAllListeners('open');
-        ws.removeAllListeners('message');
-        ws.removeAllListeners('reconnecting');
-        
-        // Only close websocket if not reconnecting
-        if (!ws.reconnecting && !ws.isClosed && !ws.isClosing) {
+        consecutivePingFailures = 0;
+        ws.removeAllListeners();
+        if (ev.isBuffering()) {
+            ev.flush();
+        }
+        if (!ws.isClosed && !ws.isClosing) {
             try {
-                await ws.close();
+                await Promise.race([
+                    ws.close(),
+                    new Promise(resolve => setTimeout(resolve, 5000))
+                ]);
             }
             catch { }
         }
-        
-        // Emit final connection update
         ev.emit('connection.update', {
-            connection: isLogout ? 'loggedOut' : 'close',
+            connection: 'close',
             lastDisconnect: {
                 error,
                 date: new Date()
-            },
-            isOnline: false
+            }
         });
-        
-        ev.removeAllListeners('connection.update');
+        noise.destroy();
+        ev.removeAllListeners();
     };
     const waitForSocketOpen = async () => {
         if (ws.isOpen) {
@@ -550,42 +540,57 @@ export const makeSocket = (config) => {
             ws.off('error', onClose);
         });
     };
-    const startKeepAliveRequest = () => (keepAliveReq = setInterval(() => {
-        if (!lastDateRecv) {
-            lastDateRecv = new Date();
-        }
-        const diff = Date.now() - lastDateRecv.getTime();
-        /*
-            check if it's been a suspicious amount of time since the server responded with our last seen
-            it could be that the network is down
-        */
-        if (diff > keepAliveIntervalMs + 60000) {
-            // Don't trigger disconnect if we're in reconnecting state
-            if (ws.reconnecting) {
-                logger.debug('skipping keepalive disconnect - reconnecting');
-                return;
-            }
-            void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
-        }
-        else if (ws.isOpen) {
-            // if its all good, send a keep alive request
-            query({
-                tag: 'iq',
-                attrs: {
-                    id: generateMessageTag(),
-                    to: S_WHATSAPP_NET,
-                    type: 'get',
-                    xmlns: 'w:p'
-                },
-                content: [{ tag: 'ping', attrs: {} }]
-            }).catch(err => {
-                logger.error({ trace: err.stack }, 'error in sending keep alive');
-            });
-        }
-        else {
-            logger.warn('keep alive called when WS not open');
-        }
-    }, keepAliveIntervalMs));
+    const startKeepAliveRequest = () => {
+        const scheduleNextPing = () => {
+            keepAliveReq = setTimeout(async () => {
+                if (closed) {
+                    return;
+                }
+                if (!lastDateRecv) {
+                    lastDateRecv = new Date();
+                }
+                const diff = Date.now() - lastDateRecv.getTime();
+                if (diff > keepAliveIntervalMs * 2 + 5000) {
+                    logger.warn({ diff, keepAliveIntervalMs }, 'connection silent for too long');
+                    void end(new Boom('Connection was lost', { statusCode: DisconnectReason.connectionLost }));
+                    return;
+                }
+                if (ws.isOpen) {
+                    try {
+                        await query({
+                            tag: 'iq',
+                            attrs: {
+                                id: generateMessageTag(),
+                                to: S_WHATSAPP_NET,
+                                type: 'get',
+                                xmlns: 'w:p'
+                            },
+                            content: [{ tag: 'ping', attrs: {} }]
+                        });
+                        consecutivePingFailures = 0;
+                    }
+                    catch (err) {
+                        consecutivePingFailures++;
+                        logger.error({ trace: err.stack, consecutivePingFailures, maxFailures: MAX_PING_FAILURES }, 'error in sending keep alive');
+                        if (consecutivePingFailures >= MAX_PING_FAILURES) {
+                            logger.warn('max ping failures reached, terminating connection');
+                            void end(new Boom('Connection was lost (ping failures)', {
+                                statusCode: DisconnectReason.connectionLost
+                            }));
+                            return;
+                        }
+                    }
+                }
+                else {
+                    logger.warn('keep alive called when WS not open');
+                }
+                if (!closed) {
+                    scheduleNextPing();
+                }
+            }, keepAliveIntervalMs);
+        };
+        scheduleNextPing();
+    };
     /** i have no idea why this exists. pls enlighten me */
     const sendPassiveIq = (tag) => query({
         tag: 'iq',
@@ -1013,7 +1018,13 @@ export const makeSocket = (config) => {
         waitForConnectionUpdate: bindWaitForConnectionUpdate(ev),
         sendWAMBuffer,
         executeUSyncQuery,
-        onWhatsApp
+        onWhatsApp,
+        get connectionHealth() {
+            return {
+                lastMessageReceived: lastDateRecv,
+                consecutivePingFailures
+            };
+        }
     };
 };
 /**

package/lib/Types/index.js

@@ -23,5 +23,8 @@ export var DisconnectReason;
     DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
     DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
     DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
+    DisconnectReason[DisconnectReason["streamReplaced"] = 405] = "streamReplaced";
+    DisconnectReason[DisconnectReason["conflict"] = 409] = "conflict";
+    DisconnectReason[DisconnectReason["preconditionFailed"] = 412] = "preconditionFailed";
 })(DisconnectReason || (DisconnectReason = {}));
 //# sourceMappingURL=index.js.map

package/lib/Utils/auth-utils.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { AsyncLocalStorage } from 'async_hooks';
 import { Mutex } from 'async-mutex';
 import { randomBytes } from 'crypto';
@@ -15,10 +15,10 @@ import { PreKeyManager } from './pre-key-manager.js';
  */
 export function makeCacheableSignalKeyStore(store, logger, _cache) {
     const cache = _cache ||
-        new NodeCache({
-            stdTTL: DEFAULT_CACHE_TTLS.SIGNAL_STORE, // 5 minutes
-            useClones: false,
-            deleteOnExpire: true
+        new LRUCache({
+            max: 5000,
+            ttl: DEFAULT_CACHE_TTLS.SIGNAL_STORE * 1000, // 5 minutes
+            allowStale: false
         });
     // Mutex for protecting cache operations
     const cacheMutex = new Mutex();

package/lib/Utils/event-buffer.js

@@ -30,11 +30,9 @@ export const makeEventBuffer = (logger, config = {}) => {
     let bufferTimeout = null;
     let flushPendingTimeout = null;
     let bufferCount = 0;
-    
-    // Make limits configurable
-    const MAX_HISTORY_CACHE_SIZE = config.maxHistoryCacheSize || 15000;
+    let activeBufferedTimeouts = new Set();
+    const MAX_HISTORY_CACHE_SIZE = config.maxHistoryCacheSize || 10000;
     const BUFFER_TIMEOUT_MS = config.bufferTimeoutMs || 30000;
-    const MAX_BUFFER_COUNT = config.maxBufferCount || 10000;
     // take the generic event and fire it as a baileys event
     ev.on('event', (map) => {
         for (const event in map) {
@@ -152,13 +150,14 @@ export const makeEventBuffer = (logger, config = {}) => {
                 buffer();
                 try {
                     const result = await work(...args);
-                    // If this is the only buffer, flush after a small delay
                     if (bufferCount === 1) {
-                        setTimeout(() => {
+                        const t = setTimeout(() => {
+                            activeBufferedTimeouts.delete(t);
                             if (isBuffering && bufferCount === 1) {
                                 flush();
                             }
-                        }, 100); // Small delay to allow nested buffers
+                        }, 100);
+                        activeBufferedTimeouts.add(t);
                     }
                     return result;
                 }
@@ -168,7 +167,6 @@ export const makeEventBuffer = (logger, config = {}) => {
                 finally {
                     bufferCount = Math.max(0, bufferCount - 1);
                     if (bufferCount === 0) {
-                        // Only schedule ONE timeout, not 10,000
                         if (!flushPendingTimeout) {
                             flushPendingTimeout = setTimeout(flush, 100);
                         }
@@ -178,7 +176,25 @@ export const makeEventBuffer = (logger, config = {}) => {
         },
         on: (...args) => ev.on(...args),
         off: (...args) => ev.off(...args),
-        removeAllListeners: (...args) => ev.removeAllListeners(...args)
+        removeAllListeners: (...args) => {
+            if (bufferTimeout) {
+                clearTimeout(bufferTimeout);
+                bufferTimeout = null;
+            }
+            if (flushPendingTimeout) {
+                clearTimeout(flushPendingTimeout);
+                flushPendingTimeout = null;
+            }
+            for (const t of activeBufferedTimeouts) {
+                clearTimeout(t);
+            }
+            activeBufferedTimeouts.clear();
+            isBuffering = false;
+            bufferCount = 0;
+            historyCache.clear();
+            data = makeBufferData();
+            return ev.removeAllListeners(...args);
+        }
     };
 };
 const makeBufferData = () => {

package/lib/Utils/generics.js

@@ -281,7 +281,10 @@ export const getStatusFromReceiptType = (type) => {
     return status;
 };
 const CODE_MAP = {
-    conflict: DisconnectReason.connectionReplaced
+    conflict: DisconnectReason.connectionReplaced,
+    'stream-replaced': DisconnectReason.streamReplaced,
+    conflict: DisconnectReason.conflict,
+    'precondition-failed': DisconnectReason.preconditionFailed
 };
 /**
  * Stream errors generally provide a reason, map that to a baileys DisconnectReason

package/lib/Utils/identity-change-handler.js

@@ -1,4 +1,4 @@
-import NodeCache from '@cacheable/node-cache';
+import { LRUCache } from 'lru-cache';
 import { areJidsSameUser, getBinaryNodeChild, jidDecode } from '../WABinary/index.js';
 import { isStringNullOrEmpty } from './generics.js';
 export async function handleIdentityChange(node, ctx) {

package/lib/Utils/noise-handler.js

@@ -5,6 +5,7 @@ import { decodeBinaryNode } from '../WABinary/index.js';
 import { aesDecryptGCM, aesEncryptGCM, Curve, hkdf, sha256 } from './crypto.js';
 const IV_LENGTH = 12;
 const EMPTY_BUFFER = Buffer.alloc(0);
+const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB max buffer cap
 const generateIV = (counter) => {
     const iv = new ArrayBuffer(IV_LENGTH);
     new DataView(iv).setUint32(8, counter);
@@ -194,7 +195,18 @@ export const makeNoiseHandler = ({ keyPair: { private: privateKey, public: publi
             else {
                 inBytes = Buffer.concat([inBytes, newData]);
             }
+            if (inBytes.length > MAX_BUFFER_SIZE) {
+                logger.error({ bufferSize: inBytes.length }, 'noise handler buffer exceeded max size, clearing');
+                inBytes = Buffer.alloc(0);
+                return;
+            }
             await processData(onFrame);
+        },
+        destroy: () => {
+            inBytes = Buffer.alloc(0);
+            transport = null;
+            pendingOnFrame = null;
+            isWaitingForTransport = false;
         }
     };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "violetics",
   "type": "module",
-  "version": "7.0.12-alpha",
+  "version": "7.0.13-alpha",
   "description": "A WebSockets library for interacting with WhatsApp Web",
   "keywords": [
     "whatsapp",