whalibmob 5.5.63 → 5.5.64

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);

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,6 +138,11 @@ 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
@@ -1153,6 +1162,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 +1460,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 +1474,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 +2966,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.64",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",