whalibmob 5.5.63 → 5.5.65

package/lib/BinaryNode.js

@@ -44,11 +44,41 @@ function _writeListSize(size, parts) {
   }
 }
 
+// Servers that make a string an addressable JID rather than free text.
+const _JID_SERVERS = new Set([
+  's.whatsapp.net', 'g.us', 'lid', 'broadcast', 'call', 'newsletter', 'c.us', 's.us'
+]);
+
+// "120363427770886227@g.us" / "40756469325:2@s.whatsapp.net" → JID object.
+// Returns null for anything that is not a full JID, so plain strings (and
+// bare server tokens like "g.us", which the dictionary already encodes as a
+// valid address) keep their existing encoding untouched.
+function _jidFromString(str) {
+  const at = str.indexOf('@');
+  if (at <= 0 || at === str.length - 1) return null;
+  const server = str.slice(at + 1);
+  if (!_JID_SERVERS.has(server)) return null;
+  const raw   = str.slice(0, at);
+  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;
+  // Mirrors jidStrToObj in DeviceManager: AD_JID only for multi-device
+  // @s.whatsapp.net, and @lid keeps the colon inside the user part.
+  if (server === 's.whatsapp.net' && device > 0) return { user, agent: 0, device, server };
+  if (server === 'lid' && device > 0)            return { user: raw, server };
+  return { user, server };
+}
+
 function _writeValue(value, parts) {
   if (value === null || value === undefined) {
     parts.push(Buffer.from([TAG.LIST_EMPTY]));
   } else if (typeof value === 'string') {
-    _writeString(value, parts);
+    // A full JID written as a plain string would go out as a raw text blob,
+    // which the server cannot route — IQs addressed that way simply never get
+    // an answer. Encode it as JID_PAIR/AD_JID like an object JID.
+    const jid = _jidFromString(value);
+    if (jid) _writeJid(jid, parts);
+    else     _writeString(value, parts);
   } else if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
     const buf = Buffer.isBuffer(value) ? value : Buffer.from(value);
     _writeBytes(buf, parts);
@@ -97,9 +127,25 @@ function _writeBytes(buf, parts) {
   parts.push(buf);
 }
 
+// AD_JID agent byte ↔ domain. 0 = phone JIDs, 1 = LIDs.
+const _AGENT_SERVER = { 0: 's.whatsapp.net', 1: 'lid' };
+function _serverForAgent(agent) {
+  return _AGENT_SERVER[agent] || 's.whatsapp.net';
+}
+function _agentForServer(server) {
+  return server === 'lid' ? 1 : 0;
+}
+
 function _writeJid(jid, parts) {
-  if (jid.agent || jid.device) {
-    parts.push(Buffer.from([TAG.AD_JID, jid.agent || 0, jid.device || 0]));
+  // Derive the agent from the domain only when this JID is going out as AD_JID
+  // anyway (explicit agent, or a device suffix). A plain LID keeps its
+  // JID_PAIR + 'lid' server-token encoding, which is what the server expects
+  // and what the rest of the codebase already produces.
+  const agent = (jid.agent !== undefined && jid.agent !== null)
+    ? jid.agent
+    : (jid.device ? _agentForServer(jid.server) : 0);
+  if (agent || jid.device) {
+    parts.push(Buffer.from([TAG.AD_JID, agent || 0, jid.device || 0]));
     _writeString(jid.user, parts);
   } else {
     parts.push(Buffer.from([TAG.JID_PAIR]));
@@ -259,7 +305,15 @@ class NodeDecoder {
     const device = this._readByte();
     const userToken = this._readByte();
     const user = this._readString(userToken);
-    return { user, agent, device, server: 's.whatsapp.net', toString() { return `${user}@s.whatsapp.net`; } };
+    // The agent byte selects the domain — it is not decoration. Hardcoding
+    // s.whatsapp.net turned every LID participant (agent 1) into a phone JID
+    // 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);
+    return {
+      user, agent, device, server,
+      toString() { return `${user}@${server}`; }
+    };
   }
 }
 

package/lib/Client.js

@@ -11,6 +11,10 @@ const { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, assert
 const { getDeviceConfig } = require('./DeviceConfig');
 const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts } = require('./Store');
 const { BinaryNode }      = require('./BinaryNode');
+const { NodeCache }       = require('@cacheable/node-cache');
+
+// Group metadata cache lifetime — matches DeviceManager's device cache.
+const GROUP_META_CACHE_TTL = '5m';
 const { SignalProtocol }  = require('./signal/SignalProtocol');
 const { DeviceManager }   = require('./DeviceManager');
 const {
@@ -134,13 +138,21 @@ class WhalibmobClient extends EventEmitter {
     this._mediaConn     = null;
     this._pendingIqs       = new Map();   // id → resolve fn
     this._pendingAcks      = new Map();   // msgId → resolve fn
+    // groupJid → parsed metadata.  Mirrors DeviceManager's device cache: a TTL
+    // so membership changes we never saw a notification for still heal, plus
+    // in-flight dedup so a burst of sends to the same group issues one IQ.
+    this._groupMetaCache    = new NodeCache({ ttl: GROUP_META_CACHE_TTL });
+    this._groupMetaInflight = new Map();  // groupJid → Promise<metadata>
     this._groupMembers     = new Map();   // groupJid → Set<memberJid>
     this._lidToPn          = new Map();   // LID user → phone number
     this._pnToLid          = new Map();   // phone number → LID user
     this._myLid            = null;        // own LID JID received from <success> node
     this._groupAddressingMode = new Map(); // groupJid → 'lid' | 'pn'
-    this._retryPending     = new Map();   // msgId → {node, retryCount}
-    this._retryPreKeyIdx   = 0;           // rotating index for assigning unique prekeys to retries
+    this._retryPending     = new Map();   // msgId → {node, count, pkId}
+    this._retryPreKeyIdx   = 0;           // rotating index, fallback when every prekey is reserved
+    // keyIds handed out by unresolved retries — never advertise one twice, or
+    // the second sender's pkmsg arrives after the key was consumed and deleted.
+    this._retryAdvertisedPreKeys = new Set();
     this._appStateVersions = {};          // collectionName → version (int)
     this._sentMsgCache     = new Map();   // msgId → {plaintext, toJid, msgId, mediaType, options, recipientPhone}
     this._tcTokenStore            = null; // TcTokenStore — loaded in init()
@@ -677,6 +689,7 @@ class WhalibmobClient extends EventEmitter {
 
     this._signal.decrypt(sigJid, encType, cipherBuf)
       .then(async plaintext => {
+        this._resolveRetry(id);
         const decoded = this._decodeMsg(plaintext);
         _whaDbg('[DBG] DM_DECODED id=' + id + ' type=' + decoded.type + ' ptLen=' + (plaintext ? plaintext.length : 0) + ' hasSKDM=' + !!(decoded.skdm || decoded.type === 'senderKeyDistribution'));
 
@@ -747,6 +760,7 @@ class WhalibmobClient extends EventEmitter {
 
     this._signal.senderKeyDecrypt(from, participant, cipherBuf)
       .then(plaintext => {
+        this._resolveRetry(id);
         const decoded = this._decodeMsg(plaintext);
         if (decoded.type === 'senderKeyDistribution') return;
         if (decoded.type === 'protocol') {
@@ -950,6 +964,17 @@ class WhalibmobClient extends EventEmitter {
   //   - <registration> 4-byte reg-id
   //   - <keys> block (from retry #1): type + identity + key + skey + device-identity
 
+  // A message we asked to be re-sent finally decrypted (or we gave up on it).
+  // Release its reserved prekey so the pool does not drain over a long session.
+  _resolveRetry(msgId) {
+    const pending = this._retryPending.get(msgId);
+    if (!pending) return;
+    if (pending.pkId !== null && pending.pkId !== undefined) {
+      this._retryAdvertisedPreKeys.delete(pending.pkId);
+    }
+    this._retryPending.delete(msgId);
+  }
+
   _sendRetryRequest(msgId, origNode) {
     const existing = this._retryPending.get(msgId);
     const count    = existing ? existing.count + 1 : 1;
@@ -957,13 +982,25 @@ class WhalibmobClient extends EventEmitter {
 
     if (!this._socket || !this._connected) return;
 
-    // Assign a stable, unique prekey index per msgId on first retry
-    let pkIdx = existing ? existing.pkIdx : -1;
-    if (pkIdx < 0 && this._signal) {
+    // Pick a prekey that is not already advertised by another unresolved retry.
+    // A prekey is deleted the moment a pkmsg using it is decrypted, so handing
+    // the same one to two senders means the second arrives after the key is
+    // gone and dies with "Invalid PreKey ID". Indexing modulo the key count
+    // could not prevent that: the list shrinks as keys are consumed, so the
+    // rotating index wraps back onto ids that are still in flight.
+    let pkId = existing ? existing.pkId : null;
+    if (pkId === null && this._signal) {
       const allKeys = this._signal.getPreKeysForUpload(800);
-      pkIdx = this._retryPreKeyIdx++ % Math.max(1, allKeys.length);
+      const free = allKeys.find(k => !this._retryAdvertisedPreKeys.has(k.keyId));
+      // If every key is already spoken for, fall back to rotating rather than
+      // sending no bundle at all — a stale id beats no retry.
+      const chosen = free || allKeys[this._retryPreKeyIdx++ % Math.max(1, allKeys.length)];
+      if (chosen) {
+        pkId = chosen.keyId;
+        this._retryAdvertisedPreKeys.add(pkId);
+      }
     }
-    this._retryPending.set(msgId, { node: origNode, count, pkIdx });
+    this._retryPending.set(msgId, { node: origNode, count, pkId });
 
     // Use original message timestamp (not current time)
     const origAttrs = (origNode && origNode.attrs) || {};
@@ -982,7 +1019,7 @@ class WhalibmobClient extends EventEmitter {
         const spk        = this._signal.getSignedPreKeyForUpload();
         const identKey   = this._signal.getIdentityKey();
         const allPreKeys = this._signal.getPreKeysForUpload(800);
-        const pk         = allPreKeys[pkIdx] || allPreKeys[0];
+        const pk         = allPreKeys.find(k => k.keyId === pkId) || allPreKeys[0];
 
         if (spk && identKey && pk) {
           const keysChildren = [
@@ -1153,6 +1190,10 @@ class WhalibmobClient extends EventEmitter {
   _processGroupUpdate(node) {
     const groupJid = node.attrs && node.attrs.from;
     if (!groupJid) return;
+    // Membership/settings just changed — the cached metadata is now stale.
+    // The live _groupMembers set below stays authoritative for this session;
+    // dropping the cache makes the next getGroupMetadata() re-read the server.
+    this.invalidateGroupMetadata(groupJid);
     if (!this._groupMembers.has(groupJid)) this._groupMembers.set(groupJid, new Set());
     const members  = this._groupMembers.get(groupJid);
     const actor    = (node.attrs && node.attrs.participant) ? String(node.attrs.participant) : null;
@@ -1447,7 +1488,7 @@ class WhalibmobClient extends EventEmitter {
     this._groupMembers.set(jid, new Set(participants.map(p => p.jid)));
     this._groupAddressingMode.set(jid, addressingMode);
 
-    return {
+    const meta = {
       jid,
       subject:    a.subject || '',
       creation:   parseInt(a.creation, 10) || 0,
@@ -1461,27 +1502,71 @@ class WhalibmobClient extends EventEmitter {
       addressingMode,
       participants
     };
+
+    // Warm the cache from every parse — fetchAllGroups() then primes metadata
+    // for every group at once, so the first send to any of them skips its IQ.
+    if (this._groupMetaCache) this._groupMetaCache.set(jid, meta);
+    return meta;
   }
 
-  // Query metadata for a single group — returns parsed object
-  async getGroupMetadata(groupJid) {
-    const jid  = makeJid(groupJid);
-    const id   = this._genMsgId();
-    const node = new BinaryNode('iq', {
-      id,
-      to:    jid,
-      type:  'get',
-      xmlns: 'w:g2'
-    }, [new BinaryNode('query', { request: 'interactive' }, null)]);
+  // Query metadata for a single group — returns parsed object.
+  // Served from cache when available; pass { force: true } to bypass it.
+  async getGroupMetadata(groupJid, opts) {
+    const jid = makeJid(groupJid);
 
-    const response = await this._sendIq(node);
-    if (!response) return null;
+    if (!opts || !opts.force) {
+      const cached = this._groupMetaCache.get(jid);
+      if (cached) {
+        _whaDbg('[DBG] GROUP_META cache hit ' + jid);
+        // Re-seed the member/addressing maps — a reconnect clears them while
+        // the metadata cache is still warm.
+        this._groupMembers.set(jid, new Set(cached.participants.map(p => p.jid)));
+        this._groupAddressingMode.set(jid, cached.addressingMode);
+        return cached;
+      }
+      // Coalesce concurrent lookups for the same group onto one IQ.
+      const inflight = this._groupMetaInflight.get(jid);
+      if (inflight) {
+        _whaDbg('[DBG] GROUP_META joining in-flight query for ' + jid);
+        return inflight;
+      }
+    }
 
-    // Response may be the group node itself or wrap it
-    const groupNode = (response.description === 'group')
-      ? response
-      : findChild(response, 'group');
-    return this._parseGroupNode(groupNode);
+    const promise = (async () => {
+      const id   = this._genMsgId();
+      const node = new BinaryNode('iq', {
+        id,
+        to:    jid,
+        type:  'get',
+        xmlns: 'w:g2'
+      }, [new BinaryNode('query', { request: 'interactive' }, null)]);
+
+      const response = await this._sendIq(node);
+      if (!response) return null;
+
+      // Response may be the group node itself or wrap it
+      const groupNode = (response.description === 'group')
+        ? response
+        : findChild(response, 'group');
+      const meta = this._parseGroupNode(groupNode);
+      if (meta) this._groupMetaCache.set(jid, meta);
+      return meta;
+    })();
+
+    this._groupMetaInflight.set(jid, promise);
+    try {
+      return await promise;
+    } finally {
+      this._groupMetaInflight.delete(jid);
+    }
+  }
+
+  // Drop cached metadata for a group so the next read re-queries the server.
+  invalidateGroupMetadata(groupJid) {
+    const jid = makeJid(groupJid);
+    this._groupMetaCache.del(jid);
+    this._groupMetaInflight.delete(jid);
+    _whaDbg('[DBG] GROUP_META invalidated ' + jid);
   }
 
   // Fetch ALL groups the connected account participates in
@@ -2909,10 +2994,23 @@ class WhalibmobClient extends EventEmitter {
       type:  'set'
     }, [new BinaryNode('create', baseAttrs, createChildren)]);
     const resp = await this._sendIq(node);
-    if (!resp) return null;
+    // These used to return null indistinguishably, which surfaced to the CLI as
+    // a bare "no response" no matter what actually went wrong.
+    if (!resp) {
+      throw new Error('createGroup: no reply from server (IQ timed out)');
+    }
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      const text    = errNode && errNode.attrs && errNode.attrs.text;
+      throw new Error('createGroup: server rejected the request' +
+        (code ? ' (' + code + (text ? ' ' + text : '') + ')' : ''));
+    }
     const createNode = findChild(resp, 'create');
     const groupNode  = createNode ? findChild(createNode, 'group') : findChildDeep(resp, 'group');
-    if (!groupNode) return null;
+    if (!groupNode) {
+      throw new Error('createGroup: server reply contained no <group> node');
+    }
     return this._parseGroupNode(groupNode);
   }
 

package/package.json

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