whalibmob 5.5.70 → 5.5.71

package/lib/Client.js

@@ -877,9 +877,16 @@ class WhalibmobClient extends EventEmitter {
       return;
     }
 
-    const fromStr       = attrs.from ? String(attrs.from) : '';
-    // Extract bare phone number: "40756469325@s.whatsapp.net" → "40756469325"
-    const recipientPhone = fromStr.split('@')[0].split('.')[0];
+    const fromStr = attrs.from ? String(attrs.from) : '';
+    const isGroup = fromStr.endsWith('@g.us');
+
+    // On a group retry `from` is the group and `participant` is the device that
+    // failed to decrypt. Keying off `from` there would have targeted the group
+    // id as if it were a contact and cleared nothing.
+    const targetJid = isGroup && attrs.participant
+      ? String(attrs.participant)
+      : fromStr;
+    const recipientPhone = targetJid.split('@')[0].split(':')[0].split('.')[0];
 
     _whaDbg('[DBG] RETRY_RECV msgId=' + msgId + ' from=' + fromStr + ' — clearing session + resending\n');
 
@@ -900,7 +907,24 @@ class WhalibmobClient extends EventEmitter {
       this._devMgr.clearCache([recipientPhone]);
     }
 
-    // Re-send the message — will create fresh pre-key (pkmsg) sessions
+    // Re-send the message — will create fresh pre-key (pkmsg) sessions.
+    // A group resend must go back through the group path: it needs a fresh
+    // SenderKey distribution, which only _sendGroupMessage builds. Drop the
+    // "already distributed" record first, or the resend would carry the same
+    // bare skmsg the recipient just told us it could not read.
+    const resendId = generateMessageId();
+    if (cached.isGroup) {
+      if (this._signal && this._signal.senderKeyStore) {
+        this._signal.senderKeyStore.invalidateSKDM(cached.toJid);
+      }
+      this._sender._sendGroupMessage(
+        cached.toJid, resendId, cached.plaintext, cached.mediaType, cached.options
+      )
+        .then(r  => _whaDbg('[DBG] RETRY_RESEND group ok id=' + (r && r.id) + '\n'))
+        .catch(e => _whaDbg('[DBG] RETRY_RESEND_ERR: ' + e.message));
+      return;
+    }
+
     this._sender._sendDMMessage(
       cached.toJid, cached.msgId, cached.plaintext, cached.mediaType, cached.options
     )

package/lib/DeviceManager.js

@@ -305,30 +305,15 @@ class DeviceManager {
   async fetchBundles(jids) {
     if (!jids || jids.length === 0) return new Map();
 
-    // Convert a string JID like "user@server" or "user:device@server" into
-    // a proper JID object so the binary encoder uses JID_PAIR / AD_JID format.
-    // Raw UTF-8 strings are NOT recognised by the WA server for @lid JIDs — the
-    // server silently ignores unknown JIDs and returns an empty bundle list.
-    const toJidObj = jidStr => {
-      const str    = typeof jidStr === 'string' ? jidStr : String(jidStr);
-      const at     = str.indexOf('@');
-      const raw    = at >= 0 ? str.slice(0, at) : str;
-      const server = at >= 0 ? str.slice(at + 1) : 's.whatsapp.net';
-      const colon  = raw.indexOf(':');
-      const user   = colon >= 0 ? raw.slice(0, colon) : raw;
-      const device = colon >= 0 ? (parseInt(raw.slice(colon + 1), 10) || 0) : 0;
-      const self   = str;
-      // AD_JID binary format is for @s.whatsapp.net with device > 0.
-      // JID_PAIR binary format is used for @lid and for device-0 @s.whatsapp.net.
-      if (server === 's.whatsapp.net' && device > 0) {
-        // AD_JID: agent=0, device=N
-        return { user, agent: 0, device, server, toString() { return self; } };
-      }
-      // JID_PAIR: user@server  — server may be 'lid' or 's.whatsapp.net'
-      return { user, server, toString() { return self; } };
-    };
-
-    const userNodes = jids.map(jid => new BinaryNode('user', { jid: toJidObj(jid) }, null));
+    // Use the shared converter. The local copy this replaced dropped the device
+    // suffix on @lid JIDs: it split "112713111982325:49@lid" into user and
+    // device, then fell through to a JID_PAIR built from `user` alone, so every
+    // device of a contact encoded to the identical "112713111982325@lid". The
+    // server saw one repeated JID, returned a single device-0 bundle, and no
+    // session was ever built for the other devices — leaving them unable to
+    // decrypt anything we sent. jidStrToObj keeps the colon inside the user
+    // part for @lid, which is what the server expects.
+    const userNodes = jids.map(jid => new BinaryNode('user', { jid: jidStrToObj(jid) }, null));
     const iqId   = this._client._genMsgId();
     const iqNode = new BinaryNode('iq',
       { id: iqId, xmlns: 'encrypt', type: 'get', to: 's.whatsapp.net' },

package/lib/messages/MessageSender.js

@@ -973,6 +973,21 @@ class MessageSender {
     };
     if (options.edit) stanzaAttrs.edit = String(options.edit);
 
+    // Cache the plaintext here too, not just on the DM path. A group recipient
+    // that cannot decrypt sends a retry receipt exactly like a DM recipient
+    // does, and without this the client had nothing to re-send and dropped it
+    // with "no cached plaintext" — so the message was acked by the server and
+    // then silently never arrived.
+    if (this._client._sentMsgCache) {
+      this._client._sentMsgCache.set(msgId, {
+        plaintext, toJid: groupJid, msgId, mediaType, options, isGroup: true
+      });
+      if (this._client._sentMsgCache.size > 200) {
+        const firstKey = this._client._sentMsgCache.keys().next().value;
+        this._client._sentMsgCache.delete(firstKey);
+      }
+    }
+
     const msgNode = new BinaryNode('message', stanzaAttrs, msgContent);
     return this._dispatchAndAck(msgNode, msgId);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.5.70",
+  "version": "5.5.71",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",