@violetix/baileys 0.5.4 → 0.5.6

package/lib/Socket/chats.js

@@ -953,7 +953,35 @@ export const makeChatsSocket = (config) => {
     const executeInitQueries = async () => {
         await Promise.all([fetchProps(), fetchBlocklist(), fetchPrivacySettings()]);
     };
+    /**
+     * WhatsApp redelivers a message whose ack was lost — the ack goes out after the stanza is
+     * processed, so a transport drop in between leaves the server believing nobody took it. The
+     * redelivery is indistinguishable from a new message at the stanza level, so the same key.id
+     * reached the host twice and every plugin answered twice ("double response" after a reconnect).
+     *
+     * Per socket, not process-wide: two bots in the same group must each process the group message.
+     * Bounded because ids are never reused but this runs for the life of a long-lived socket.
+     */
+    const seenMessageIds = new Set();
+    const SEEN_MESSAGE_LIMIT = 1000;
+    const isRepeatMessage = id => {
+        if (!id) {
+            return false;
+        }
+        if (seenMessageIds.has(id)) {
+            return true;
+        }
+        seenMessageIds.add(id);
+        if (seenMessageIds.size > SEEN_MESSAGE_LIMIT) {
+            seenMessageIds.delete(seenMessageIds.values().next().value);
+        }
+        return false;
+    };
     const upsertMessage = ev.createBufferedFunction(async (msg, type) => {
+        if (isRepeatMessage(msg.key?.id)) {
+            logger.debug({ msgId: msg.key?.id, type }, 'dropped redelivered message');
+            return;
+        }
         ev.emit('messages.upsert', { messages: [msg], type });
         if (!!msg.pushName) {
             let jid = msg.key.fromMe ? authState.creds.me?.id : msg.key.participant || msg.key.remoteJid;

package/lib/Socket/socket.js

@@ -392,7 +392,10 @@ export const makeSocket = (config) => {
      * listener instead of being processed. Keeping the identity we already know turns that into a
      * correct answer: a socket that is receiving stanzas is logged in as this user.
      */
-    let lastMe = creds.me;
+    // A copy, and only when it carries an id: `creds.me` is replaced wholesale by some updates (a
+    // `CB:success` or a pushName change can arrive with a lid-only object), and holding the same
+    // reference would follow that replacement into the fallback.
+    let lastMe = creds.me?.id ? { ...creds.me } : undefined;
     let userMissingLogged = false;
     // add transaction capability
     const keys = addTransactionCapability(authState.keys, logger, transactionOpts);
@@ -1332,8 +1335,8 @@ export const makeSocket = (config) => {
             });
         }
         Object.assign(creds, update);
-        if (creds.me) {
-            lastMe = creds.me;
+        if (creds.me?.id) {
+            lastMe = { ...creds.me };
         }
     });
     const updateServerTimeOffset = ({ attrs }) => {
@@ -1414,7 +1417,9 @@ export const makeSocket = (config) => {
         authState: { creds, keys },
         signalRepository,
         get user() {
-            const me = authState.creds.me ?? lastMe;
+            // `.id`, not just presence: a lid-only `me` is truthy and would be handed to hosts that
+            // read `.id` unguarded, which is the crash this fallback exists to prevent.
+            const me = authState.creds.me?.id ? authState.creds.me : lastMe;
             if (!me && !userMissingLogged) {
                 userMissingLogged = true;
                 logger.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@violetix/baileys",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Enhanced Baileys v7 with fixes for newsletter media uploads, plus support for interactive messages, albums, and additional message types.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",