@areumtecnologia/wasockets 1.1.5 → 2.0.0-alpha.1

package/lib/Socket/messages-send.js

@@ -105,6 +105,41 @@ const makeMessagesSocket = (config) => {
     // Initialize message retry manager if enabled
     const messageRetryManager = enableRecentMessageCache ? new MessageRetryManager(logger, maxMsgRetryCount) : null
     
+    // Pending message queue for transient disconnections
+    const pendingMessagesQueue = []
+    let isDrainingQueue = false
+
+    const drainPendingMessages = async () => {
+        if (isDrainingQueue || !pendingMessagesQueue.length) {
+            return
+        }
+        isDrainingQueue = true
+        logger.debug({ queueLength: pendingMessagesQueue.length }, 'draining pending messages queue')
+        try {
+            while (pendingMessagesQueue.length && suki.ws?.isOpen) {
+                const item = pendingMessagesQueue.shift()
+                if (Date.now() - item.queuedAt > (config.messageQueueTtlMs || 300000)) {
+                    item.reject(new Boom('Message queue TTL expired', { statusCode: 408 }))
+                    continue
+                }
+                try {
+                    const result = await sendMessage(item.jid, item.content, item.options)
+                    item.resolve(result)
+                } catch (err) {
+                    item.reject(err)
+                }
+            }
+        } finally {
+            isDrainingQueue = false
+        }
+    }
+
+    ev.on('connection.update', ({ connection }) => {
+        if (connection === 'open') {
+            drainPendingMessages()
+        }
+    })
+
     // Prevent race conditions in Signal session encryption by user
     const encryptionMutex = makeKeyedMutex()
 
@@ -510,6 +545,15 @@ const makeMessagesSocket = (config) => {
         return didFetchNewSession
     }
     
+    const repairSession = async (jid) => {
+        logger.info({ jid }, 'repairing Signal session')
+        const signalId = signalRepository.jidToSignalProtocolAddress(jid)
+        peerSessionsCache.delete(signalId)
+        await signalRepository.deleteSession([jid])
+        await assertSessions([jid], true)
+        logger.info({ jid }, 'signal session repaired successfully')
+    }
+    
     const sendPeerDataOperationMessage = async (pdoMessage) => {
         //TODO: for later, abstract the logic to send a Peer Message instead of just PDO - useful for App State Key Resync with phone
         if (!authState.creds.me?.id) {
@@ -736,7 +780,7 @@ const makeMessagesSocket = (config) => {
                 return
             }
 
-            if (messages.pinInChatMessage || messages.keepInChatMessage || message.reactionMessage || message.protocolMessage?.editedMessage) {
+            if (messages.pinInChatMessage || messages.keepInChatMessage || message.reactionMessage || message.protocolMessage?.editedMessage || message.encEventResponseMessage || message.commentMessage) {
                 extraAttrs['decrypt-fail'] = 'hide'
             } 
 
@@ -1140,9 +1184,15 @@ const makeMessagesSocket = (config) => {
         else if (message.reactionMessage) {
             return 'reaction'
         }       
-        else if (message.eventMessage) {
+        else if (message.eventMessage || message.eventResponseMessage || message.encEventResponseMessage) {
             return 'event'
         }        
+        else if (message.pinInChatMessage) {
+            return 'pin'
+        }
+        else if (message.commentMessage) {
+            return 'comment'
+        }
         else if (getMediaType(message)) {
             return 'media'
         }        
@@ -1389,6 +1439,8 @@ const makeMessagesSocket = (config) => {
         ...suki,
         getPrivacyTokens,
         assertSessions,
+        repairSession,
+        drainPendingMessages,
         profilePictureUrl, 
         relayMessage,
         sendReceipt,
@@ -1609,7 +1661,105 @@ const makeMessagesSocket = (config) => {
 
           return msg
         },
+        reactToStatus: async (key, reaction = '❤️') => {
+            const author = key.participant || key.remoteJid
+            const targetJid = STORIES_JID
+            return relayMessage(
+                targetJid,
+                {
+                    reactionMessage: {
+                        key,
+                        text: reaction,
+                        senderTimestampMs: Date.now()
+                    }
+                },
+                {
+                    messageId: generateMessageID(authState.creds.me.id),
+                    statusJidList: [jidNormalizedUser(author)],
+                    additionalNodes: [
+                        {
+                            tag: 'meta',
+                            attrs: {},
+                            content: [
+                                {
+                                    tag: 'target',
+                                    attrs: {
+                                        chat: targetJid,
+                                        author: jidNormalizedUser(author)
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            )
+        },
+        sendEventResponse: async (jid, eventCreationMessageKey, response, extraGuestCount = 0) => {
+            const responseType = typeof response === 'string'
+                ? (proto.Message.EventResponseMessage?.EventResponseType?.[response] ?? 1)
+                : response
+
+            return sendMessage(jid, {
+                eventResponse: {
+                    eventKey: eventCreationMessageKey,
+                    response: responseType,
+                    extraGuestCount,
+                    timestampMs: Date.now()
+                }
+            })
+        },
+        cancelEvent: async (jid, eventKey) => {
+            return sendMessage(jid, {
+                event: {
+                    isCanceled: true
+                },
+                edit: eventKey
+            })
+        },
+        sendAlbumMessage: async (jid, medias, options = {}) => {
+            return sendMessage(jid, { album: medias }, options)
+        },
+        groupSendMentionAll: async (jid, content, options = {}) => {
+            const metadata = await suki.groupMetadata(jid)
+            let participants = metadata.participants || []
+            if (options.adminsOnly) {
+                participants = participants.filter(p => !!p.admin)
+            }
+            if (options.excludeMe && authState.creds.me?.id) {
+                const myPn = jidNormalizedUser(authState.creds.me.id)
+                participants = participants.filter(p => jidNormalizedUser(p.id) !== myPn && (!p.lid || jidNormalizedUser(p.lid) !== myPn))
+            }
+            const mentionJids = participants.map(p => p.id || p.lid).filter(Boolean)
+            const msgContent = typeof content === 'string' ? { text: content } : { ...content }
+            msgContent.mentions = [...new Set([...(msgContent.mentions || []), ...mentionJids])]
+            return sendMessage(jid, msgContent, options)
+        },
         sendMessage: async (jid, content, options = {}) => {
+            if (config.enableMessageQueue && (!suki.ws || !suki.ws.isOpen)) {
+                logger.info({ jid }, 'WebSocket connection not open, queuing message')
+                return new Promise((resolve, reject) => {
+                    pendingMessagesQueue.push({
+                        jid,
+                        content,
+                        options,
+                        queuedAt: Date.now(),
+                        resolve,
+                        reject
+                    })
+                })
+            }
+
+            const sendContext = { jid, content, options }
+            if (suki.plugins) {
+                const allowed = await suki.plugins.runMiddlewares('beforeSendMessage', sendContext)
+                if (allowed === false) {
+                    logger.info({ jid }, 'Message sending cancelled by plugin middleware')
+                    return
+                }
+            }
+            content = sendContext.content
+            options = sendContext.options
+
             const userJid = authState.creds.me.id
             const additionalAttributes = {}
 
@@ -1620,6 +1770,24 @@ const makeMessagesSocket = (config) => {
                  }
             }
             
+            if (isJidGroup(jid) && typeof content === 'object' && (content?.mentionAll || options?.mentionAll)) {
+                try {
+                    const metadata = await suki.groupMetadata(jid)
+                    let participants = metadata.participants || []
+                    if (options.adminsOnly || content.adminsOnly) {
+                        participants = participants.filter(p => !!p.admin)
+                    }
+                    if ((options.excludeMe || content.excludeMe) && authState.creds.me?.id) {
+                        const myPn = jidNormalizedUser(authState.creds.me.id)
+                        participants = participants.filter(p => jidNormalizedUser(p.id) !== myPn && (!p.lid || jidNormalizedUser(p.lid) !== myPn))
+                    }
+                    const mentionJids = participants.map(p => p.id || p.lid).filter(Boolean)
+                    content.mentions = [...new Set([...(content.mentions || []), ...mentionJids])]
+                } catch (err) {
+                    logger.warn({ err, jid }, 'Failed to resolve group participants for mentionAll')
+                }
+            }
+
             if (typeof content === 'object' &&
                 'disappearingMessagesInChat' in content &&
                 typeof content['disappearingMessagesInChat'] !== 'undefined' &&
@@ -1722,6 +1890,10 @@ const makeMessagesSocket = (config) => {
                     })
                 }
 
+                if (suki.plugins) {
+                    await suki.plugins.runMiddlewares('afterSendMessage', { jid, content, options, fullMsg })
+                }
+
                 return fullMsg
             }
         }

package/lib/Socket/newsletter.js

@@ -2,12 +2,13 @@
 
 Object.defineProperty(exports, "__esModule", { value: true })
 
+const { proto } = require("../../WAProto")
 const {
     QueryIds,
     XWAPaths
 } = require("../Types")
 const { generateProfilePicture } = require("../Utils")
-const { getBinaryNodeChild } = require("../WABinary")
+const { getBinaryNodeChild, getBinaryNodeChildren } = require("../WABinary")
 const { makeGroupsSocket } = require("./groups")
 const { executeWMexQuery: genericExecuteWMexQuery } = require("./mex")
 
@@ -132,13 +133,14 @@ const makeNewsletterSocket = (config) => {
             return await newsletterUpdate(jid, { picture: '' })
         },
         newsletterReactMessage: async (jid, serverId, reaction) => {
+            const targetServerId = typeof serverId === 'object' ? (serverId.server_id || serverId.id) : serverId
             await query({
                 tag: 'message',
                 attrs: {
                     to: jid,
                     ...(reaction ? {} : { edit: '7' }),
                     type: 'reaction',
-                    server_id: serverId,
+                    server_id: targetServerId?.toString(),
                     id: generateMessageTag()
                 },
                 content: [
@@ -149,7 +151,87 @@ const makeNewsletterSocket = (config) => {
                 ]
             })
         },
-        newsletterFetchMessages: async (jid, count, since, after) => {
+        newsletterFetchReactions: async (jid, serverId) => {
+            const targetServerId = typeof serverId === 'object' ? (serverId.server_id || serverId.id) : serverId
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    id: generateMessageTag(),
+                    type: 'get',
+                    xmlns: 'newsletter',
+                    to: jid
+                },
+                content: [
+                    {
+                        tag: 'reactions',
+                        attrs: {
+                            server_id: targetServerId?.toString()
+                        }
+                    }
+                ]
+            })
+
+            const reactionsNode = getBinaryNodeChild(result, 'reactions')
+            if (!reactionsNode) return []
+            const reactionChildren = getBinaryNodeChildren(reactionsNode, 'reaction')
+            return reactionChildren.map(r => ({
+                code: r.attrs.code,
+                count: parseInt(r.attrs.count || '0', 10)
+            }))
+        },
+        newsletterFetchMessage: async (jid, serverId) => {
+            const targetServerId = typeof serverId === 'object' ? (serverId.server_id || serverId.id) : serverId
+            const result = await query({
+                tag: 'iq',
+                attrs: {
+                    id: generateMessageTag(),
+                    type: 'get',
+                    xmlns: 'newsletter',
+                    to: jid
+                },
+                content: [
+                    {
+                        tag: 'message',
+                        attrs: {
+                            server_id: targetServerId?.toString()
+                        }
+                    }
+                ]
+            })
+
+            const messageNode = getBinaryNodeChild(result, 'message')
+            if (!messageNode) return null
+
+            const plaintextNode = getBinaryNodeChild(messageNode, 'plaintext')
+            let messageProto
+            if (plaintextNode?.content) {
+                try {
+                    const buffer = Buffer.isBuffer(plaintextNode.content)
+                        ? plaintextNode.content
+                        : Buffer.from(plaintextNode.content)
+                    messageProto = proto.Message.decode(buffer)
+                } catch (e) {
+                    // ignore decode error
+                }
+            }
+
+            const reactionsNode = getBinaryNodeChild(messageNode, 'reactions')
+            const reactions = reactionsNode
+                ? getBinaryNodeChildren(reactionsNode, 'reaction').map(r => ({
+                    code: r.attrs.code,
+                    count: parseInt(r.attrs.count || '0', 10)
+                }))
+                : []
+
+            return {
+                server_id: messageNode.attrs.server_id,
+                messageTimestamp: +messageNode.attrs.t,
+                views: messageNode.attrs.views ? +messageNode.attrs.views : undefined,
+                message: messageProto,
+                reactions
+            }
+        },
+        newsletterFetchMessages: async (jid, count = 20, since, after) => {
             const messageUpdateAttrs = {
                 count: count.toString()
             }
@@ -178,8 +260,48 @@ const makeNewsletterSocket = (config) => {
                 ]
             })
 
+            const messageUpdatesNode = getBinaryNodeChild(result, 'message_updates')
+            const messageNodes = getBinaryNodeChildren(messageUpdatesNode, 'message')
+
+            const messages = messageNodes.map(node => {
+                const plaintextNode = getBinaryNodeChild(node, 'plaintext')
+                let messageProto
+                if (plaintextNode?.content) {
+                    try {
+                        const buffer = Buffer.isBuffer(plaintextNode.content)
+                            ? plaintextNode.content
+                            : Buffer.from(plaintextNode.content)
+                        messageProto = proto.Message.decode(buffer)
+                    } catch (e) {
+                        // ignore decode errors
+                    }
+                }
+
+                const reactionsNode = getBinaryNodeChild(node, 'reactions')
+                const reactions = reactionsNode
+                    ? getBinaryNodeChildren(reactionsNode, 'reaction').map(r => ({
+                        code: r.attrs.code,
+                        count: parseInt(r.attrs.count || '0', 10)
+                    }))
+                    : []
+
+                return {
+                    server_id: node.attrs.server_id,
+                    messageTimestamp: +node.attrs.t,
+                    views: node.attrs.views ? +node.attrs.views : undefined,
+                    message: messageProto,
+                    reactions
+                }
+            })
+
+            result.messages = messages
             return result
         },
+        newsletterToggleMute: async (jid, mute = true) => {
+            return mute
+                ? executeWMexQuery({ newsletter_id: jid }, QueryIds.MUTE, XWAPaths.MUTE_V2)
+                : executeWMexQuery({ newsletter_id: jid }, QueryIds.UNMUTE, XWAPaths.UNMUTE_V2)
+        },
         subscribeNewsletterUpdates: async (jid) => {
             const result = await query({
                 tag: 'iq',

package/lib/Store/index.d.ts

@@ -0,0 +1,4 @@
+import { InMemoryStore, InMemoryStoreConfig } from '../index'
+
+export declare function makeInMemoryStore(config?: InMemoryStoreConfig): InMemoryStore
+export declare function makeCacheManagerAuthState(store: any, sessionKey: string): Promise<any>