violetics 7.0.11-alpha → 7.0.12-alpha

package/lib/Defaults/index.js

@@ -47,13 +47,13 @@ export const DEFAULT_CONNECTION_CONFIG = {
     version: version,
     browser: Browsers.macOS('Chrome'),
     waWebSocketUrl: 'wss://web.whatsapp.com/ws/chat',
-    connectTimeoutMs: 60000,
-    keepAliveIntervalMs: 30000,
+    connectTimeoutMs: 45000, // 45 seconds - faster than 60s
+    keepAliveIntervalMs: 20000, // 20 seconds - faster disconnect detection
     logger: logger.child({ class: 'baileys' }),
     emitOwnEvents: true,
-    defaultQueryTimeoutMs: 90000,
+    defaultQueryTimeoutMs: 60000, // 60 seconds - reduced from 90s
     customUploadHosts: [],
-    retryRequestDelayMs: 250,
+    retryRequestDelayMs: 200, // Faster retry (was 250ms)
     maxMsgRetryCount: 5,
     fireInitQueries: true,
     auth: undefined,
@@ -77,7 +77,21 @@ export const DEFAULT_CONNECTION_CONFIG = {
     countryCode: 'US',
     getMessage: async () => undefined,
     cachedGroupMetadata: async () => undefined,
-    makeSignalRepository: makeLibSignalRepository
+    makeSignalRepository: makeLibSignalRepository,
+    
+    // New connection stability options
+    maxReconnectAttempts: 5,
+    reconnectDelay: 2000,
+    maxReconnectDelay: 30000,
+    
+    // Memory management options
+    maxMessagesPerChat: 2000,
+    maxChats: 10000,
+    maxContacts: 20000,
+    messageCleanupIntervalMs: 5 * 60 * 1000, // 5 minutes
+    maxHistoryCacheSize: 15000,
+    bufferTimeoutMs: 30000,
+    maxBufferCount: 10000
 };
 export const MEDIA_PATH_MAP = {
     image: '/mms/image',

package/lib/Socket/Client/websocket.js

@@ -5,6 +5,11 @@ 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;
     }
     get isOpen() {
         return this.socket?.readyState === WebSocket.OPEN;
@@ -19,9 +24,10 @@ export class WebSocketClient extends AbstractSocketClient {
         return this.socket?.readyState === WebSocket.CONNECTING;
     }
     connect() {
-        if (this.socket) {
+        if (this.socket && !this.isClosed) {
             return;
         }
+        this.reconnecting = false;
         this.socket = new WebSocket(this.url, {
             origin: DEFAULT_ORIGIN,
             headers: this.config.options?.headers,
@@ -34,21 +40,72 @@ export class WebSocketClient extends AbstractSocketClient {
         for (const event of events) {
             this.socket?.on(event, (...args) => this.emit(event, ...args));
         }
+        
+        // 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;
         }
         const closePromise = new Promise(resolve => {
             this.socket?.once('close', resolve);
         });
-        this.socket.close();
+        this.socket.close(1000, 'Intentional 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/messages-recv.js

@@ -20,20 +20,30 @@ export const makeMessagesRecvSocket = (config) => {
     const msgRetryCache = config.msgRetryCounterCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false
+            useClones: false,
+            checkperiod: 300, // Check every 5 min
+            maxKeys: 10000 // Limit to prevent memory bloat
         });
     const callOfferCache = config.callOfferCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.CALL_OFFER, // 5 mins
-            useClones: false
+            useClones: false,
+            checkperiod: 60,
+            maxKeys: 5000
         });
     const placeholderResendCache = config.placeholderResendCache ||
         new NodeCache({
             stdTTL: DEFAULT_CACHE_TTLS.MSG_RETRY, // 1 hour
-            useClones: false
+            useClones: false,
+            checkperiod: 300,
+            maxKeys: 5000
         });
     // Debounce identity-change session refreshes per JID to avoid bursts
-    const identityAssertDebounce = new NodeCache({ stdTTL: 5, useClones: false });
+    const identityAssertDebounce = new NodeCache({ 
+        stdTTL: 10, 
+        useClones: false,
+        maxKeys: 1000
+    });
     let sendActiveReceipts = false;
     const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
         if (!authState.creds.me?.id) {
@@ -1662,11 +1672,18 @@ export const makeMessagesRecvSocket = (config) => {
             await upsertMessage(protoMsg, call.offline ? 'append' : 'notify');
         }
     });
-    ev.on('connection.update', ({ isOnline }) => {
+    ev.on('connection.update', ({ isOnline, connection }) => {
         if (typeof isOnline !== 'undefined') {
             sendActiveReceipts = isOnline;
             logger.trace(`sendActiveReceipts set to "${sendActiveReceipts}"`);
         }
+        // Clean up caches on disconnect
+        if (connection === 'close' || connection === 'loggedOut') {
+            msgRetryCache.flush();
+            placeholderResendCache.flush();
+            identityAssertDebounce.flush();
+            logger.debug('flushed message caches on disconnect');
+        }
     });
     return {
         ...sock,

package/lib/Socket/socket.js

@@ -266,7 +266,11 @@ export const makeSocket = (config) => {
         }
         return [];
     };
-    const ev = makeEventBuffer(logger);
+    const ev = makeEventBuffer(logger, {
+        maxHistoryCacheSize: config.maxHistoryCacheSize,
+        bufferTimeoutMs: config.bufferTimeoutMs,
+        maxBufferCount: config.maxBufferCount
+    });
     const { creds } = authState;
     // add transaction capability
     const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
@@ -486,25 +490,43 @@ export const makeSocket = (config) => {
             return;
         }
         closed = true;
-        logger.info({ trace: error?.stack }, error ? 'connection errored' : 'connection closed');
+        
+        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);
         clearTimeout(qrTimer);
+        
+        // Clean up event listeners but preserve reconnect listener
         ws.removeAllListeners('close');
         ws.removeAllListeners('open');
         ws.removeAllListeners('message');
-        if (!ws.isClosed && !ws.isClosing) {
+        ws.removeAllListeners('reconnecting');
+        
+        // Only close websocket if not reconnecting
+        if (!ws.reconnecting && !ws.isClosed && !ws.isClosing) {
             try {
                 await ws.close();
             }
             catch { }
         }
+        
+        // Emit final connection update
         ev.emit('connection.update', {
-            connection: 'close',
+            connection: isLogout ? 'loggedOut' : 'close',
             lastDisconnect: {
                 error,
                 date: new Date()
-            }
+            },
+            isOnline: false
         });
+        
         ev.removeAllListeners('connection.update');
     };
     const waitForSocketOpen = async () => {
@@ -538,6 +560,11 @@ export const makeSocket = (config) => {
             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) {
@@ -571,27 +598,63 @@ export const makeSocket = (config) => {
     });
     /** logout & invalidate connection */
     const logout = async (msg) => {
+        logger.info({ msg }, 'initiating logout');
+        
+        // Prevent reconnect on logout
+        if (ws) {
+            ws.maxReconnectAttempts = 0;
+            ws.reconnecting = false;
+        }
+        
         const jid = authState.creds.me?.id;
-        if (jid) {
-            await sendNode({
-                tag: 'iq',
-                attrs: {
-                    to: S_WHATSAPP_NET,
-                    type: 'set',
-                    id: generateMessageTag(),
-                    xmlns: 'md'
-                },
-                content: [
-                    {
-                        tag: 'remove-companion-device',
-                        attrs: {
-                            jid,
-                            reason: 'user_initiated'
+        
+        // Try to send logout IQ to WA server
+        try {
+            if (jid) {
+                const logoutNode = {
+                    tag: 'iq',
+                    attrs: {
+                        to: S_WHATSAPP_NET,
+                        type: 'set',
+                        id: generateMessageTag(),
+                        xmlns: 'md'
+                    },
+                    content: [
+                        {
+                            tag: 'remove-companion-device',
+                            attrs: {
+                                jid,
+                                reason: 'user_initiated'
+                            }
                         }
-                    }
-                ]
-            });
+                    ]
+                };
+                await sendNode(logoutNode);
+                logger.info({ jid }, 'sent logout IQ to server');
+            }
+        } catch (e) {
+            logger.warn({ err: e }, 'failed to send logout IQ, continuing with local logout');
+        }
+        
+        // Emit proper logout event BEFORE ending connection
+        ev.emit('connection.update', {
+            connection: 'loggedOut',
+            lastDisconnect: {
+                error: new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }),
+                date: new Date()
+            },
+            isOnline: false,
+            qr: undefined
+        });
+        
+        // Clear sensitive credentials
+        if (authState.creds) {
+            authState.creds.me = undefined;
+            authState.creds.lid = undefined;
+            authState.creds.deviceName = undefined;
         }
+        
+        // End the connection
         void end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
     const requestPairingCode = async (phoneNumber, customPairingCode) => {
@@ -681,6 +744,8 @@ export const makeSocket = (config) => {
     };
     ws.on('message', onMessageReceived);
     ws.on('open', async () => {
+        // Reset reconnect attempts on successful connection
+        ws.reconnectAttempts = 0;
         try {
             await validateConnection();
         }
@@ -690,7 +755,26 @@ export const makeSocket = (config) => {
         }
     });
     ws.on('error', mapWebSocketError(end));
-    ws.on('close', () => void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed })));
+    ws.on('close', (code, reason) => {
+        // Check if reconnecting - if so, don't end the connection
+        if (ws.reconnecting) {
+            logger.info({ code, reason: reason?.toString() }, 'connection closed, waiting for reconnect');
+            return;
+        }
+        void end(new Boom('Connection Terminated', { statusCode: DisconnectReason.connectionClosed, data: { code, reason: reason?.toString() } }));
+    });
+    ws.on('reconnecting', (info) => {
+        ev.emit('connection.update', {
+            connection: 'reconnecting',
+            lastDisconnect: {
+                error: new Boom('Reconnecting', { statusCode: DisconnectReason.connectionClosed }),
+                date: new Date()
+            },
+            reconnectAttempt: info.attempt,
+            maxReconnectAttempts: info.maxAttempts,
+            reconnectDelay: info.delay
+        });
+    });
     // the server terminated the connection
     ws.on('CB:xmlstreamend', () => void end(new Boom('Connection Terminated by Server', { statusCode: DisconnectReason.connectionClosed })));
     // QR gen

package/lib/Store/make-in-memory-store.js

@@ -37,6 +37,75 @@ export const makeInMemoryStore = (config) => {
     const state = { connection: 'close' };
     const labels = new ObjectRepository();
     const labelAssociations = new KeyedDB(labelAssociationKey, labelAssociationKey.key);
+    
+    // Memory management - configurable limits
+    const MAX_MESSAGES_PER_CHAT = config.maxMessagesPerChat || 2000;
+    const MAX_CHATS = config.maxChats || 10000;
+    const MAX_CONTACTS = config.maxContacts || 20000;
+    const MESSAGE_CLEANUP_INTERVAL = config.messageCleanupIntervalMs || 5 * 60 * 1000; // 5 min
+    let cleanupTimer = null;
+    
+    // Check and enforce memory limits
+    const enforceMemoryLimits = () => {
+        // Cleanup old messages if exceeds limit
+        for (const jid in messages) {
+            const list = messages[jid];
+            if (list && list.array && list.array.length > MAX_MESSAGES_PER_CHAT) {
+                const excess = list.array.length - MAX_MESSAGES_PER_CHAT;
+                list.array.splice(0, excess);
+                logger.debug({ jid, removed: excess, remaining: list.array.length }, 'cleaned excess messages from chat');
+            }
+        }
+        
+        // Limit total chats
+        if (chats.length > MAX_CHATS) {
+            const toRemove = chats.length - MAX_CHATS;
+            const sortedChats = [...chats].sort((a, b) => {
+                const aTime = a.conversationTimestamp || 0;
+                const bTime = b.conversationTimestamp || 0;
+                return aTime - bTime;
+            });
+            for (let i = 0; i < toRemove; i++) {
+                const chatId = sortedChats[i]?.id;
+                if (chatId) {
+                    chats.deleteById(chatId);
+                    delete messages[chatId];
+                }
+            }
+            logger.debug({ removed: toRemove }, 'cleaned old chats due to memory limit');
+        }
+        
+        // Limit contacts
+        const contactIds = Object.keys(contacts);
+        if (contactIds.length > MAX_CONTACTS) {
+            const toRemove = contactIds.length - MAX_CONTACTS;
+            const sortedContacts = contactIds
+                .map(id => ({ id, contact: contacts[id] }))
+                .sort((a, b) => {
+                    const aTime = a.contact?.lastSeen || 0;
+                    const bTime = b.contact?.lastSeen || 0;
+                    return aTime - bTime;
+                });
+            for (let i = 0; i < toRemove; i++) {
+                delete contacts[sortedContacts[i].id];
+            }
+            logger.debug({ removed: toRemove }, 'cleaned old contacts due to memory limit');
+        }
+    };
+    
+    // Start periodic cleanup
+    const startMemoryCleanup = () => {
+        if (cleanupTimer) return;
+        cleanupTimer = setInterval(enforceMemoryLimits, MESSAGE_CLEANUP_INTERVAL);
+        cleanupTimer.unref(); // Don't block process exit
+    };
+    
+    const stopMemoryCleanup = () => {
+        if (cleanupTimer) {
+            clearInterval(cleanupTimer);
+            cleanupTimer = null;
+        }
+    };
     const assertMessageList = (jid) => {
         if (!messages[jid]) {
             messages[jid] = makeMessagesDictionary();
@@ -65,6 +134,13 @@ export const makeInMemoryStore = (config) => {
     const bind = (ev) => {
         ev.on('connection.update', update => {
             Object.assign(state, update);
+            
+            // Start cleanup when connected, stop when disconnected
+            if (update.connection === 'open') {
+                startMemoryCleanup();
+            } else if (update.connection === 'close' || update.connection === 'loggedOut') {
+                stopMemoryCleanup();
+            }
         });
         ev.on('messaging-history.set', ({ chats: newChats, contacts: newContacts, messages: newMessages, isLatest, syncType }) => {
             if (syncType === proto.HistorySync.HistorySyncType.ON_DEMAND) {
@@ -395,6 +471,44 @@ export const makeInMemoryStore = (config) => {
                 const json = JSON.parse(jsonStr);
                 fromJSON(json);
             }
+        },
+        /** Clear all stored data - useful for logout */
+        clear: () => {
+            chats.clear();
+            for (const key of Object.keys(messages)) {
+                delete messages[key];
+            }
+            for (const key of Object.keys(contacts)) {
+                delete contacts[key];
+            }
+            for (const key of Object.keys(groupMetadata)) {
+                delete groupMetadata[key];
+            }
+            for (const key of Object.keys(presences)) {
+                delete presences[key];
+            }
+            labels.clear();
+            labelAssociations.clear();
+            stopMemoryCleanup();
+            logger.info('Cleared all store data');
+        },
+        /** Get memory usage stats */
+        getMemoryStats: () => {
+            let totalMessages = 0;
+            for (const jid in messages) {
+                totalMessages += messages[jid]?.array?.length || 0;
+            }
+            return {
+                chats: chats.length,
+                messages: totalMessages,
+                contacts: Object.keys(contacts).length,
+                groups: Object.keys(groupMetadata).length,
+                labels: labels.count(),
+                labelAssociations: labelAssociations.length,
+                maxMessagesPerChat: MAX_MESSAGES_PER_CHAT,
+                maxChats: MAX_CHATS,
+                maxContacts: MAX_CONTACTS
+            };
         }
     };
 };

package/lib/Utils/event-buffer.js

@@ -22,16 +22,19 @@ const BUFFERABLE_EVENT_SET = new Set(BUFFERABLE_EVENT);
  * The event buffer logically consolidates different events into a single event
  * making the data processing more efficient.
  */
-export const makeEventBuffer = (logger) => {
+export const makeEventBuffer = (logger, config = {}) => {
     const ev = new EventEmitter();
     const historyCache = new Set();
     let data = makeBufferData();
     let isBuffering = false;
     let bufferTimeout = null;
-    let flushPendingTimeout = null; // Add a specific timer for the debounced flush to prevent leak
+    let flushPendingTimeout = null;
     let bufferCount = 0;
-    const MAX_HISTORY_CACHE_SIZE = 10000; // Limit the history cache size to prevent memory bloat
-    const BUFFER_TIMEOUT_MS = 30000; // 30 seconds
+    
+    // Make limits configurable
+    const MAX_HISTORY_CACHE_SIZE = config.maxHistoryCacheSize || 15000;
+    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) {
@@ -55,6 +58,12 @@ export const makeEventBuffer = (logger) => {
         }
         // Always increment count when requested
         bufferCount++;
+        
+        // Auto-flush if buffer count exceeds limit
+        if (bufferCount > MAX_BUFFER_COUNT) {
+            logger.debug({ bufferCount }, 'buffer count exceeded limit, auto-flushing');
+            flush();
+        }
     }
     function flush() {
         if (!isBuffering) {

package/package.json

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