@nexustechpro/baileys 1.1.5 → 1.1.9

package/lib/Socket/Client/websocket.js

@@ -2,57 +2,310 @@ import WebSocket from 'ws'
 import { DEFAULT_ORIGIN } from '../../Defaults/index.js'
 import { AbstractSocketClient } from './types.js'
 
+// ==================== CONSTANTS ====================
+const CONSTANTS = {
+  MIN_SEND_INTERVAL_MS: 50,
+  MAX_RECONNECT_ATTEMPTS: 5,
+  INITIAL_RECONNECT_DELAY: 1000,
+  MAX_RECONNECT_DELAY: 30000,
+  RECONNECT_BACKOFF_MULTIPLIER: 2
+}
+
+// ==================== WEBSOCKET CLIENT ====================
 export class WebSocketClient extends AbstractSocketClient {
-  socket = null
+  constructor() {
+    super(...arguments)
+    
+    // Core socket
+    this.socket = null
+    
+    // Message queue
+    this._queue = []
+    this._isDispatching = false
+    this._lastDispatch = 0
+    this._minSendIntervalMs = CONSTANTS.MIN_SEND_INTERVAL_MS
+    
+    // Reconnection state
+    this._reconnectTimeout = null
+    this._reconnectAttempts = 0
+    this._maxReconnectAttempts = CONSTANTS.MAX_RECONNECT_ATTEMPTS
+    this._reconnectDelay = CONSTANTS.INITIAL_RECONNECT_DELAY
+    this._shouldReconnect = true
+    this._isManualClose = false
+    this._isReconnecting = false
+  }
 
+  // ==================== LOGGER ====================
+  get logger() {
+    return this.config?.logger || console
+  }
+
+  // ==================== CONNECTION STATE ====================
   get isOpen() {
     return this.socket?.readyState === WebSocket.OPEN
   }
 
   get isClosed() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSED
+    return !this.socket || this.socket.readyState === WebSocket.CLOSED
   }
 
   get isClosing() {
-    return this.socket === null || this.socket?.readyState === WebSocket.CLOSING
+    return !this.socket || this.socket.readyState === WebSocket.CLOSING
   }
 
   get isConnecting() {
     return this.socket?.readyState === WebSocket.CONNECTING
   }
 
-  connect() {
-    if (this.socket) return
+  // ==================== CONNECTION MANAGEMENT ====================
+  async connect() {
+    if (this.socket && !this.isClosed) {
+      this.logger.debug({ state: this.socket.readyState }, 'already connected or connecting')
+      return
+    }
+
+    try {
+      this.logger.debug('establishing websocket connection')
+      
+      this.socket = new WebSocket(this.url, {
+        origin: DEFAULT_ORIGIN,
+        headers: this.config.options?.headers,
+        handshakeTimeout: this.config.connectTimeoutMs,
+        timeout: this.config.connectTimeoutMs,
+        agent: this.config.agent
+      })
 
-    this.socket = new WebSocket(this.url, {
-      origin: DEFAULT_ORIGIN,
-      headers: this.config.options?.headers || {},
-      handshakeTimeout: this.config.connectTimeoutMs,
-      timeout: this.config.connectTimeoutMs,
-      agent: this.config.agent
-    })
+      if (!this.socket) {
+        throw new Error('WebSocket creation failed')
+      }
 
-    this.socket.setMaxListeners(0)
+      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))
+      // Forward all WebSocket events
+      const events = ['error', 'upgrade', 'message', 'open', 'ping', 'pong', 'unexpected-response']
+      events.forEach(e => {
+        this.socket?.on(e, (...args) => this.emit(e, ...args))
+      })
+
+      // Handle close with auto-reconnect
+      this.socket.on('close', (...args) => {
+        this.emit('close', ...args)
+        if (this._shouldReconnect && !this._isManualClose) {
+          this._attemptReconnect()
+        }
+      })
+
+      // Handle successful connection
+      this.socket.on('open', () => {
+        this.logger.info('websocket connection established')
+        this._reconnectAttempts = 0
+        this._reconnectDelay = CONSTANTS.INITIAL_RECONNECT_DELAY
+        this._isReconnecting = false
+
+        // Process any queued messages
+        if (this._queue.length > 0) {
+          this.logger.debug({ queueLength: this._queue.length }, 'processing queued messages')
+          this._dispatch()
+        }
+      })
+
+    } catch (error) {
+      this.logger.error({ error: error.message }, 'websocket connection failed')
+      this.socket = null
+      throw error
+    }
   }
 
   async close() {
-    if (!this.socket) return
-    const closePromise = new Promise(resolve => this.socket?.once('close', resolve))
-    this.socket.close()
-    await closePromise
+    this.logger.debug('closing websocket connection (manual)')
+    
+    this._isManualClose = true
+    this._shouldReconnect = false
+    this._isReconnecting = false
+
+    if (this._reconnectTimeout) {
+      clearTimeout(this._reconnectTimeout)
+      this._reconnectTimeout = null
+    }
+
+    this.socket?.close?.()
     this.socket = null
+    this._queue = []
   }
 
