whalibmob 5.6.8 → 5.6.9

package/cli.js

@@ -580,6 +580,23 @@ function attachEvents(client) {
     notConnected();
   });
 
+  // Someone else opened a session for this number. Reconnecting would fight
+  // them for it, so the client stands down and says so.
+  client.on('connection_replaced', (r) => {
+    _rl && _rl.pause();
+    fail('connection replaced');
+    out('  ' + r.message);
+    _rl && _rl.resume();
+    notConnected();
+  });
+
+  // A stanza whose shape we mishandled. Not fatal — the connection kept going.
+  client.on('node_error', (e) => {
+    _rl && _rl.pause();
+    fail('could not handle a <' + e.tag + '>: ' + (e.err && e.err.message));
+    _rl && (_rl.resume(), _rl.prompt(true));
+  });
+
   // The server declined the client, not the session. Nothing to re-register.
   client.on('client_rejected', (r) => {
     _rl && _rl.pause();

package/lib/Client.js

@@ -1019,6 +1019,29 @@ class WhalibmobClient extends EventEmitter {
   // We do NOT decrypt the patches — that requires the full LTHASH machinery.
   // We DO update our version counters from the server response so that we
   // never re-request the same snapshot twice.
+  /**
+   * Acknowledge a dirty bit so the server stops announcing it.
+   *
+   * `<ib><dirty type="..."/></ib>` is the server saying something changed while
+   * we were away. Whatever the client does about it, the bit has to be cleared
+   * or the same announcement arrives on every connection.
+   *
+   * @param {string} type            the dirty type, e.g. 'groups'
+   * @param {number|string} [fromTs] the timestamp the announcement carried
+   */
+  _cleanDirtyBits(type, fromTs) {
+    if (!this._socket || !this._connected) return;
+    const attrs = { type: String(type) };
+    if (fromTs) attrs.timestamp = String(fromTs);
+    _whaDbg('[DBG] CLEAN_DIRTY type=' + type + (fromTs ? ' t=' + fromTs : ''));
+    this._socket.sendNode(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'urn:xmpp:whatsapp:dirty'
+    }, [new BinaryNode('clean', attrs, null)]));
+  }
+
   _sendAppStateSyncForTypes(dirtyTypes) {
     if (!this._socket || !this._connected) return;
 
@@ -1037,7 +1060,11 @@ class WhalibmobClient extends EventEmitter {
     for (const type of dirtyTypes) {
       const mapped = COLLECTION_MAP[type];
       if (!mapped) {
-        _whaDbg('[DBG] ignoring unknown dirty type: ' + type);
+        // "groups" is not an app-state collection, but it is still a dirty bit
+        // the server expects to be cleared. Ignoring it meant the server
+        // re-announced it on every single connection, forever.
+        _whaDbg('[DBG] DIRTY type=' + type + ' — not an app-state collection, clearing the bit');
+        this._cleanDirtyBits(type);
         continue;
       }
       for (const c of mapped) collections.add(c);
@@ -1134,18 +1161,31 @@ class WhalibmobClient extends EventEmitter {
       try { _whaDbg('[DBG] IQ_ERROR content=' + JSON.stringify(node.content)); } catch(_) {}
     }
 
-    if      (tag === 'iq')           this._handleIq(node);
-    else if (tag === 'message')      this._handleMessage(node);
-    else if (tag === 'receipt')      this._handleReceipt(node);
-    else if (tag === 'ack')          this._handleAck(node);
-    else if (tag === 'notification') this._handleNotification(node);
-    else if (tag === 'presence')     this._handlePresence(node);
-    else if (tag === 'call')         this._handleCall(node);
-    else if (tag === 'ib')           this._handleIb(node);
-    else if (tag === 'success')      this.emit('session_refresh', { node }); // late success (re-auth)
-    else if (tag === 'failure')      this._handleFailure(node);
-    else if (tag === 'stream:error') this._handleStreamError(node);
-    else                             this.emit('node', node);
+    // One malformed stanza must not take the connection down with it.
+    //
+    // A throw here propagates out through the socket's frame reader, which
+    // reports it as a socket error — so a single unhandled shape in one
+    // notification looked like the transport failing, and every stanza queued
+    // behind it in the same offline batch was lost. Contain it: log the stanza
+    // that did it, tell the caller, carry on reading.
+    try {
+      if      (tag === 'iq')           this._handleIq(node);
+      else if (tag === 'message')      this._handleMessage(node);
+      else if (tag === 'receipt')      this._handleReceipt(node);
+      else if (tag === 'ack')          this._handleAck(node);
+      else if (tag === 'notification') this._handleNotification(node);
+      else if (tag === 'presence')     this._handlePresence(node);
+      else if (tag === 'call')         this._handleCall(node);
+      else if (tag === 'ib')           this._handleIb(node);
+      else if (tag === 'success')      this.emit('session_refresh', { node }); // late success (re-auth)
+      else if (tag === 'failure')      this._handleFailure(node);
+      else if (tag === 'stream:error') this._handleStreamError(node);
+      else                             this.emit('node', node);
+    } catch (err) {
+      _whaDbg('[DBG] NODE_HANDLER_ERR tag=' + tag + ' err=' + (err && err.message) +
+        ' attrs=' + JSON.stringify(node.attrs || {}));
+      this.emit('node_error', { tag, node, err });
+    }
   }
 
   // A stream error ends the connection; the reconnect in _onClose picks it up.
@@ -1157,16 +1197,55 @@ class WhalibmobClient extends EventEmitter {
   _handleStreamError(node) {
     const attrs  = (node && node.attrs) || {};
     const code   = attrs.code ? String(attrs.code) : null;
-    const reason = attrs.reason || code || 'unknown';
 
     if (code === '515') {
       _whaDbg('[DBG] STREAM_ERROR 515 — restart required after pairing, reconnecting');
-      this.emit('restart_required', { reason });
+      this.emit('restart_required', { reason: '515' });
+      return;
+    }
+
+    // Most stream errors carry no code at all — the reason is a child element,
+    // and for <conflict> the type attribute on it says which kind. Reading only
+    // the attributes reported every one of these as "code=null reason=unknown",
+    // which is the same message for a session someone else took over and a
+    // session that was deleted.
+    const child       = Array.isArray(node.content) && node.content[0] ? node.content[0] : null;
+    const childTag    = child && child.description ? child.description : null;
+    const conflictType = childTag === 'conflict' && child.attrs
+      ? String(child.attrs.type || '') : null;
+
+    if (conflictType === 'replaced') {
+      // Another client opened a session for this account and the server handed
+      // it over. Reconnecting immediately just takes it back, and the two ends
+      // trade the session until one of them is stopped — so this one stands
+      // down and says why.
+      _whaDbg('[DBG] STREAM_ERROR conflict/replaced — another client took the session');
+      this._fatal = true;
+      this.emit('connection_replaced', {
+        message: 'Another client connected with this number and took over the ' +
+                 'session. Reconnecting would take it back and the two would ' +
+                 'keep displacing each other, so this connection has stopped. ' +
+                 'Close the other client, then connect again.'
+      });
+      this.disconnect();
+      return;
+    }
+
+    if (conflictType === 'device_removed') {
+      // The companion was unlinked from the phone. Same meaning as a 401.
+      _whaDbg('[DBG] STREAM_ERROR conflict/device_removed — unlinked');
+      this._fatal = true;
+      this.emit('auth_failure', {
+        reason: '401', location: null, loggedOut: true, node
+      });
+      this.disconnect();
       return;
     }
 
-    _whaDbg('[DBG] STREAM_ERROR code=' + code + ' reason=' + reason);
-    this.emit('stream_error', { reason, code });
+    const reason = attrs.reason || conflictType || childTag || code || 'unknown';
+    _whaDbg('[DBG] STREAM_ERROR code=' + code + ' child=' + childTag +
+      ' conflict=' + conflictType + ' reason=' + reason);
+    this.emit('stream_error', { reason, code, conflictType, childTag, node });
   }
 
   // ─── IQ handling ──────────────────────────────────────────────────────────
@@ -1956,7 +2035,13 @@ class WhalibmobClient extends EventEmitter {
       // Server push: a contact's linked device list changed (they linked or
       // unlinked a tablet, desktop, etc.).  Invalidate that phone's cache entry
       // so the next send triggers a fresh usync IQ and reaches all their devices.
-      const fromJid   = attrs.from || '';
+      // BinaryNode decodes an AD-encoded JID into an object, not a string, so
+      // this has to be stringified before it can be split. It was not, and a
+      // <notification type="devices"> from a LID-addressed contact threw
+      // "fromJid.split is not a function" out of the node handler — taking the
+      // whole dispatch down with it, so every notification behind it in the
+      // offline queue was dropped too.
+      const fromJid   = String(attrs.from || '');
       const fromPhone = fromJid.split('@')[0].split(':')[0];
       if (fromPhone && this._devMgr) {
         this._devMgr._dcDel([fromPhone]);
@@ -1980,7 +2065,7 @@ class WhalibmobClient extends EventEmitter {
       // Server push: a contact re-registered WhatsApp (new identity key / new phone).
       // Their old Signal sessions are no longer valid — clear them and the device
       // cache so the next send builds a fresh pkmsg session from scratch.
-      const fromJid   = attrs.from || '';
+      const fromJid   = String(attrs.from || '');
       const fromPhone = fromJid.split('@')[0].split(':')[0];
       if (fromPhone && this._devMgr) {
         this._devMgr._dcDel([fromPhone]);

package/package.json

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