@badzz88/baileys 8.5.4 → 8.5.5

package/lib/Utils/process-message.js

@@ -59,9 +59,9 @@ const REAL_MSG_STUB_TYPES = new Set([
 	Types_1.WAMessageStubType.CALL_MISSED_VOICE
 ])
 const REAL_MSG_REQ_ME_STUB_TYPES = new Set([Types_1.WAMessageStubType.GROUP_PARTICIPANT_ADD])
-
+/** Cleans a received message to further processing */
 const cleanMessage = (message, meId, meLid) => {
-	
+	// ensure remoteJid and participant doesn't have device or agent in it
 	if ((0, WABinary_1.isHostedPnUser)(message.key.remoteJid) || (0, WABinary_1.isHostedLidUser)(message.key.remoteJid)) {
 		message.key.remoteJid = (0, WABinary_1.jidEncode)(
 			(0, WABinary_1.jidDecode)(message.key?.remoteJid)?.user,
@@ -82,7 +82,7 @@ const cleanMessage = (message, meId, meLid) => {
 		message.key.participant = (0, WABinary_1.jidNormalizedUser)(message.key.participant)
 	}
 	const content = (0, messages_1.normalizeMessageContent)(message.message)
-	
+	// if the message has a reaction, ensure fromMe & remoteJid are from our perspective
 	if (content?.reactionMessage) {
 		normaliseKey(content.reactionMessage.key)
 	}
@@ -90,48 +90,47 @@ const cleanMessage = (message, meId, meLid) => {
 		normaliseKey(content.pollUpdateMessage.pollCreationMessageKey)
 	}
 	function normaliseKey(msgKey) {
-		
-		
+		// if the reaction is from another user
+		// we've to correctly map the key to this user's perspective
 		if (!message.key.fromMe) {
-			
-			
+			// if the sender believed the message being reacted to is not from them
+			// we've to correct the key to be from them, or some other participant
 			msgKey.fromMe = !msgKey.fromMe
 				? (0, WABinary_1.areJidsSameUser)(msgKey.participant || msgKey.remoteJid, meId) ||
 					(0, WABinary_1.areJidsSameUser)(msgKey.participant || msgKey.remoteJid, meLid)
-				: 
-					
+				: // if the message being reacted to, was from them
+					// fromMe automatically becomes false
 					false
-			
-			
+			// set the remoteJid to being the same as the chat the message came from
+			// TODO: investigate inconsistencies
 			msgKey.remoteJid = message.key.remoteJid
-			
+			// set participant of the message
 			msgKey.participant = msgKey.participant || message.key.participant
 		}
 	}
 }
 exports.cleanMessage = cleanMessage
+// TODO: target:audit AUDIT THIS FUNCTION AGAIN
 const isRealMessage = message => {
-	
-	
-	
-	if (REAL_MSG_STUB_TYPES.has(message.messageStubType) || REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) {
-		return true
-	}
 	const normalizedContent = (0, messages_1.normalizeMessageContent)(message.message)
 	const hasSomeContent = !!(0, messages_1.getContentType)(normalizedContent)
 	return (
-		!!normalizedContent &&
+		(!!normalizedContent ||
+			REAL_MSG_STUB_TYPES.has(message.messageStubType) ||
+			REAL_MSG_REQ_ME_STUB_TYPES.has(message.messageStubType)) &&
 		hasSomeContent &&
 		!normalizedContent?.protocolMessage &&
 		!normalizedContent?.reactionMessage &&
-		!normalizedContent?.pollUpdateMessage &&
-		!normalizedContent?.secretEncryptedMessage
+		!normalizedContent?.pollUpdateMessage
 	)
 }
 exports.isRealMessage = isRealMessage
 const shouldIncrementChatUnread = message => !message.key.fromMe && !message.messageStubType
 exports.shouldIncrementChatUnread = shouldIncrementChatUnread
-
+/**
+ * Get the ID of the chat from the given key.
+ * Typically -- that'll be the remoteJid, but for broadcasts, it'll be the participant
+ */
 const getChatId = ({ remoteJid, participant, fromMe }) => {
 	if ((0, WABinary_1.isJidBroadcast)(remoteJid) && !(0, WABinary_1.isJidStatusBroadcast)(remoteJid) && !fromMe) {
 		return participant
@@ -139,7 +138,12 @@ const getChatId = ({ remoteJid, participant, fromMe }) => {
 	return remoteJid
 }
 exports.getChatId = getChatId
-
+/**
+ * Decrypt a poll vote
+ * @param vote encrypted vote
+ * @param ctx additional info about the poll required for decryption
+ * @returns list of SHA256 options
+ */
 function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pollEncKey, voterJid }) {
 	const sign = Buffer.concat([
 		toBinary(pollMsgId),
@@ -157,7 +161,12 @@ function decryptPollVote({ encPayload, encIv }, { pollCreatorJid, pollMsgId, pol
 		return Buffer.from(txt)
 	}
 }
-
+/**
+ * Decrypt an event response
+ * @param response encrypted event response
+ * @param ctx additional info about the event required for decryption
+ * @returns event response message
+ */
 function decryptEventResponse({ encPayload, encIv }, { eventCreatorJid, eventMsgId, eventEncKey, responderJid }) {
 	const sign = Buffer.concat([
 		toBinary(eventMsgId),
@@ -175,108 +184,6 @@ function decryptEventResponse({ encPayload, encIv }, { eventCreatorJid, eventMsg
 		return Buffer.from(txt)
 	}
 }
-
-function decryptMessageEdit({ encPayload, encIv }, { origMsgId, origMsgSenderJid, editorJid, msgEncKey }) {
-	const sign = Buffer.concat([
-		toBinary(origMsgId),
-		toBinary(origMsgSenderJid),
-		toBinary(editorJid),
-		toBinary('Message Edit'),
-		new Uint8Array([1])
-	])
-	const key0 = (0, crypto_1.hmacSign)(msgEncKey, new Uint8Array(32), 'sha256')
-	const decKey = (0, crypto_1.hmacSign)(sign, key0, 'sha256')
-	
-	const decrypted = (0, crypto_1.aesDecryptGCM)(encPayload, decKey, encIv, new Uint8Array(0))
-	return index_js_1.proto.Message.decode(decrypted)
-	function toBinary(txt) {
-		return Buffer.from(txt)
-	}
-}
-exports.decryptMessageEdit = decryptMessageEdit
-
-const unwrapSecretEncryptedMessage = async (message, { creds, getMessage, logger }) => {
-	const content = (0, messages_1.normalizeMessageContent)(message.message)
-	const secretEnc = content?.secretEncryptedMessage
-	if (
-		!secretEnc?.encPayload ||
-		!secretEnc.encIv ||
-		secretEnc.secretEncType !== index_js_1.proto.Message.SecretEncryptedMessage.SecretEncType.MESSAGE_EDIT
-	) {
-		return
-	}
-	const targetKey = secretEnc.targetMessageKey
-	if (!targetKey?.id) {
-		return
-	}
-	try {
-		
-		
-		const origMsg = await getMessage({
-			...targetKey,
-			remoteJid: message.key.remoteJid,
-			fromMe: message.key.fromMe,
-			participant: message.key.participant
-		})
-		let msgEncKey = origMsg?.messageContextInfo?.messageSecret
-		if (typeof msgEncKey === 'string') {
-			
-			msgEncKey = Buffer.from(msgEncKey, 'base64')
-		}
-		if (!msgEncKey?.length) {
-			logger?.warn({ targetKey }, 'message edit: missing messageSecret for decryption')
-			return
-		}
-		
-		
-		const meIdNormalised = (0, WABinary_1.jidNormalizedUser)(creds.me.id)
-		const candidates = [
-			...(message.key.fromMe
-				? [meIdNormalised, creds.me?.lid]
-				: [message.key.participant || message.key.remoteJid, message.key.participantAlt || message.key.remoteJidAlt]),
-			targetKey.remoteJid
-		]
-			.filter(jid => !!jid)
-			.map(jid => (0, WABinary_1.jidNormalizedUser)(jid))
-			.filter((jid, i, arr) => arr.indexOf(jid) === i)
-		let decoded
-		let lastError
-		for (const authorJid of candidates) {
-			try {
-				decoded = decryptMessageEdit(secretEnc, {
-					origMsgId: targetKey.id,
-					origMsgSenderJid: authorJid,
-					editorJid: authorJid,
-					msgEncKey
-				})
-				break
-			} catch (err) {
-				lastError = err
-			}
-		}
-		if (!decoded) {
-			throw lastError
-		}
-		if (!decoded.protocolMessage) {
-			
-			decoded = index_js_1.proto.Message.fromObject({
-				protocolMessage: {
-					key: targetKey,
-					type: index_js_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT,
-					editedMessage: decoded
-				}
-			})
-		}
-		if (!decoded.messageContextInfo && content?.messageContextInfo) {
-			decoded.messageContextInfo = content.messageContextInfo
-		}
-		message.message = decoded
-		logger?.debug({ targetKey }, 'decrypted secretEncryptedMessage edit')
-	} catch (err) {
-		logger?.warn({ err, targetKey }, 'failed to decrypt secretEncryptedMessage edit')
-	}
-}
-exports.unwrapSecretEncryptedMessage = unwrapSecretEncryptedMessage
 const processMessage = async (
 	message,
 	{
@@ -298,7 +205,7 @@ const processMessage = async (
 	if (isRealMsg) {
 		chat.messages = [{ message }]
 		chat.conversationTimestamp = (0, generics_1.toNumber)(message.messageTimestamp)
-		
+		// only increment unread count if not CIPHERTEXT and from another person
 		if ((0, exports.shouldIncrementChatUnread)(message)) {
 			chat.unreadCount = (chat.unreadCount || 0) + 1
 		}
@@ -329,8 +236,8 @@ const processMessage = async (
 		})
 	}
 	const content = (0, messages_1.normalizeMessageContent)(message.message)
-	
-	
+	// unarchive chat if it's a real message, or someone reacted to our message
+	// and we've the unarchive chats setting on
 	if ((isRealMsg || content?.reactionMessage?.key?.fromMe) && accountSettings?.unarchiveChats) {
 		chat.archived = false
 		chat.readOnly = false
@@ -352,7 +259,7 @@ const processMessage = async (
 					'got history notification'
 				)
 				if (process) {
-					
+					// TODO: investigate
 					if (histNotification.syncType !== index_js_1.proto.HistorySync.HistorySyncType.ON_DEMAND) {
 						ev.emit('creds.update', {
 							processedHistoryMessages: [
@@ -418,31 +325,31 @@ const processMessage = async (
 			case index_js_1.proto.Message.ProtocolMessage.Type.PEER_DATA_OPERATION_REQUEST_RESPONSE_MESSAGE:
 				const response = protocolMsg.peerDataOperationRequestResponseMessage
 				if (response) {
-					
+					// TODO: IMPLEMENT HISTORY SYNC ETC (sticker uploads etc.).
 					const peerDataOperationResult = response.peerDataOperationResult || []
 					for (const result of peerDataOperationResult) {
 						const retryResponse = result?.placeholderMessageResendResponse
-						
+						//eslint-disable-next-line max-depth
 						if (!retryResponse?.webMessageInfoBytes) {
 							continue
 						}
-						
+						//eslint-disable-next-line max-depth
 						try {
 							const webMessageInfo = index_js_1.proto.WebMessageInfo.decode(retryResponse.webMessageInfoBytes)
 							const msgId = webMessageInfo.key?.id
-							
-							
+							// Retrieve cached original message data (preserves LID details,
+							// timestamps, etc. that the phone may omit in its PDO response)
 							const cachedData = msgId ? await placeholderResendCache?.get(msgId) : undefined
-							
+							//eslint-disable-next-line max-depth
 							if (msgId) {
 								await placeholderResendCache?.del(msgId)
 							}
 							let finalMsg
-							
+							//eslint-disable-next-line max-depth
 							if (cachedData && typeof cachedData === 'object') {
-								
+								// Apply decoded message content onto cached metadata (preserves LID etc.)
 								cachedData.message = webMessageInfo.message
-								
+								//eslint-disable-next-line max-depth
 								if (webMessageInfo.messageTimestamp) {
 									cachedData.messageTimestamp = webMessageInfo.messageTimestamp
 								}
@@ -465,7 +372,7 @@ const processMessage = async (
 			case index_js_1.proto.Message.ProtocolMessage.Type.MESSAGE_EDIT:
 				ev.emit('messages.update', [
 					{
-						
+						// flip the sender / fromMe properties because they're in the perspective of the sender
 						key: { ...message.key, id: protocolMsg.key?.id },
 						update: {
 							message: {
@@ -482,12 +389,10 @@ const processMessage = async (
 				break
 			case index_js_1.proto.Message.ProtocolMessage.Type.GROUP_MEMBER_LABEL_CHANGE:
 				const labelAssociationMsg = protocolMsg.memberLabel
-				if (labelAssociationMsg) {
-					
-					
+				if (labelAssociationMsg?.label) {
 					ev.emit('group.member-tag.update', {
 						groupId: chat.id,
-						label: labelAssociationMsg.label || '',
+						label: labelAssociationMsg.label,
 						participant: message.key.participant,
 						participantAlt: message.key.participantAlt,
 						messageTimestamp: Number(message.messageTimestamp)
@@ -711,12 +616,12 @@ const processMessage = async (
 	} else if (content?.encEventResponseMessage) {
 		const encEventResponse = content.encEventResponseMessage
 		const creationMsgKey = encEventResponse.eventCreationMessageKey
-		
+		// we need to fetch the event creation message to get the event enc key
 		const eventMsg = await getMessage(creationMsgKey)
 		if (eventMsg) {
 			try {
 				const meIdNormalised = (0, WABinary_1.jidNormalizedUser)(meId)
-				
+				// all jids need to be PN
 				const eventCreatorKey = creationMsgKey.participant || creationMsgKey.remoteJid
 				const eventCreatorPn = (0, WABinary_1.isLidUser)(eventCreatorKey)
 					? await signalRepository.lidMapping.getPNForLID(eventCreatorKey)
@@ -758,7 +663,7 @@ const processMessage = async (
 		}
 	} else if (message.messageStubType) {
 		const jid = message.key?.remoteJid
-		
+		//let actor = whatsappID (message.participant)
 		let participants
 		const emitParticipantsUpdate = action =>
 			ev.emit('group-participants.update', {
@@ -774,7 +679,7 @@ const processMessage = async (
 				{
 					id: jid,
 					...update,
-					author: message.key.participant,
+					author: message.key.participant ?? undefined,
 					authorPn: message.key.participantAlt,
 					authorUsername: message.key.participantUsername
 				}
@@ -793,7 +698,7 @@ const processMessage = async (
 			})
 		}
 		const participantsIncludesMe = () =>
-			participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid.phoneNumber)) 
+			participants.find(jid => (0, WABinary_1.areJidsSameUser)(meId, jid.phoneNumber)) // ADD SUPPORT FOR LID
 		switch (message.messageStubType) {
 			case Types_1.WAMessageStubType.GROUP_PARTICIPANT_CHANGE_NUMBER:
 				participants = message.messageStubParameters.map(a => JSON.parse(a)) || []
@@ -803,7 +708,7 @@ const processMessage = async (
 			case Types_1.WAMessageStubType.GROUP_PARTICIPANT_REMOVE:
 				participants = message.messageStubParameters.map(a => JSON.parse(a)) || []
 				emitParticipantsUpdate('remove')
-				
+				// mark the chat read only if you left the group
 				if (participantsIncludesMe()) {
 					chat.readOnly = true
 				}
@@ -855,7 +760,7 @@ const processMessage = async (
 				const approvalMode = message.messageStubParameters?.[0]
 				emitGroupUpdate({ joinApprovalMode: approvalMode === 'on' })
 				break
-			case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD:
+			case Types_1.WAMessageStubType.GROUP_MEMBERSHIP_JOIN_APPROVAL_REQUEST_NON_ADMIN_ADD: // TODO: Add other events
 				const participant = JSON.parse(message.messageStubParameters?.[0])
 				const action = message.messageStubParameters?.[1]
 				const method = message.messageStubParameters?.[2]
@@ -945,7 +850,7 @@ const processMessage = async (
 				ev.emit('chats.update', [{ id: jid, psa: { urlParams: message.messageStubParameters } }])
 				break
 			case Types_1.WAMessageStubType.CHAT_POLL_CREATION_MESSAGE:
-				
+				// poll was created, no special action needed beyond message processing
 				break
 			case Types_1.WAMessageStubType.BIZ_CHAT_ASSIGNMENT:
 				ev.emit('chats.update', [
@@ -1087,51 +992,55 @@ const processMessage = async (
 				emitGroupUpdate({ hidden: true })
 				break
 		}
-	} else if (content?.pollUpdateMessage) {
-		const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey
-		const pollMsg = await getMessage(creationMsgKey)
-		if (pollMsg) {
-			
-			const inner = pollMsg.viewOnceMessage?.message || pollMsg.botInvokeMessage?.message || pollMsg
-			const pollEncKey = inner.messageContextInfo?.messageSecret || pollMsg.messageContextInfo?.messageSecret || null
-			if (!pollEncKey) {
-				logger?.warn({ creationMsgKey }, 'poll: messageSecret missing, cannot decrypt vote')
-			} else {
-				
-				const rawLid = creds.me?.lid
-				const meLidNorm = rawLid ? `${rawLid.split(':')[0]}@lid` : ''
-				const pollCreatorJid = meLidNorm || (0, WABinary_1.jidNormalizedUser)(meId)
-				
-				const voterJid = message.key.fromMe ? pollCreatorJid : message.key.participant || message.key.remoteJid
-				try {
-					const voteMsg = decryptPollVote(content.pollUpdateMessage.vote, {
-						pollEncKey,
-						pollCreatorJid,
-						pollMsgId: creationMsgKey.id,
-						voterJid
-					})
-					ev.emit('messages.update', [
-						{
-							key: creationMsgKey,
-							update: {
-								pollUpdates: [
-									{
-										pollUpdateMessageKey: message.key,
-										vote: voteMsg,
-										senderTimestampMs: (0, generics_1.toNumber)(content.pollUpdateMessage.senderTimestampMs)
-									}
-								]
-							}
-						}
-					])
-				} catch (err) {
-					logger?.warn({ err, creationMsgKey, pollCreatorJid, voterJid }, 'failed to decrypt poll vote')
-				}
-			}
-		} else {
-			logger?.warn({ creationMsgKey }, 'poll: creation message not found, cannot decrypt vote')
-		}
-	}
+	} /*  else if(content?.pollUpdateMessage) {
+        const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey!
+        // we need to fetch the poll creation message to get the poll enc key
+        // TODO: make standalone, remove getMessage reference
+        // TODO: Remove entirely
+        const pollMsg = await getMessage(creationMsgKey)
+        if(pollMsg) {
+            const meIdNormalised = jidNormalizedUser(meId)
+            const pollCreatorJid = getKeyAuthor(creationMsgKey, meIdNormalised)
+            const voterJid = getKeyAuthor(message.key, meIdNormalised)
+            const pollEncKey = pollMsg.messageContextInfo?.messageSecret!
+
+            try {
+                const voteMsg = decryptPollVote(
+                    content.pollUpdateMessage.vote!,
+                    {
+                        pollEncKey,
+                        pollCreatorJid,
+                        pollMsgId: creationMsgKey.id!,
+                        voterJid,
+                    }
+                )
+                ev.emit('messages.update', [
+                    {
+                        key: creationMsgKey,
+                        update: {
+                            pollUpdates: [
+                                {
+                                    pollUpdateMessageKey: message.key,
+                                    vote: voteMsg,
+                                    senderTimestampMs: (content.pollUpdateMessage.senderTimestampMs! as Long).toNumber(),
+                                }
+                            ]
+                        }
+                    }
+                ])
+            } catch(err) {
+                logger?.warn(
+                    { err, creationMsgKey },
+                    'failed to decrypt poll vote'
+                )
+            }
+        } else {
+            logger?.warn(
+                { creationMsgKey },
+                'poll creation message not found, cannot decrypt update'
+            )
+        }
+        } */
 	if (Object.keys(chat).length > 1) {
 		ev.emit('chats.update', [chat])
 	}

package/lib/Utils/reporting-utils.js

@@ -1,7 +1,7 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', { value: true })
 exports.getMessageReportingToken = exports.shouldIncludeReportingToken = void 0
-const rb = require('whatsapp-rust-bridge')
+const Crypto_1 = require('./crypto')
 const crypto_2 = require('./crypto')
 const reportingFields = [
 	{ f: 1 },
@@ -246,7 +246,7 @@ const getMessageReportingToken = async (msgProtobuf, message, key) => {
 	if (!content || content.length === 0) {
 		return null
 	}
-	const reportingToken = Buffer.from(rb.hmacSign(content, reportingSecret)).subarray(0, 16)
+	const reportingToken = Buffer.from(Crypto_1.hmacSign(content, reportingSecret)).subarray(0, 16)
 	return {
 		tag: 'reporting',
 		attrs: {},

package/lib/Utils/session-pool.d.ts

@@ -0,0 +1,16 @@
+export interface SessionPoolOptions {
+	makeSocket: (sessionId: string) => Promise<any> | any
+	logger?: any
+	maxBackoffMs?: number
+	onSessionUpdate?: (sessionId: string, sock: any) => void
+	onLoggedOut?: (sessionId: string) => void
+}
+
+export interface SessionPool {
+	add: (sessionId: string) => Promise<void>
+	remove: (sessionId: string) => void
+	get: (sessionId: string) => any
+	list: () => string[]
+}
+
+export function createSessionPool(options: SessionPoolOptions): SessionPool

package/lib/Utils/session-pool.js

@@ -0,0 +1,94 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', { value: true })
+exports.createSessionPool = void 0
+
+const DISCONNECT_REASON_LOGGED_OUT = 401
+
+/**
+ * Manages multiple Baileys socket instances (one per account/session), automatically
+ * restarting any session that disconnects -- except when it was logged out -- using
+ * exponential backoff with jitter, instead of every project re-implementing its own
+ * reconnect loop.
+ *
+ * @param {{
+ *   makeSocket: (sessionId: string) => Promise<any> | any,
+ *   logger?: any,
+ *   maxBackoffMs?: number,
+ *   onSessionUpdate?: (sessionId: string, sock: any) => void,
+ *   onLoggedOut?: (sessionId: string) => void
+ * }} options
+ * @returns {{
+ *   add: (sessionId: string) => Promise<void>,
+ *   remove: (sessionId: string) => void,
+ *   get: (sessionId: string) => any,
+ *   list: () => string[]
+ * }}
+ */
+const createSessionPool = options => {
+	const logger = options.logger
+	const maxBackoffMs = options.maxBackoffMs ?? 60000
+	const sessions = new Map() // sessionId -> { sock, attempts, stopped }
+
+	const computeBackoffMs = attempts => {
+		const base = Math.min(1000 * 2 ** attempts, maxBackoffMs)
+		return base + Math.floor(Math.random() * (base * 0.2))
+	}
+
+	const start = async sessionId => {
+		const entry = sessions.get(sessionId) || { attempts: 0, stopped: false }
+		sessions.set(sessionId, entry)
+		if (entry.stopped) return
+		try {
+			const sock = await options.makeSocket(sessionId)
+			entry.sock = sock
+			options.onSessionUpdate?.(sessionId, sock)
+			sock.ev.on('connection.update', update => {
+				if (update.connection === 'open') {
+					entry.attempts = 0
+				}
+				if (update.connection === 'close') {
+					const statusCode = update.lastDisconnect?.error?.output?.statusCode
+					if (statusCode === DISCONNECT_REASON_LOGGED_OUT) {
+						logger?.info?.({ sessionId }, 'session logged out, removing from pool')
+						sessions.delete(sessionId)
+						options.onLoggedOut?.(sessionId)
+						return
+					}
+					if (entry.stopped) return
+					entry.attempts += 1
+					const backoffMs = computeBackoffMs(entry.attempts)
+					logger?.warn?.(
+						{ sessionId, attempt: entry.attempts, backoffMs },
+						'session disconnected, reconnecting with backoff'
+					)
+					setTimeout(() => start(sessionId), backoffMs)
+				}
+			})
+		} catch (error) {
+			entry.attempts += 1
+			const backoffMs = computeBackoffMs(entry.attempts)
+			logger?.error?.({ error, sessionId, backoffMs }, 'failed to start session, retrying with backoff')
+			if (!entry.stopped) {
+				setTimeout(() => start(sessionId), backoffMs)
+			}
+		}
+	}
+
+	const add = sessionId => start(sessionId)
+	const remove = sessionId => {
+		const entry = sessions.get(sessionId)
+		if (!entry) return
+		entry.stopped = true
+		if (entry.sock?.end) {
+			try {
+				entry.sock.end(undefined)
+			} catch {}
+		}
+		sessions.delete(sessionId)
+	}
+	const get = sessionId => sessions.get(sessionId)?.sock
+	const list = () => [...sessions.keys()]
+
+	return { add, remove, get, list }
+}
+exports.createSessionPool = createSessionPool