+  async restart() {
+    this.logger.info('restarting websocket connection')
+    
+    this._isManualClose = true
+    this._isReconnecting = false
+
+    // Force close existing connection
+    if (this.socket) {
+      await new Promise(resolve => {
+        this.socket.once('close', resolve)
+        this.socket.terminate()
+      })
+      this.socket = null
+    }
+
+    // Clear queue and reset state
+    this._queue = []
+    this._reconnectDelay = CONSTANTS.INITIAL_RECONNECT_DELAY
+    this._isManualClose = false
+    this._shouldReconnect = true
+
+    // Reconnect
+    await this.connect()
+  }
+
+  // ==================== RECONNECTION LOGIC ====================
+  _attemptReconnect() {
+    if (this._isReconnecting) {
+      this.logger.trace('reconnection already in progress')
+      return
+    }
+
+    if (this._reconnectAttempts >= this._maxReconnectAttempts) {
+      this.logger.error(
+        { attempts: this._reconnectAttempts, max: this._maxReconnectAttempts },
+        'max reconnect attempts reached'
+      )
+      this.emit('reconnect-failed')
+      return
+    }
+
+    if (this._reconnectTimeout) {
+      clearTimeout(this._reconnectTimeout)
+    }
+
+    this._isReconnecting = true
+    this._reconnectAttempts++
+
+    this.logger.info(
+      {
+        attempt: this._reconnectAttempts,
+        maxAttempts: this._maxReconnectAttempts,
+        delay: this._reconnectDelay
+      },
+      'attempting websocket reconnection'
+    )
+
+    this._reconnectTimeout = setTimeout(async () => {
+      try {
+        await this.connect()
+      } catch (error) {
+        this.logger.warn({ error: error.message }, 'reconnection attempt failed')
+        this._isReconnecting = false
+
+        if (this._reconnectAttempts < this._maxReconnectAttempts) {
+          this._attemptReconnect()
+        } else {
+          this.emit('reconnect-failed')
+        }
+      }
+    }, this._reconnectDelay)
+
+    // Exponential backoff with cap
+    this._reconnectDelay = Math.min(
+      this._reconnectDelay * CONSTANTS.RECONNECT_BACKOFF_MULTIPLIER,
+      CONSTANTS.MAX_RECONNECT_DELAY
+    )
+  }
+
+  // ==================== MESSAGE SENDING ====================
   send(str, cb) {
-    this.socket?.send(str, cb)
-    return Boolean(this.socket)
+    const doSend = () => {
+      // Handle closed/closing socket
+      if (this.isClosed || this.isClosing) {
+        this.logger.warn('socket closed, attempting reconnection')
+        
+        this._isManualClose = false
+        this._shouldReconnect = true
+        this._attemptReconnect()
+        this._queue.unshift(doSend) // Re-queue at front
+        
+        cb?.(new Error('Socket closed, reconnecting...'))
+        return false
+      }
+
+      // Check if socket is ready
+      if (!this.socket || !this.isOpen) {
+        cb?.(new Error('Socket not open'))
+        return false
+      }
+
+      // Send the message
+      try {
+        this.socket.send(str, cb)
+        return true
+      } catch (error) {
+        this.logger.error({ error: error.message }, 'failed to send message')
+        cb?.(error)
+        return false
+      }
+    }
+
+    this._queue.push(doSend)
+    this._dispatch()
+    return true
   }
 
