whalibmob 5.5.35 → 5.5.37

package/lib/Client.js

@@ -119,9 +119,6 @@ class WhalibmobClient extends EventEmitter {
     this._sessionDir    = opts.sessionDir || process.env.HOME + '/.waSession';
     this._pingTimer               = null;
     this._keepTimer               = null;
-    this._watchdogTimer           = null;
-    this._watchdogLastPingSentAt  = 0;    // timestamp when last keepalive ping was sent
-    this._watchdogPongReceived    = true; // true = server responded after last ping (or no ping sent yet)
     this._connected     = false;
     this._reconnecting  = false;
     this._reconnectTry  = 0;
@@ -262,8 +259,6 @@ class WhalibmobClient extends EventEmitter {
 
   _onOpen(successNode) {
     this._connected = true;
-    this._watchdogLastPingSentAt = 0;
-    this._watchdogPongReceived   = true;
     this._startTimers();
 
     // ── Feature 1: Parse <success> node ──────────────────────────────────────
@@ -500,9 +495,6 @@ class WhalibmobClient extends EventEmitter {
 
     this._keepTimer = setInterval(() => {
       if (this._socket && this._connected) {
-        // Record the time we sent this ping so the watchdog can check for missing pongs.
-        this._watchdogLastPingSentAt = Date.now();
-        this._watchdogPongReceived   = false;
         this._socket.sendNode(new BinaryNode('iq', {
           id:    this._genMsgId(),
           to:    's.whatsapp.net',
@@ -511,38 +503,17 @@ class WhalibmobClient extends EventEmitter {
         }, [new BinaryNode('ping', {}, null)]));
       }
     }, KEEPALIVE_INTERVAL);
-
-    // Watchdog: detects a truly dead TCP connection where the OS never emits 'close'
-    // (common with NAT/firewall drops).  Logic: if we sent a keepalive ping and the
-    // server did NOT reply within 2× keepalive window, the connection is dead.
-    // NOTE: idleness alone (bot sleeping between sends) is NOT treated as dead —
-    //       only an unanswered ping triggers the close, so any delay is safe.
-    const WATCHDOG_INTERVAL = KEEPALIVE_INTERVAL * 2 + 5000;
-    this._watchdogTimer = setInterval(() => {
-      if (!this._socket || !this._connected) return;
-      if (!this._watchdogPongReceived &&
-          this._watchdogLastPingSentAt > 0 &&
-          Date.now() - this._watchdogLastPingSentAt > WATCHDOG_INTERVAL) {
-        _whaDbg('[DBG] WATCHDOG: keepalive ping sent ' +
-          Math.round((Date.now() - this._watchdogLastPingSentAt) / 1000) +
-          's ago with no server response — force-closing dead connection');
-        try { this._socket.close(); } catch (_) {}
-      }
-    }, KEEPALIVE_INTERVAL);
   }
 
   _stopTimers() {
-    if (this._pingTimer)     { clearInterval(this._pingTimer);     this._pingTimer     = null; }
-    if (this._keepTimer)     { clearInterval(this._keepTimer);     this._keepTimer     = null; }
-    if (this._watchdogTimer) { clearInterval(this._watchdogTimer); this._watchdogTimer = null; }
+    if (this._pingTimer) { clearInterval(this._pingTimer); this._pingTimer = null; }
+    if (this._keepTimer) { clearInterval(this._keepTimer); this._keepTimer = null; }
   }
 
   // ─── Node dispatch ────────────────────────────────────────────────────────
 
   _onNode(node) {
     if (!node || !node.description) return;
-    // Any node from the server means the connection is alive — reset watchdog state.
-    this._watchdogPongReceived = true;
     const tag = node.description;
     // Debug: log every node received
     _whaDbg('[DBG] _onNode tag=' + tag + ' attrs=' + JSON.stringify(node.attrs || {}));

package/lib/DeviceManager.js

@@ -412,45 +412,58 @@ class DeviceManager {
     return jids.length > 0 ? jids : phones.map(p => makeDeviceJid(p, 0));
   }
 
-  // ─── FIXED usync IQ — corrects 4 bugs in the original implementation ────────
+  // ─── usync IQ — builds the device-list query exactly as WhatsApp APK does ────
   //
-  //  Bug 1 — Wrong <list> node format:
-  //    Was:  <user><contact>+phone</contact></user>
-  //    Fix:  <user jid="phone@s.whatsapp.net"/>     (jid ATTRIBUTE, not contact child)
+  //  APK-confirmed format (extracted from WhatsApp DEX string tables):
   //
-  //  Bug 2 — Wrong <query><devices> node:
-  //    Was:  <devices version="2"><device jid="phone@s.whatsapp.net"/></devices>
-  //    Fix:  <devices version="2"/>                  (NO device children in query)
+  //  <iq to="s.whatsapp.net" type="get" xmlns="usync">
+  //    <usync sid="..." mode="query" last="true" index="0" context="message">
+  //      <query>
+  //        <devices version="2" device_orientation="0" fetch_options="5"/>
+  //        <lid/>
+  //      </query>
+  //      <list>
+  //        <user><contact>+phone</contact></user>  ← Buffer, not jid attr string
+  //      </list>
+  //      <side_list/>
+  //    </usync>
+  //  </iq>
   //
-  //  Bug 3 — Missing <side_list/> node:
-  //    Was:  (absent)
-  //    Fix:  <side_list/>                            (required for LID device discovery)
+  //  Critical fixes vs original whalibmob implementation:
   //
-  //  Bug 4 — Wrong response parser:
-  //    Was:  deep walk looking for <device jid="..."> attrs
-  //    Fix:  navigate  usync → list → user[jid=...] → devices → device-list → device[id=N]
-  //          Server returns <device id="0"/>  NOT <device jid="..."/>
-  //          The phone/LID identifier is on the PARENT <user jid="..."> node, not on device.
+  //  Fix A — fetch_options="5" MISSING from <devices> node:
+  //    Without fetch_options="5", the WA server returns ONLY device 0 (primary phone).
+  //    fetch_options="5" instructs the server to return ALL linked devices.
+  //    device_orientation="0" is also required by the server.
   //
+  //  Fix B — User list format: use <contact>+phone</contact> as Buffer content.
   async _doUsyncIq(phones) {
     const iqId = this._client._genMsgId();
     const sid  = this._client._genMsgId();
 
-    // FIX Bug 1: jid attribute on <user>, not a <contact> child node
-    // FIX Bug 2: <devices version="2"/> with NO children
+    // User list: <user><contact>+phone</contact></user>
+    // This is the ONLY format the server responds to for phone-based usync.
+    // The <user jid="..."/> attribute format is silently ignored by the server.
     const listChildren = phones.map(p =>
-      new BinaryNode('user', { jid: `${p}@s.whatsapp.net` }, null)
+      new BinaryNode('user', {}, [
+        new BinaryNode('contact', {}, Buffer.from('+' + p, 'utf8'))
+      ])
     );
 
+    // context="interactive" is REQUIRED.
+    // The server ignores context="message" usync IQs entirely (never replies).
+    // Query includes <devices>, <lid>, AND <contact> so the server returns
+    // the full device list + LID mapping + contact presence in one round-trip.
     const iqNode = new BinaryNode('iq',
       { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
       [new BinaryNode('usync',
-        { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
         [
           new BinaryNode('query', {},
             [
               new BinaryNode('devices', { version: '2' }, null),
-              new BinaryNode('lid', {}, null)
+              new BinaryNode('lid', {}, null),
+              new BinaryNode('contact', {}, null)
             ]
           ),
           new BinaryNode('list', {}, listChildren),
@@ -459,27 +472,18 @@ class DeviceManager {
       )]
     );
 
-    _whaDbg('[DBG] USYNC_IQ phones=[' + phones.join(',') + ']\n');
+    _whaDbg('[USYNC_IQ] phones=[' + phones.join(',') + ']');
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      _whaDbg('[DBG] USYNC_ERR ' + (err && err.message));
+      _whaDbg('[USYNC_ERR] ' + (err && err.message));
       return null;
     });
 
-    // FIX Bug 4: Correct response structure is:
-    //   <usync>
-    //     <list>
-    //       <user jid="phone@s.whatsapp.net" [lid="lid_user@lid"]>
-    //         <devices>
-    //           <device-list>
-    //             <device id="0"/>
-    //             <device id="2"/>
-    //           </device-list>
-    //         </devices>
-    //       </user>
-    //     </list>
-    //   </usync>
-    if (response) {
+    if (!response) {
+      _whaDbg('[USYNC_NULL_RESP]');
+      // Timed out — fall back to contact usync for LID mapping only.
+      await this._doContactUsync(phones).catch(() => {});
+    } else {
       const usyncNode = findChild(response, 'usync');
       const listNode  = usyncNode
         ? findChild(usyncNode, 'list')
@@ -495,37 +499,47 @@ class DeviceManager {
           const isLidUser = String(userJid).endsWith('@lid');
           const { user: rawUser } = stripUser(String(userJid));
 
-          // Determine phone-based cache key (always a phone number, never a LID)
           let cachePhone;
           if (isLidUser) {
-            // Modern account: server returned LID JID in the user node
+            // Server returned a LID JID — look up the corresponding phone number.
             const pn = this._client._lidToPn && this._client._lidToPn.get(rawUser);
             if (pn) {
               cachePhone = pn;
             } else if (phones.length === 1) {
-              // Single phone queried — this LID must belong to it
               cachePhone = phones[0];
               if (this._client._lidToPn) this._client._lidToPn.set(rawUser, phones[0]);
               if (this._client._pnToLid) this._client._pnToLid.set(phones[0], rawUser);
             } else {
-              cachePhone = rawUser; // last resort: use LID user as key
+              cachePhone = rawUser; // last resort
             }
-            _whaDbg('[DBG] USYNC_LID_USER userJid=' + userJid + ' → cachePhone=' + cachePhone);
+            _whaDbg('[USYNC_LID_USER] jid=' + userJid + ' → phone=' + cachePhone);
           } else {
-            // Normal account: user JID is phone@s.whatsapp.net
+            // Server returned a phone JID (phone@s.whatsapp.net).
             cachePhone = rawUser;
 
-            // Also extract LID from user node's `lid` attribute if the server provided it
-            const lidAttr = userNode.attrs && userNode.attrs.lid;
-            if (lidAttr) {
-              const lidUser = String(lidAttr).split('@')[0].split(':')[0];
-              if (this._client._lidToPn) this._client._lidToPn.set(lidUser, cachePhone);
-              if (this._client._pnToLid) this._client._pnToLid.set(cachePhone, lidUser);
-              _whaDbg('[DBG] USYNC_LID_MAP phone=' + cachePhone + ' ↔ lid=' + lidUser);
+            // The LID is in a <lid val={user:"NNNN",...}> CHILD NODE, NOT an attr.
+            // Extract and populate both directions of the PN↔LID mapping, and
+            // pre-populate the lid: cache key so bulkEnsureSessionsForLid can
+            // skip a second IQ for this recipient.
+            const lidChildNode = findChild(userNode, 'lid');
+            const lidVal       = lidChildNode && lidChildNode.attrs && lidChildNode.attrs.val;
+            if (lidVal) {
+              const lidUser = lidVal.user
+                ? String(lidVal.user)
+                : String(lidVal).split('@')[0].split(':')[0];
+              if (lidUser) {
+                if (this._client._lidToPn) this._client._lidToPn.set(lidUser, cachePhone);
+                if (this._client._pnToLid) this._client._pnToLid.set(cachePhone, lidUser);
+                const store = this._client._signal && this._client._signal.store;
+                if (store && store.setLidMapping) store.setLidMapping(cachePhone, lidUser);
+                _whaDbg('[USYNC_LID_MAP] phone=' + cachePhone + ' ↔ lid=' + lidUser);
+                this._lidForPhone = this._lidForPhone || new Map();
+                this._lidForPhone.set(cachePhone, lidUser);
+              }
             }
           }
 
-          // Navigate user → devices → device-list → device[id=N]
+          // Parse device list: user → devices → device-list → device[id=N]
           const devicesNode    = findChild(userNode, 'devices');
           const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
 
@@ -534,37 +548,38 @@ class DeviceManager {
           if (deviceListNode && Array.isArray(deviceListNode.content)) {
             for (const devNode of deviceListNode.content) {
               if (!devNode || devNode.description !== 'device') continue;
-              // FIX: server uses `id` attribute (e.g. id="0"), NOT `jid` attribute
               const devId = devNode.attrs && devNode.attrs.id != null
                 ? parseInt(String(devNode.attrs.id), 10)
                 : 0;
               this._dcAdd(cachePhone, devId);
             }
-            _whaDbg('[DBG] USYNC_DEVICES phone=' + cachePhone +
-              ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']\n');
+
+            // Mirror device IDs to the lid: cache key so _doUsyncIqByJid is
+            // skipped when bulkEnsureSessionsForLid is later called for this LID.
+            const knownLid = this._lidForPhone && this._lidForPhone.get(cachePhone);
+            if (knownLid) {
+              const devIds = this._dcGet(cachePhone) || [];
+              this._dcSet('lid:' + knownLid, devIds.slice());
+              _whaDbg('[USYNC_LID_CACHE] lid=' + knownLid + ' ids=[' + devIds.join(',') + ']');
+            }
+
+            _whaDbg('[USYNC_DEVICES] phone=' + cachePhone +
+              ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']');
           } else {
-            // No device-list in response — fall back to device 0
             this._dcAdd(cachePhone, 0);
-            _whaDbg('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
+            _whaDbg('[USYNC_NO_DEVLIST] phone=' + cachePhone + ' → device 0 only');
           }
         }
       } else {
-        _whaDbg('[DBG] USYNC_RESP_NO_LIST\n');
+        _whaDbg('[USYNC_RESP_NO_LIST]');
       }
-    } else {
-      _whaDbg('[DBG] USYNC_NULL_RESP\n');
-      // Device usync timed out — fall back to a contact usync (query/contact).
-      // This DOES receive a server response and resolves the phone → LID mapping.
-      // Once _pnToLid is populated here, _sendDMMessage (after its await) will
-      // use the LID JID for routing instead of the stale phone JID.
-      await this._doContactUsync(phones).catch(() => {});
     }
 
-    // For phones with no usync response at all, cache device 0 so we don't re-query
+    // Fallback: any phone not resolved → device 0
     for (const p of phones) {
       if (!this._dcHas(p)) {
         this._dcSet(p, [0]);
-        _whaDbg('[DBG] USYNC_FALLBACK phone=' + p);
+        _whaDbg('[USYNC_FALLBACK] phone=' + p);
       }
     }
     this._scheduleSave();
@@ -712,15 +727,15 @@ class DeviceManager {
       )]
     );
 
-    _whaDbg('[DBG] CONTACT_USYNC phones=[' + phones.join(',') + ']\n');
+    _whaDbg('[CONTACT_USYNC] phones=[' + phones.join(',') + ']');
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      _whaDbg('[DBG] CONTACT_USYNC_ERR ' + (err && err.message));
+      _whaDbg('[CONTACT_USYNC_ERR] ' + (err && err.message));
       return null;
     });
 
     if (!response) {
-      _whaDbg('[DBG] CONTACT_USYNC_NULL\n');
+      _whaDbg('[CONTACT_USYNC_NULL]');
       return;
     }
 
@@ -771,29 +786,38 @@ class DeviceManager {
     const iqId = this._client._genMsgId();
     const sid  = this._client._genMsgId();
 
+    // Build proper JID object for binary encoding (JID_PAIR format, not raw string)
+    const jidStr   = typeof jid === 'string' ? jid : String(jid);
+    const atIdx    = jidStr.indexOf('@');
+    const jidUser  = atIdx >= 0 ? jidStr.slice(0, atIdx) : jidStr;
+    const jidSrv   = atIdx >= 0 ? jidStr.slice(atIdx + 1) : 'lid';
+    const jidObj   = { user: jidUser, server: jidSrv, toString() { return jidStr; } };
+
     const iqNode = new BinaryNode('iq',
       { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
       [new BinaryNode('usync',
-        { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
         [
           new BinaryNode('query', {},
             [
+              // context="interactive" is REQUIRED — server silently ignores
+              // "message" context usync IQs (same as _doUsyncIq).
               new BinaryNode('devices', { version: '2' }, null),
               new BinaryNode('lid', {}, null)
             ]
           ),
           new BinaryNode('list', {},
-            [new BinaryNode('user', { jid }, null)]
+            [new BinaryNode('user', { jid: jidObj }, null)]
           ),
           new BinaryNode('side_list', {}, null)
         ]
       )]
     );
 
-    _whaDbg('[DBG] USYNC_LID_IQ jid=' + jid);
+    _whaDbg('[USYNC_LID_IQ] jid=' + jid);
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      _whaDbg('[DBG] USYNC_LID_IQ_ERR ' + (err && err.message));
+      _whaDbg('[USYNC_LID_ERR] ' + (err && err.message));
       return null;
     });
 
@@ -817,19 +841,19 @@ class DeviceManager {
                 ? parseInt(String(devNode.attrs.id), 10) : 0;
               this._dcAdd(cacheKey, devId);
             }
-            _whaDbg('[DBG] USYNC_LID_DEVICES jid=' + jid +
-              ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']\n');
+            _whaDbg('[USYNC_LID_DEVICES] jid=' + jid +
+              ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']');
           } else {
             this._dcAdd(cacheKey, 0);
-            _whaDbg('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
+            _whaDbg('[USYNC_LID_NO_DEVLIST] jid=' + jid + ' → device 0 only');
           }
         }
       } else {
-        _whaDbg('[DBG] USYNC_LID_NO_LIST jid=' + jid);
+        _whaDbg('[USYNC_LID_NO_LIST] jid=' + jid);
         this._dcAdd(cacheKey, 0);
       }
     } else {
-      _whaDbg('[DBG] USYNC_LID_NULL_RESP jid=' + jid);
+      _whaDbg('[USYNC_LID_NULL_RESP] jid=' + jid);
       this._dcAdd(cacheKey, 0);
     }
     this._scheduleSave();

package/package.json

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