whalibmob 5.5.72 → 5.5.75

package/lib/BinaryNode.js

@@ -310,9 +310,15 @@ class NodeDecoder {
     // that does not exist, so device queries for it came back empty, no Signal
     // session was ever built, and group sends were rejected with ack 479.
     const server = _serverForAgent(agent);
+    // The device must survive stringification. Everything downstream keys off
+    // the string form: fetchBundles maps bundles by it, so five devices all
+    // rendering as "user@server" collapsed into one entry and left the rest
+    // without a session; and jidToAddress parses the ":device" out of it, so
+    // dropping it addressed every Signal session as device 0 — which is why a
+    // message from a linked device could not be decrypted either.
     return {
       user, agent, device, server,
-      toString() { return `${user}@${server}`; }
+      toString() { return device ? `${user}:${device}@${server}` : `${user}@${server}`; }
     };
   }
 }

package/lib/DeviceManager.js

@@ -44,12 +44,18 @@ function jidStrToObj(jidStr) {
   if (server === 's.whatsapp.net' && device > 0) {
     return { user, agent: 0, device, server, toString() { return self; } };
   }
-  // @lid multi-device (e.g. "112713111982325:2@lid"): JID_PAIR with user="112713111982325:2"
-  // so the server receives the colon-device in the user string, not stripped.
-  // Without this, ":2@lid" is encoded as device-0 "@lid" and the server
-  // returns the wrong bundle (or ignores device 2 entirely).
+  // @lid multi-device (e.g. "112713111982325:2@lid"): AD_JID with the domain in
+  // the agent byte — 1 for lid, matching Baileys' writeJid, which emits AD_JID
+  // with domainType whenever a device is present.
+  //
+  // This previously packed the device into the user string as a JID_PAIR
+  // ("112713111982325:2"), a workaround from when the encoder could not express
+  // a LID agent at all and would otherwise have flattened the JID to device 0.
+  // The server does not recognise that shape: a prekey IQ addressed with it got
+  // no reply whatsoever and timed out, so no session was ever built for the
+  // contact's linked devices and sends failed with NO_OPEN_SESSION.
   if (server === 'lid' && device > 0) {
-    return { user: raw, server, toString() { return self; } };
+    return { user, agent: 1, device, server, toString() { return self; } };
   }
   // JID_PAIR: used for @lid device-0, @g.us, and primary (device-0) @s.whatsapp.net
   return { user, server, toString() { return self; } };
@@ -749,8 +755,37 @@ class DeviceManager {
     }
 
     if (allowPkmsg && fetchJids.length > 0) {
-      const bundles = await this.fetchBundles(fetchJids);
-      for (const [jid, bundle] of bundles) {
+      // Ask for the bundles by phone JID. The encrypt IQ is not answered at all
+      // when its <user> entries are @lid — it just times out — while the same
+      // request in phone form comes back in full. Translate through the known
+      // LID→PN mapping, keeping a link back so each bundle is installed under
+      // the LID address the participants node will use.
+      const pnForLid = this._client._lidToPn && this._client._lidToPn.get(lidUser);
+      const wireToLid = new Map();
+      let wireJids = fetchJids;
+      if (pnForLid) {
+        wireJids = fetchJids.map(j => {
+          const at    = j.indexOf('@');
+          const base  = at >= 0 ? j.slice(0, at) : j;
+          const colon = base.indexOf(':');
+          const dev   = colon >= 0 ? (parseInt(base.slice(colon + 1), 10) || 0) : 0;
+          const wire  = makeDeviceJid(pnForLid, dev, 's.whatsapp.net');
+          wireToLid.set(wire, j);
+          return wire;
+        });
+        _whaDbg('[DBG] LID_BUNDLE_VIA_PN lid=' + lidUser + ' pn=' + pnForLid +
+          ' jids=[' + wireJids.join(',') + ']\n');
+      } else {
+        _whaDbg('[DBG] LID_BUNDLE_NO_PN lid=' + lidUser + ' — requesting by LID\n');
+      }
+
+      const bundles = await this.fetchBundles(wireJids);
+      for (const [wireJid, bundle] of bundles) {
+        // Install under the @lid address: that is what the outgoing
+        // participants node — and therefore the encrypt step — looks the
+        // session up by. Stored under the phone user it is a different Signal
+        // address and would never be found.
+        const jid = wireToLid.get(wireJid) || wireJid;
         try {
           await signalProto.buildSessionFromBundle(jid, bundle);
           // ── CRITICAL: remap bundle JID back to @lid format ────────────────────
@@ -760,14 +795,13 @@ class DeviceManager {
           // nodes to also use @lid format — mixing @s.whatsapp.net participants with
           // a @lid routing address causes the server to close the connection.
           //
-          // The Signal session address is keyed only by (user, device) — the @server
-          // suffix is stripped by jidToAddress() — so the session is reachable via
-          // either @lid or @s.whatsapp.net.  We push the @lid form so the participants
-          // node is consistent with the routing.
-          //
-          // Mapping: strip @s.whatsapp.net / @lid suffix from jid, re-append @lid
-          // e.g. "112713111982325@s.whatsapp.net"   → "112713111982325@lid"
-          //      "112713111982325:2@s.whatsapp.net" → "112713111982325:2@lid"
+          // A Signal address is (user, device) with the @server stripped — but
+          // the user of a LID and the user of a phone JID are different strings,
+          // so a session is NOT reachable under both. That assumption is what
+          // left sends failing: bundles fetched in phone form were stored under
+          // the phone user while the participants node looked them up by LID.
+          // The session is installed under the @lid address above; this only
+          // normalises the JID pushed into readyJids.
           const jidBase = jid.replace(/@(?:s\.whatsapp\.net|lid)$/, '');
           const lidJidForDevice = jidBase + '@lid';
           readyJids.push(lidJidForDevice);

package/lib/messages/MessageSender.js

@@ -554,6 +554,21 @@ class MessageSender {
           return this._sendGroupMessage(toJid, msgId, plaintext, mediaType,
             Object.assign({}, options, { _479retry: true }));
         }
+        // No session could be built for a single member — usually a prekey IQ
+        // that timed out, leaving the device list cached with nothing behind
+        // it. Purge the cached devices and sessions so the retry re-fetches
+        // bundles and opens fresh pkmsg sessions instead of failing again.
+        if (err && /NO_OPEN_SESSION/.test(err.message) && !options._noSessionRetry) {
+          _whaDbg('[DBG] NO_OPEN_SESSION group ' + toJid + ' — forcing fresh pkmsg\n');
+          await this._forceSessionRebuild(
+            (this._client._getGroupMembers ? this._client._getGroupMembers(toJid) : [])
+          );
+          if (this._signal && this._signal.senderKeyStore) {
+            this._signal.senderKeyStore.invalidateSKDM(toJid);
+          }
+          return this._sendGroupMessage(toJid, msgId, plaintext, mediaType,
+            Object.assign({}, options, { _noSessionRetry: true }));
+        }
         throw err;
       }
     }
@@ -587,11 +602,41 @@ class MessageSender {
         return this._sendDMMessage(toJid, retryMsgId, plaintext, mediaType,
           Object.assign({}, options, { _479retry: true }));
       }
+      // ── No session at all ────────────────────────────────────────────────────
+      // Nothing could be encrypted for any device, so there is no ciphertext to
+      // send. This is what a timed-out prekey IQ leaves behind: the device list
+      // is cached but no session sits behind it, and every later send fails the
+      // same way because the cache hides the gap. Purge both and retry once, so
+      // the next attempt re-fetches bundles and opens fresh pkmsg sessions.
+      if (err && /NO_OPEN_SESSION/.test(err.message) && !options._noSessionRetry) {
+        _whaDbg('[DBG] NO_OPEN_SESSION dm ' + toJid + ' — forcing fresh pkmsg\n');
+        await this._forceSessionRebuild([toJid]);
+        return this._sendDMMessage(toJid, generateMessageId(), plaintext, mediaType,
+          Object.assign({}, options, { _noSessionRetry: true }));
+      }
       // ─────────────────────────────────────────────────────────────────────────
       throw err;
     }
   }
 
+  // Drop every cached device list and Signal session for these JIDs so the next
+  // send is forced to re-query devices, re-fetch prekey bundles and open new
+  // pkmsg sessions from scratch.
+  async _forceSessionRebuild(jids) {
+    const phones = [...new Set((jids || []).map(phoneFromJid).filter(Boolean))];
+    for (const phone of phones) {
+      await this._clearSignalSessionsForRecipient(phone).catch(() => {});
+    }
+    if (this._devMgr && phones.length) {
+      this._devMgr.clearCache(phones);
+      // LID device lists are cached under a separate key.
+      if (typeof this._devMgr._dcDel === 'function') {
+        this._devMgr._dcDel(phones.map(p => 'lid:' + p));
+      }
+    }
+    _whaDbg('[DBG] FORCE_SESSION_REBUILD purged ' + phones.join(', ') + '\n');
+  }
+
   // ─── Clear all Signal sessions for a phone-number recipient ─────────────────
   //
   // Called on error 479 (stale session).  Deletes:

package/lib/signal/SignalProtocol.js

@@ -320,6 +320,14 @@ function jidToAddress(jid) {
   } else if (jid && jid.user) {
     user     = jid.user;
     deviceId = jid.device || 0;
+    // A @lid JID is encoded as JID_PAIR with the device kept inside the user
+    // part ("112713111982325:49"), so an object can carry its device there
+    // rather than in .device. Without this the address came out as device 0.
+    const colonIdx = String(user).indexOf(':');
+    if (colonIdx >= 0) {
+      if (!deviceId) deviceId = parseInt(String(user).slice(colonIdx + 1), 10) || 0;
+      user = String(user).slice(0, colonIdx);
+    }
   } else {
     user = String(jid);
   }

package/package.json

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