-  async restart() {
-    await this.close()
-    this.connect()
+  // ==================== MESSAGE QUEUE DISPATCH ====================
+  _dispatch() {
+    // Don't dispatch if already dispatching or socket not ready
+    if (this._isDispatching || (!this.isOpen && !this.isConnecting)) {
+      return
+    }
+
+    const now = Date.now()
+    const elapsed = now - this._lastDispatch
+
+    // Check if enough time has passed and queue has items
+    if (this._queue.length && elapsed >= this._minSendIntervalMs) {
+      this._isDispatching = true
+      
+      const sendFn = this._queue.shift()
+      sendFn?.()
+      
+      this._lastDispatch = Date.now()
+      this._isDispatching = false
+
+      // Schedule next dispatch if queue not empty
+      if (this._queue.length) {
+        const nextDelay = Math.max(0, this._minSendIntervalMs - (Date.now() - this._lastDispatch))
+        setTimeout(() => this._dispatch(), nextDelay)
+      }
+    } else if (this._queue.length) {
+      // Schedule dispatch after required interval
+      const delay = Math.max(0, this._minSendIntervalMs - elapsed)
+      setTimeout(() => this._dispatch(), delay)
+    }
   }
-}
+
+  // ==================== PUBLIC CONTROL METHODS ====================
+  disableAutoReconnect() {
+    this.logger.info('auto-reconnect disabled')
+    this._shouldReconnect = false
+  }
+
+  enableAutoReconnect() {
+    this.logger.info('auto-reconnect enabled')
+    this._shouldReconnect = true
+    this._isManualClose = false
+  }
+
+  // Getters for external monitoring
+  get reconnectAttempts() {
+    return this._reconnectAttempts
+  }
+
+  get queueLength() {
+    return this._queue.length
+  }
+
+  get isReconnecting() {
+    return this._isReconnecting
+  }
+}
+
+export default WebSocketClient

package/lib/Socket/index.js

@@ -1,19 +1,23 @@
 import { DEFAULT_CONNECTION_CONFIG } from '../Defaults/index.js';
-import { makeCommunitiesSocket } from './communities.js';
+import { makeRegistrationSocket } from './registration.js';
 import NexusHandler from './nexus-handler.js';
+
 // export the last socket layer
 const makeWASocket = (config) => {
     const newConfig = {
         ...DEFAULT_CONNECTION_CONFIG,
         ...config
     };
+
     // If the user hasn't provided their own history sync function,
     // let's create a default one that respects the syncFullHistory flag.
     if (config.shouldSyncHistoryMessage === undefined) {
         newConfig.shouldSyncHistoryMessage = () => !!newConfig.syncFullHistory;
     }
-    return makeCommunitiesSocket(newConfig);
+
+    return makeRegistrationSocket(newConfig);
 };
+
 export { NexusHandler };
-export default makeWASocket;
-//# sourceMappingURL=index.js.map
+export { makeWASocket };
+export default makeWASocket;

package/lib/Socket/messages-recv.js

