Session recreation and improved message retry (#1735)

* Add message retry manager for session recreation and caching

Introduces a MessageRetryManager to cache recent sent messages and manage automatic Signal session recreation for failed message retries. Adds new config options to enable these features, integrates retry manager into message send/receive logic, and provides periodic cache cleanup. Improves reliability of message delivery and retry handling.

* Add buffer timeout and cache limit to event-buffer

Introduces a buffer timeout to auto-flush events after 30 seconds and limits the history cache size to prevent memory bloat in event-buffer.ts.

* Add session validation to SignalRepository

Introduces a validateSession method to SignalRepository for checking session existence and state. Updates message retry logic to use the new validation, improving session recreation handling and retry management.

* Improve message retry management and tracking

Refactored message retry manager to use LRU caches for recent messages and session history, added retry counters and statistics tracking, and implemented phone request scheduling. Updated message receive and send logic to mark retry success and pass max retry count. Removed periodic cleanup logic in favor of cache TTLs for better resource management.

* lint fix

* Use validateSession for session checks in message send

Replaces direct session existence checks with the improved validateSession method, which also checks for session staleness. Adds debug logging for failed session validations to aid troubleshooting.

* Delete src/Utils/message-retry.ts

---------

Co-authored-by: Rajeh Taher <rajeh@reforward.dev>

src/Utils/event-buffer.ts

@@ -66,7 +66,6 @@ type BaileysBufferableEventEmitter = BaileysEventEmitter & {
 /**
  * The event buffer logically consolidates different events into a single event
  * making the data processing more efficient.
- * @param ev the baileys event emitter
  */
 export const makeEventBuffer = (logger: ILogger): BaileysBufferableEventEmitter => {
 	const ev = new EventEmitter()
@@ -74,6 +73,10 @@ export const makeEventBuffer = (logger: ILogger): BaileysBufferableEventEmitter
 
 	let data = makeBufferData()
 	let isBuffering = false
+	let bufferTimeout: NodeJS.Timeout | null = 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
 
 	// take the generic event and fire it as a baileys event
 	ev.on('event', (map: BaileysEventData) => {
@@ -86,6 +89,21 @@ export const makeEventBuffer = (logger: ILogger): BaileysBufferableEventEmitter
 		if (!isBuffering) {
 			logger.debug('Event buffer activated')
 			isBuffering = true
+			bufferCount++
+
+			// Auto-flush after a timeout to prevent infinite buffering
+			if (bufferTimeout) {
+				clearTimeout(bufferTimeout)
+			}
+
+			bufferTimeout = setTimeout(() => {
+				if (isBuffering) {
+					logger.warn('Buffer timeout reached, auto-flushing')
+					flush()
+				}
+			}, BUFFER_TIMEOUT_MS)
+		} else {
+			bufferCount++
 		}
 	}
 
@@ -94,8 +112,21 @@ export const makeEventBuffer = (logger: ILogger): BaileysBufferableEventEmitter
 			return false
 		}
 
-		logger.debug('Flushing event buffer')
+		logger.debug({ bufferCount }, 'Flushing event buffer')
 		isBuffering = false
+		bufferCount = 0
+
+		// Clear timeout
+		if (bufferTimeout) {
+			clearTimeout(bufferTimeout)
+			bufferTimeout = null
+		}
+
+		// Clear history cache if it exceeds the max size
+		if (historyCache.size > MAX_HISTORY_CACHE_SIZE) {
+			logger.debug({ cacheSize: historyCache.size }, 'Clearing history cache')
+			historyCache.clear()
+		}
 
 		const newData = makeBufferData()
 		const chatUpdates = Object.values(data.chatUpdates)
@@ -148,9 +179,25 @@ export const makeEventBuffer = (logger: ILogger): BaileysBufferableEventEmitter
 			return async (...args) => {
 				buffer()
 				try {
-					return await work(...args)
+					const result = await work(...args)
+					// If this is the only buffer, flush after a small delay
+					if (bufferCount === 1) {
+						setTimeout(() => {
+							if (isBuffering && bufferCount === 1) {
+								flush()
+							}
+						}, 100) // Small delay to allow nested buffers
+					}
+
+					return result
+				} catch (error) {
+					throw error
 				} finally {
-					// Flushing is now controlled centrally by the state machine.
+					bufferCount = Math.max(0, bufferCount - 1)
+					if (bufferCount === 0) {
+						// Auto-flush when no other buffers are active
+						setTimeout(flush, 100)
+					}
 				}
 			}
 		},