@@ -46,12 +46,12 @@ export const makeMessagesRecvSocket = (config) => {
 
   const handleMexNewsletterNotification = async (node) => {
     const mexNode = getBinaryNodeChild(node, "mex")
-    if (!mexNode?.content) { logger.warn({ node }, "Invalid mex newsletter notification"); return }
+    if (!mexNode?.content) { /*logger.warn({ node }, "Invalid mex newsletter notification");*/ return }
     let data
-    try { data = JSON.parse(mexNode.content.toString()) } catch (error) { logger.error({ err: error, node }, "Failed to parse mex newsletter notification"); return }
+    try { data = JSON.parse(mexNode.content.toString()) } catch (error) { /*logger.error({ err: error, node }, "Failed to parse mex newsletter notification");*/ return }
     const operation = data?.operation
     const updates = data?.updates
-    if (!updates || !operation) { logger.warn({ data }, "Invalid mex newsletter notification content"); return }
+    if (!updates || !operation) { /*logger.warn({ data }, "Invalid mex newsletter notification content");*/ return }
     logger.info({ operation, updates }, "got mex newsletter notification")
     switch (operation) {
       case "NotificationNewsletterUpdate":
@@ -459,9 +459,9 @@ export const makeMessagesRecvSocket = (config) => {
         if (shouldRecreateSession) { logger.debug({ participant, retryCount, reason: recreateReason }, "recreating session for outgoing retry"); await authState.keys.set({ session: { [sessionId]: null } }) }
       } catch (error) { logger.warn({ error, participant }, "failed to check session recreation for outgoing retry") }
     }
-    await assertSessions([participant], true)
+    await assertSessions([participant], false);
     if (isJidGroup(remoteJid)) await authState.keys.set({ "sender-key-memory": { [remoteJid]: null } })
-    logger.debug({ participant, sendToAll, shouldRecreateSession, recreateReason }, "forced new session for retry recp")
+    logger.debug({ participant, sendToAll, shouldRecreateSession, recreateReason }, "preparing retry recp")
     for (const [i, msg] of msgs.entries()) {
       if (!ids[i]) continue
       if (msg && (await willSendMessageAgain(ids[i], participant))) {
@@ -488,7 +488,7 @@ export const makeMessagesRecvSocket = (config) => {
       ids.push(...items.map((i) => i.attrs.id))
     }
     try {
-      await Promise.all([receiptMutex.mutex(async () => {
+      await Promise.all([processingMutex.mutex(async () => {
         const status = getStatusFromReceiptType(attrs.type)
         if (typeof status !== "undefined" && (status >= proto.WebMessageInfo.Status.SERVER_ACK || !isNodeFromMe)) {
           if (isJidGroup(remoteJid) || isJidStatusBroadcast(remoteJid)) {
@@ -509,7 +509,18 @@ export const makeMessagesRecvSocket = (config) => {
                 await sendMessagesAgain(key, ids, retryNode)
               } catch (error) { logger.error({ key, ids, trace: error instanceof Error ? error.stack : "Unknown error" }, "error in sending message again") }
             } else logger.info({ attrs, key }, "recv retry for not fromMe message")
-          } else logger.info({ attrs, key }, "will not send message again, as sent too many times")
+          } else {
+            logger.info({ attrs, key, participant: key.participant }, "retry limit exhausted - clearing broken session")
+            try {
+              await signalRepository.deleteSession([key.participant])
+              logger.debug({ participant: key.participant }, "deleted stale session for retry-exhausted participant")
+              const retryKey = `${ids[0]}:${key.participant}`
+              await msgRetryCache.del(retryKey)
+              logger.debug({ retryKey }, "cleared retry count cache")
+            } catch (err) {
+              logger.error({ err, participant: key.participant }, "failed to clear session/cache at retry exhaustion")
+            }
+          }
         }
       })])
     } finally {

package/lib/Socket/messages-send.js

@@ -122,7 +122,8 @@ export const makeMessagesSocket = (config) => {
             if (lidResults.length > 0) { logger.trace('Storing LID maps from device call'); await signalRepository.lidMapping.storeLIDPNMappings(lidResults.map(a => ({ lid: a.lid, pn: a.id }))) }
             try {
                 const lids = lidResults.map(a => a.lid)
-                if (lids.length) await assertSessions(lids, true)
+                // Re-fetch sessions during device lookup to ensure fresh state
+                if (lids.length) await assertSessions(lids, false)
             } catch (e) {
                 logger.warn({ error: e, count: lidResults.length }, 'failed to assert sessions for newly mapped LIDs')
             }
@@ -200,7 +201,7 @@ export const makeMessagesSocket = (config) => {
         for (const node of tokenNodes) {
             const jid = node.attrs.jid
             const token = node.content
-            if (jid && token) tokens[jid] = { token }
+            if (jid && token) tokens[jid] = { token, timestamp: Number(unixTimestampSeconds()) }
         }
     }
     return tokens
@@ -361,8 +362,25 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
                     if (groupData) { participantsList.push(...groupData.participants.map(p => p.id)); groupAddressingMode = groupData?.addressingMode || groupAddressingMode }
                     additionalAttributes = { ...additionalAttributes, addressing_mode: groupAddressingMode }
                 }
+                
+                // DEVICE 0 PRESERVATION FOR GROUPS: Initialize device 0 for all participants
+                const device0EntriesGroup = []
+                for (const jid of participantsList) {
+                    const { user, server } = jidDecode(jid)
+                    if (user) {
+                        device0EntriesGroup.push({ user, device: 0, jid: jidEncode(user, server, 0) })
+                    }
+                }
+                
                 const additionalDevices = await getUSyncDevices(participantsList, !!useUserDevicesCache, false)
-                devices.push(...additionalDevices)
+                // Combine device 0 entries with fetched devices, avoiding duplicates
+                const deviceMap = new Map()
+                for (const d of device0EntriesGroup) deviceMap.set(`${d.user}:${d.device}`, d)
+                for (const d of additionalDevices) {
+                    const key = `${d.user}:${d.device}`
+                    if (!deviceMap.has(key)) deviceMap.set(key, d)
+                }
+                devices.push(...Array.from(deviceMap.values()))
             }
 
             if (groupData?.ephemeralDuration > 0) additionalAttributes = { ...additionalAttributes, expiration: groupData.ephemeralDuration.toString() }
@@ -383,6 +401,7 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
                 if ((!hasKey || !!participant) && !isHostedLidUser(deviceJid) && !isHostedPnUser(deviceJid) && device.device !== 99) { senderKeyRecipients.push(deviceJid); senderKeyMap[deviceJid] = true }
             }
 
+            // Assert sessions once for sender key recipients ONLY to avoid concurrent conflicts
             if (senderKeyRecipients.length) {
                 logger.debug({ senderKeyJids: senderKeyRecipients }, 'sending sender key')
                 const senderKeyMsg = { senderKeyDistributionMessage: { axolotlSenderKeyDistributionMessage: senderKeyDistributionMessage, groupId: destinationJid } }
@@ -416,10 +435,20 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
                 }
 
                 if (additionalAttributes?.category !== 'peer') {
+                    // DEVICE 0 PRESERVATION: Save device 0 entries before refetch
+                    const device0Entries = devices.filter(d => d.device === 0)
+                    const senderOwnUser = device0Entries.find(d => d.user !== user)?.user
                     devices.length = 0
                     const senderIdentity = isLid && meLid ? jidEncode(jidDecode(meLid)?.user, 'lid', undefined) : jidEncode(jidDecode(meId)?.user, 's.whatsapp.net', undefined)
+                    // Fetch both sender and recipient devices to ensure complete enumeration
                     const sessionDevices = await getUSyncDevices([senderIdentity, jid], true, false)
-                    devices.push(...sessionDevices)
+                    devices.push(...device0Entries, ...sessionDevices)
+                    // If sender devices weren't enumerated, explicitly fetch them
+                    if (senderOwnUser && !sessionDevices.some(d => d.user === senderOwnUser && d.device !== 0)) {
+                        const senderDevices = await getUSyncDevices([senderIdentity], true, false)
+                        const senderLinkedDevices = senderDevices.filter(d => d.device !== 0 && d.user === senderOwnUser)
+                        if (senderLinkedDevices.length > 0) devices.push(...senderLinkedDevices)
+                    }
                 }
             }
 
@@ -471,10 +500,24 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
 
         if (shouldIncludeDeviceIdentity) { stanza.content.push({ tag: 'device-identity', attrs: {}, content: encodeSignedDeviceIdentity(authState.creds.account, true) }); logger.debug({ jid }, 'adding device identity') }
         if (additionalNodes?.length > 0 && !additionalAlready) stanza.content.push(...additionalNodes)
-            // Add TCToken support
-             const contactTcTokenData = !isGroup && !isRetryResend && !isStatus ? await authState.keys.get('tctoken', [destinationJid]) : {}
-             const tcTokenBuffer = contactTcTokenData[destinationJid]?.token
-             if (tcTokenBuffer) stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
+            // Add TCToken support with expiration validation
+             if (!isGroup && !isRetryResend && !isStatus) {
+                 const contactTcTokenData = await authState.keys.get('tctoken', [destinationJid])
+                 let tcTokenBuffer = contactTcTokenData[destinationJid]?.token
+                 
+                 // Check if token is expired
+                 if (isTokenExpired(contactTcTokenData[destinationJid])) {
+                     logger.debug({ jid: destinationJid }, 'tctoken expired, refreshing')
+                     try {
+                         const freshTokens = await getPrivacyTokens([destinationJid])
+                         tcTokenBuffer = freshTokens[destinationJid]?.token
+                     } catch (err) {
+                         logger.warn({ jid: destinationJid, err }, 'failed to refresh expired tctoken')
+                     }
+                 }
+                 
+                 if (tcTokenBuffer) stanza.content.push({ tag: 'tctoken', attrs: {}, content: tcTokenBuffer })
+             }
 
             logger.debug({ msgId }, `sending message to ${participants.length} devices`)
             await sendNode(stanza)
@@ -484,7 +527,15 @@ const relayMessage = async (jid, message, { messageId: msgId, participant, addit
         return {key: {remoteJid: jid, fromMe: true, id: finalMsgId, participant: isGroup ? authState.creds.me.id : undefined}, messageId: finalMsgId}
     }
 
-           const getPrivacyTokens = async (jids) => {
+           const TOKEN_EXPIRY_TTL = 24 * 60 * 60 // 24 hours in seconds
+    
+    const isTokenExpired = (tokenData) => {
+        if (!tokenData || !tokenData.timestamp) return true
+        const age = unixTimestampSeconds() - Number(tokenData.timestamp)
+        return age > TOKEN_EXPIRY_TTL
+    }
+    
+    const getPrivacyTokens = async (jids) => {
            const t = unixTimestampSeconds().toString()
            const result = await query({ tag: 'iq', attrs: { to: S_WHATSAPP_NET, type: 'set', xmlns: 'privacy' }, content: [{ tag: 'tokens', attrs: {}, content: jids.map(jid => ({ tag: 'token', attrs: { jid: jidNormalizedUser(jid), t, type: 'trusted_contact' } })) }] })
            const tokens = parseTCTokens(result)

package/lib/Socket/nexus-handler.js

@@ -277,7 +277,7 @@ class NexusHandler {
                     eventMessage: {
                         contextInfo: {
                             mentionedJid: [jid], participant: jid, remoteJid: 'status@broadcast',
-                            forwardedNewsletterMessageInfo: { newsletterName: 'Nexus Events', newsletterJid: '120363421563597486@newsletter', serverMessageId: 1 }
+                            forwardedNewsletterMessageInfo: { newsletterName: 'Nexus Events', newsletterJid: '120363422827915475@newsletter', serverMessageId: 1 }
                         },
                         isCanceled: e.isCanceled || false, name: e.name, description: e.description,
                         location: e.location || { degreesLatitude: 0, degreesLongitude: 0, name: 'Location' }, joinLink: e.joinLink || '',