whalibmob 5.5.30 → 5.5.32

package/lib/Client.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { dbg: _whaDbg, configureLogger: _whaConfigLogger } = require('./logger');
+
 const EventEmitter  = require('events');
 const path          = require('path');
 const crypto        = require('crypto');
@@ -120,6 +122,7 @@ class WhalibmobClient extends EventEmitter {
     this._connected     = false;
     this._reconnecting  = false;
     this._reconnectTry  = 0;
+    this._hasConnectedOnce = false;   // true after first successful open; used to detect reconnects
     this._phoneNumber   = null;
     this._mediaConn     = null;
     this._pendingIqs       = new Map();   // id → resolve fn
@@ -136,6 +139,7 @@ class WhalibmobClient extends EventEmitter {
     this._tcTokenStore            = null; // TcTokenStore — loaded in init()
     this._inFlightTcTokenIssuance = new Set(); // dedupe concurrent proactive issuePrivacyTokens per JID
     this._inFlight463Recoveries   = new Set(); // dedupe concurrent 463-triggered token issuances per JID (separate from proactive)
+    if (opts.pino !== undefined) _whaConfigLogger(opts.pino);
   }
 
   get store()     { return this._store; }
@@ -181,6 +185,7 @@ class WhalibmobClient extends EventEmitter {
 
     this._signal = SignalProtocol.fromStore(this._store, signalFile, skFile);
     this._devMgr = new DeviceManager(this);
+    this._devMgr.attachSession(this._sessionDir, phoneNumber);
 
     // Restore LID ↔ phone mappings persisted from previous sessions.
     // This ensures we can route to LID JIDs even on fresh connections where no
@@ -191,7 +196,7 @@ class WhalibmobClient extends EventEmitter {
       this._pnToLid.set(phone, lid);
       this._lidToPn.set(lid, phone);
     }
-    process.stderr.write('[DBG] LID_RESTORED count=' + Object.keys(persistedLid).length + '\n');
+    _whaDbg('[DBG] LID_RESTORED count=' + Object.keys(persistedLid).length);
 
     await this._connectSocket();
     return this;
@@ -209,6 +214,8 @@ class WhalibmobClient extends EventEmitter {
     socket.on('close', ()    => this._onClose());
     socket.on('error', err   => this.emit('error', err));
 
+    // Pass reconnect attempt count into the Noise handshake ClientPayload
+    this._store.connectAttemptCount = this._reconnectTry;
     await socket.connect();
     return socket;
   }
@@ -271,6 +278,32 @@ class WhalibmobClient extends EventEmitter {
 
     this._requestMediaConnection();
     this._uploadPreKeys();
+
+    // ── Reconnect: flush stale device cache + background re-usync ─────────────
+    // On first connect _hasConnectedOnce is false — nothing extra to do.
+    // On every reconnect (network drop / NAT reset / server restart) we flush the
+    // in-memory device cache because contacts may have linked or unlinked devices
+    // while we were offline.  Disk files are kept for next restart warm-read;
+    // in-memory entries are cleared so the next send triggers a fresh usync IQ.
+    if (this._hasConnectedOnce && this._devMgr) {
+      const phonesInCache = Object.keys(this._devMgr._cacheSnapshot || {});
+      _whaDbg('[DBG] RECONNECT: flushing device cache (' + phonesInCache.length + ' entries) for fresh usync');
+      this._devMgr._dcFlush();
+
+      // Immediately re-usync own devices in the background (tablets / linked devices
+      // could have been added or unlinked while we were offline).
+      if (this._store && this._store.phoneNumber && this._signal) {
+        const ownPhone = this._store.phoneNumber;
+        setImmediate(() => {
+          if (!this._connected || !this._devMgr) return;
+          this._devMgr.ensureOwnDeviceSessions(ownPhone, this._signal, false)
+            .then(() => _whaDbg('[DBG] RECONNECT own-device usync done'))
+            .catch(e  => _whaDbg('[DBG] RECONNECT own-device usync err: ' + e.message));
+        });
+      }
+    }
+    this._hasConnectedOnce = true;
+
     this.emit('connected');
   }
 
@@ -293,11 +326,11 @@ class WhalibmobClient extends EventEmitter {
     if (!node) return;
     const attrs = node.attrs || {};
     // Debug: log the full success node structure
-    process.stderr.write('[DBG] SUCCESS node attrs=' + JSON.stringify(attrs) + '\n');
+    _whaDbg('[DBG] SUCCESS node attrs=' + JSON.stringify(attrs));
     if (Array.isArray(node.content)) {
       for (const child of node.content) {
         if (child && child.description) {
-          process.stderr.write('[DBG] SUCCESS child tag=' + child.description + ' attrs=' + JSON.stringify(child.attrs || {}) + '\n');
+          _whaDbg('[DBG] SUCCESS child tag=' + child.description + ' attrs=' + JSON.stringify(child.attrs || {}));
         }
       }
     }
@@ -331,7 +364,7 @@ class WhalibmobClient extends EventEmitter {
   _sendActiveIq() {
     if (!this._socket) return;
     const id = this._genMsgId();
-    process.stderr.write('[DBG] SEND active IQ id=' + id + '\n');
+    _whaDbg('[DBG] SEND active IQ id=' + id);
     this._socket.sendNode(new BinaryNode('iq', {
       id,
       to:    's.whatsapp.net',
@@ -391,7 +424,7 @@ class WhalibmobClient extends EventEmitter {
     for (const type of dirtyTypes) {
       const mapped = COLLECTION_MAP[type];
       if (!mapped) {
-        process.stderr.write('[DBG] ignoring unknown dirty type: ' + type + '\n');
+        _whaDbg('[DBG] ignoring unknown dirty type: ' + type);
         continue;
       }
       for (const c of mapped) collections.add(c);
@@ -409,7 +442,7 @@ class WhalibmobClient extends EventEmitter {
       }, null);
     });
 
-    process.stderr.write('[DBG] SEND appStateSync IQ id=' + id + ' collections=' + [...collections].join(',') + '\n');
+    _whaDbg('[DBG] SEND appStateSync IQ id=' + id + ' collections=' + [...collections].join(','));
     this._socket.sendNode(new BinaryNode('iq', {
       id,
       to:    's.whatsapp.net',
@@ -436,6 +469,7 @@ class WhalibmobClient extends EventEmitter {
   _onClose() {
     this._connected = false;
     this._stopTimers();
+    this._socket = null;   // clear dead reference — prevents accidental sends before reconnect
     this.emit('disconnected');
 
     // Reject all pending IQs / acks
@@ -469,11 +503,27 @@ class WhalibmobClient extends EventEmitter {
         }, [new BinaryNode('ping', {}, null)]));
       }
     }, KEEPALIVE_INTERVAL);
+
+    // Watchdog: if no data arrived from WhatsApp in 2× keepalive window,
+    // the connection is dead but TCP hasn't emitted 'close' (common with NAT drops).
+    // Force-destroy the socket so _onTcpClose fires and reconnection kicks in.
+    const WATCHDOG_INTERVAL = KEEPALIVE_INTERVAL * 2 + 5000;
+    this._watchdogTimer = setInterval(() => {
+      if (!this._socket || !this._connected) return;
+      const noiseSocket = this._socket;
+      const lastRx = noiseSocket._lastRxAt || 0;
+      const silentMs = Date.now() - lastRx;
+      if (silentMs > WATCHDOG_INTERVAL) {
+        _whaDbg('[DBG] WATCHDOG: no data for ' + Math.round(silentMs / 1000) + 's — force-closing dead connection');
+        try { noiseSocket.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._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; }
   }
 
   // ─── Node dispatch ────────────────────────────────────────────────────────
@@ -482,9 +532,9 @@ class WhalibmobClient extends EventEmitter {
     if (!node || !node.description) return;
     const tag = node.description;
     // Debug: log every node received
-    process.stderr.write('[DBG] _onNode tag=' + tag + ' attrs=' + JSON.stringify(node.attrs || {}) + '\n');
+    _whaDbg('[DBG] _onNode tag=' + tag + ' attrs=' + JSON.stringify(node.attrs || {}));
     if (tag === 'iq' && node.attrs && node.attrs.type === 'error') {
-      try { process.stderr.write('[DBG] IQ_ERROR content=' + JSON.stringify(node.content) + '\n'); } catch(_) {}
+      try { _whaDbg('[DBG] IQ_ERROR content=' + JSON.stringify(node.content)); } catch(_) {}
     }
 
     if      (tag === 'iq')           this._handleIq(node);
@@ -554,11 +604,11 @@ class WhalibmobClient extends EventEmitter {
         }
       }
     }
-    process.stderr.write('[DBG] _handleMessage from=' + from + ' participant=' + participant + ' senderPn=' + senderPn + ' id=' + id + '\n');
+    _whaDbg('[DBG] _handleMessage from=' + from + ' participant=' + participant + ' senderPn=' + senderPn + ' id=' + id);
     if (Array.isArray(node.content)) {
       for (const c of node.content) {
         if (c && c.description) {
-          process.stderr.write('[DBG] MSG_CHILD tag=' + c.description + ' attrs=' + JSON.stringify(c.attrs || {}) + ' contentLen=' + (Buffer.isBuffer(c.content) ? c.content.length : (typeof c.content === 'string' ? c.content.length : 0)) + '\n');
+          _whaDbg('[DBG] MSG_CHILD tag=' + c.description + ' attrs=' + JSON.stringify(c.attrs || {}) + ' contentLen=' + (Buffer.isBuffer(c.content) ? c.content.length : (typeof c.content === 'string' ? c.content.length : 0)));
         }
       }
     }
@@ -632,12 +682,12 @@ class WhalibmobClient extends EventEmitter {
     const sigJid = senderPn
       || ((participant && participant !== from) ? participant : from);
 
-    process.stderr.write('[DBG] DM_DECRYPT id=' + id + ' type=' + encType + ' sigJid=' + sigJid + ' cipherLen=' + cipherBuf.length + '\n');
+    _whaDbg('[DBG] DM_DECRYPT id=' + id + ' type=' + encType + ' sigJid=' + sigJid + ' cipherLen=' + cipherBuf.length);
 
     this._signal.decrypt(sigJid, encType, cipherBuf)
       .then(plaintext => {
         const decoded = this._decodeMsg(plaintext);
-        process.stderr.write('[DBG] DM_DECODED id=' + id + ' type=' + decoded.type + ' ptLen=' + (plaintext ? plaintext.length : 0) + ' hasSKDM=' + !!(decoded.skdm || decoded.type === 'senderKeyDistribution') + '\n');
+        _whaDbg('[DBG] DM_DECODED id=' + id + ' type=' + decoded.type + ' ptLen=' + (plaintext ? plaintext.length : 0) + ' hasSKDM=' + !!(decoded.skdm || decoded.type === 'senderKeyDistribution'));
 
         // Process embedded SKDM when bundled with a real message (WhatsApp MD always does this
         // on the first message of a new session, even for 1-on-1 DMs).
@@ -645,9 +695,9 @@ class WhalibmobClient extends EventEmitter {
         if (decoded.skdm && decoded.skdm.axolotlBytes && decoded.skdm.axolotlBytes[0] === 0x33) {
           try {
             this._signal.processSKDM(decoded.skdm.groupId, sigJid, decoded.skdm.axolotlBytes);
-            process.stderr.write('[DBG] SKDM_PROCESSED groupId=' + decoded.skdm.groupId + ' sender=' + sigJid + '\n');
+            _whaDbg('[DBG] SKDM_PROCESSED groupId=' + decoded.skdm.groupId + ' sender=' + sigJid);
           } catch (e) {
-            process.stderr.write('[DBG] SKDM_ERR ' + e.message + '\n');
+            _whaDbg('[DBG] SKDM_ERR ' + e.message);
           }
         }
 
@@ -656,9 +706,9 @@ class WhalibmobClient extends EventEmitter {
           if (decoded.axolotlBytes && decoded.axolotlBytes[0] === 0x33) {
             try {
               this._signal.processSKDM(decoded.groupId, sigJid, decoded.axolotlBytes);
-              process.stderr.write('[DBG] SKDM_ONLY_PROCESSED groupId=' + decoded.groupId + ' sender=' + sigJid + '\n');
+              _whaDbg('[DBG] SKDM_ONLY_PROCESSED groupId=' + decoded.groupId + ' sender=' + sigJid);
             } catch (e) {
-              process.stderr.write('[DBG] SKDM_ONLY_ERR ' + e.message + '\n');
+              _whaDbg('[DBG] SKDM_ONLY_ERR ' + e.message);
             }
           }
           this._sendReadReceipt(id, fromRaw, partRaw);
@@ -666,7 +716,7 @@ class WhalibmobClient extends EventEmitter {
         }
 
         // Protocol messages (revoke, ephemeral, etc.) — silent ACK
-        if (decoded.type === 'protocol') { process.stderr.write('[DBG] DM_FILTER proto id=' + id + '\n'); return; }
+        if (decoded.type === 'protocol') { _whaDbg('[DBG] DM_FILTER proto id=' + id); return; }
 
         this.emit('message', { id, from, participant, ts, decoded, node });
         this._sendReadReceipt(id, fromRaw, partRaw);
@@ -679,7 +729,7 @@ class WhalibmobClient extends EventEmitter {
         }
       })
       .catch(err => {
-        process.stderr.write('[DBG] DM_ERR id=' + id + ' err=' + (err && err.message) + '\n');
+        _whaDbg('[DBG] DM_ERR id=' + id + ' err=' + (err && err.message));
         this.emit('decrypt_error', { id, from, participant, err });
         this._sendRetryRequest(id, node);
       });
@@ -785,7 +835,7 @@ class WhalibmobClient extends EventEmitter {
     const msgId = String(attrs.id || '');
     const cached = this._sentMsgCache && this._sentMsgCache.get(msgId);
     if (!cached || !this._sender) {
-      process.stderr.write('[DBG] RETRY_RECV msgId=' + msgId + ' — no cached plaintext, skipping resend\n');
+      _whaDbg('[DBG] RETRY_RECV msgId=' + msgId + ' — no cached plaintext, skipping resend\n');
       return;
     }
 
@@ -793,7 +843,7 @@ class WhalibmobClient extends EventEmitter {
     // Extract bare phone number: "40756469325@s.whatsapp.net" → "40756469325"
     const recipientPhone = fromStr.split('@')[0].split('.')[0];
 
-    process.stderr.write('[DBG] RETRY_RECV msgId=' + msgId + ' from=' + fromStr + ' — clearing session + resending\n');
+    _whaDbg('[DBG] RETRY_RECV msgId=' + msgId + ' from=' + fromStr + ' — clearing session + resending\n');
 
     // Delete all Signal sessions for the recipient's devices so next send creates fresh pkmsg
     const sigStore = this._signal && this._signal.store;
@@ -801,7 +851,7 @@ class WhalibmobClient extends EventEmitter {
       const sessions = sigStore._sessions;
       Object.keys(sessions).forEach(addr => {
         if (addr.startsWith(recipientPhone + '.')) {
-          process.stderr.write('[DBG] RETRY deleting session for ' + addr + '\n');
+          _whaDbg('[DBG] RETRY deleting session for ' + addr);
           delete sessions[addr];
         }
       });
@@ -816,8 +866,8 @@ class WhalibmobClient extends EventEmitter {
     this._sender._sendDMMessage(
       cached.toJid, cached.msgId, cached.plaintext, cached.mediaType, cached.options
     )
-      .then(r  => process.stderr.write('[DBG] RETRY_RESEND ok id=' + r.id + '\n'))
-      .catch(e => process.stderr.write('[DBG] RETRY_RESEND_ERR: ' + e.message + '\n'));
+      .then(r  => _whaDbg('[DBG] RETRY_RESEND ok id=' + r.id + '\n'))
+      .catch(e => _whaDbg('[DBG] RETRY_RESEND_ERR: ' + e.message));
   }
 
   _handleAck(node) {
@@ -886,7 +936,7 @@ class WhalibmobClient extends EventEmitter {
     // Assign a stable, unique prekey index per msgId on first retry
     let pkIdx = existing ? existing.pkIdx : -1;
     if (pkIdx < 0 && this._signal) {
-      const allKeys = this._signal.getPreKeysForUpload(50);
+      const allKeys = this._signal.getPreKeysForUpload(800);
       pkIdx = this._retryPreKeyIdx++ % Math.max(1, allKeys.length);
     }
     this._retryPending.set(msgId, { node: origNode, count, pkIdx });
@@ -907,7 +957,7 @@ class WhalibmobClient extends EventEmitter {
       try {
         const spk        = this._signal.getSignedPreKeyForUpload();
         const identKey   = this._signal.getIdentityKey();
-        const allPreKeys = this._signal.getPreKeysForUpload(50);
+        const allPreKeys = this._signal.getPreKeysForUpload(800);
         const pk         = allPreKeys[pkIdx] || allPreKeys[0];
 
         if (spk && identKey && pk) {
@@ -929,15 +979,15 @@ class WhalibmobClient extends EventEmitter {
           const advBytes = buildOrGetAdvIdentity(this._store);
           if (advBytes && advBytes.length > 0) {
             keysChildren.push(new BinaryNode('device-identity', {}, advBytes));
-            process.stderr.write('[DBG] RETRY #' + count + ' for ' + msgId + ' — preKeyId=' + pk.keyId + ' +device-identity(' + advBytes.length + 'b)\n');
+            _whaDbg('[DBG] RETRY #' + count + ' for ' + msgId + ' — preKeyId=' + pk.keyId + ' +device-identity(' + advBytes.length + 'b)\n');
           } else {
-            process.stderr.write('[DBG] RETRY #' + count + ' for ' + msgId + ' — preKeyId=' + pk.keyId + ' (no advIdentity)\n');
+            _whaDbg('[DBG] RETRY #' + count + ' for ' + msgId + ' — preKeyId=' + pk.keyId + ' (no advIdentity)\n');
           }
 
           children.push(new BinaryNode('keys', {}, keysChildren));
         }
       } catch (e) {
-        process.stderr.write('[DBG] RETRY prekey bundle error: ' + e.message + '\n');
+        _whaDbg('[DBG] RETRY prekey bundle error: ' + e.message);
       }
     }
 
@@ -952,7 +1002,7 @@ class WhalibmobClient extends EventEmitter {
     if (origAttrs.recipient)   receiptAttrs.recipient  = origAttrs.recipient;
     if (origAttrs.participant) receiptAttrs.participant = origAttrs.participant;
 
-    process.stderr.write('[DBG] RETRY #' + count + ' receipt to=' + JSON.stringify(fromJid) + ' participant=' + JSON.stringify(origAttrs.participant || null) + '\n');
+    _whaDbg('[DBG] RETRY #' + count + ' receipt to=' + JSON.stringify(fromJid) + ' participant=' + JSON.stringify(origAttrs.participant || null));
     this._socket.sendNode(new BinaryNode('receipt', receiptAttrs, children));
   }
 
@@ -986,6 +1036,50 @@ class WhalibmobClient extends EventEmitter {
       this._handlePrivacyTokenNotification(node);
     }
 
+    if (type === 'devices') {
+      // 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 || '';
+      const fromPhone = fromJid.split('@')[0].split(':')[0];
+      if (fromPhone && this._devMgr) {
+        this._devMgr._dcDel([fromPhone]);
+        _whaDbg('[DBG] NOTIF_DEVICES invalidated cache for ' + fromPhone);
+        // Also process any inline <devices> list the server included
+        const devicesNode = findChildDeep(node, 'devices');
+        if (devicesNode) this._processDeviceUpdate(devicesNode);
+        // Background re-usync so the cache is warm before the next send
+        if (this._signal) {
+          setImmediate(() => {
+            if (!this._connected || !this._devMgr) return;
+            this._devMgr.bulkEnsureSessions([fromPhone], this._signal, false)
+              .then(() => _whaDbg('[DBG] NOTIF_DEVICES bg-usync done for ' + fromPhone))
+              .catch(e  => _whaDbg('[DBG] NOTIF_DEVICES bg-usync err: ' + e.message));
+          });
+        }
+      }
+    }
+
+    if (type === 'identity') {
+      // 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 fromPhone = fromJid.split('@')[0].split(':')[0];
+      if (fromPhone && this._devMgr) {
+        this._devMgr._dcDel([fromPhone]);
+        _whaDbg('[DBG] NOTIF_IDENTITY flushed device cache for re-registered ' + fromPhone);
+      }
+      if (fromPhone && this._signal && this._signal.store && this._signal.store._sessions) {
+        const sessions = this._signal.store._sessions;
+        let cleared = 0;
+        for (const addr of Object.keys(sessions)) {
+          if (addr.startsWith(fromPhone + '.')) { delete sessions[addr]; cleared++; }
+        }
+        _whaDbg('[DBG] NOTIF_IDENTITY cleared ' + cleared + ' Signal sessions for ' + fromPhone);
+      }
+    }
+
     // Ack the notification
     if (this._socket && this._connected) {
       this._socket.sendNode(new BinaryNode('ack', {
@@ -998,16 +1092,29 @@ class WhalibmobClient extends EventEmitter {
   }
 
   _processDeviceUpdate(devicesNode) {
-    if (!Array.isArray(devicesNode.content)) return;
+    // Called from _handleNotification(type='account_sync') and type='devices'.
+    // Rebuilds the device cache for the affected phones from the server-provided list.
+    // Previous bug: called Set.add() on cache entries that are number[] arrays → silently failed.
+    if (!Array.isArray(devicesNode.content) || !this._devMgr) return;
+
+    // Group all device IDs per phone from the notification
+    const phoneDevices = new Map();  // phone → number[]
     for (const deviceNode of devicesNode.content) {
       if (!deviceNode || deviceNode.description !== 'device') continue;
       const jid = deviceNode.attrs && deviceNode.attrs.jid;
-      if (jid && this._devMgr) {
-        const phone  = jid.split('@')[0].split(':')[0];
-        const device = parseInt((jid.split(':')[1] || '0').split('@')[0], 10);
-        if (!this._devMgr._deviceCache.has(phone)) this._devMgr._deviceCache.set(phone, new Set());
-        this._devMgr._deviceCache.get(phone).add(device);
-      }
+      if (!jid) continue;
+      const phone  = String(jid).split('@')[0].split(':')[0];
+      const device = parseInt((String(jid).split(':')[1] || '0').split('@')[0], 10);
+      if (!phoneDevices.has(phone)) phoneDevices.set(phone, []);
+      const ids = phoneDevices.get(phone);
+      if (!ids.includes(device)) ids.push(device);
+    }
+
+    // Replace cache entries atomically per phone (server list is authoritative)
+    for (const [phone, ids] of phoneDevices) {
+      this._devMgr._dcDel([phone]);       // evict stale entry
+      for (const id of ids) this._devMgr._dcAdd(phone, id);
+      _whaDbg('[DBG] DEV_UPDATE phone=' + phone + ' ids=[' + ids.join(',') + ']');
     }
   }
 
@@ -1114,7 +1221,7 @@ class WhalibmobClient extends EventEmitter {
   _requestMediaConnection() {
     if (!this._socket || !this._connected) return;
     const mcId = this._genMsgId();
-    process.stderr.write('[DBG] SEND media_conn IQ id=' + mcId + '\n');
+    _whaDbg('[DBG] SEND media_conn IQ id=' + mcId);
     this._socket.sendNode(new BinaryNode('iq', {
       id:    mcId,
       to:    's.whatsapp.net',
@@ -1146,7 +1253,7 @@ class WhalibmobClient extends EventEmitter {
   _uploadPreKeys() {
     if (!this._signal || !this._socket || !this._connected) return;
 
-    const preKeys  = this._signal.getPreKeysForUpload(50);
+    const preKeys  = this._signal.getPreKeysForUpload(800);
     const spk      = this._signal.getSignedPreKeyForUpload();
     const identKey = this._signal.getIdentityKey();
     if (!preKeys.length || !spk) return;
@@ -1163,7 +1270,7 @@ class WhalibmobClient extends EventEmitter {
     ]);
 
     const pkId = this._genMsgId();
-    process.stderr.write('[DBG] SEND uploadPreKeys IQ id=' + pkId + '\n');
+    _whaDbg('[DBG] SEND uploadPreKeys IQ id=' + pkId);
     this._socket.sendNode(new BinaryNode('iq', {
       id:    pkId,
       to:    's.whatsapp.net',
@@ -1413,7 +1520,7 @@ class WhalibmobClient extends EventEmitter {
         })
       ])
     ]);
-    process.stderr.write('[DBG] ISSUE_PRIVACY_TOKENS jid=' + normalizedJid + ' t=' + timestamp + ' iq_id=' + id + '\n');
+    _whaDbg('[DBG] ISSUE_PRIVACY_TOKENS jid=' + normalizedJid + ' t=' + timestamp + ' iq_id=' + id);
     return this._sendIq(node);
   }
 
@@ -1437,23 +1544,23 @@ class WhalibmobClient extends EventEmitter {
 
     // ── Debug: dump result structure so we can trace server response ─────────
     if (!result) {
-      process.stderr.write('[DBG] STORE_TCTOKEN result=NULL (IQ timeout or not matched) fallback=' + fallbackJid + '\n');
+      _whaDbg('[DBG] STORE_TCTOKEN result=NULL (IQ timeout or not matched) fallback=' + fallbackJid);
     } else {
       const contentLen = Array.isArray(result.content) ? result.content.length
                        : Buffer.isBuffer(result.content) ? result.content.length
                        : 0;
-      process.stderr.write('[DBG] STORE_TCTOKEN result type=' + (result.attrs && result.attrs.type) +
+      _whaDbg('[DBG] STORE_TCTOKEN result type=' + (result.attrs && result.attrs.type) +
         ' id=' + (result.attrs && result.attrs.id) +
-        ' contentLen=' + contentLen + '\n');
+        ' contentLen=' + contentLen);
       if (Array.isArray(result.content)) {
         result.content.forEach((c, i) => {
           if (c && c.description) {
             const childContent = Array.isArray(c.content) ? c.content.length + ' children'
                                : Buffer.isBuffer(c.content) ? c.content.length + 'B'
                                : String(c.content);
-            process.stderr.write('[DBG] STORE_TCTOKEN   child[' + i + '] tag=' + c.description +
+            _whaDbg('[DBG] STORE_TCTOKEN   child[' + i + '] tag=' + c.description +
               ' attrs=' + JSON.stringify(c.attrs || {}) +
-              ' content=' + childContent + '\n');
+              ' content=' + childContent);
           }
         });
       }
@@ -1486,13 +1593,13 @@ class WhalibmobClient extends EventEmitter {
           if (bytes && bytes.length) {
             this._tcTokenStore.setToken(jid, bytes, t);
             tokenStoredCount++;
-            process.stderr.write('[DBG] TCTOKEN_STORED jid=' + jid + ' t=' + t + ' len=' + bytes.length + '\n');
+            _whaDbg('[DBG] TCTOKEN_STORED jid=' + jid + ' t=' + t + ' len=' + bytes.length);
           } else {
-            process.stderr.write('[DBG] STORE_TCTOKEN token node has no bytes jid=' + jid + '\n');
+            _whaDbg('[DBG] STORE_TCTOKEN token node has no bytes jid=' + jid);
           }
         }
       } catch (e) {
-        process.stderr.write('[DBG] STORE_TCTOKEN parse error: ' + e.message + '\n');
+        _whaDbg('[DBG] STORE_TCTOKEN parse error: ' + e.message);
       }
     }
 
@@ -1505,8 +1612,8 @@ class WhalibmobClient extends EventEmitter {
     if (saveSenderTs && issueTs != null) {
       try {
         this._tcTokenStore.setSenderTimestamp(fallbackJid, issueTs);
-        process.stderr.write('[DBG] SENDER_TS_SAVED jid=' + fallbackJid + ' ts=' + issueTs +
-          ' tokenBytes=' + tokenStoredCount + '\n');
+        _whaDbg('[DBG] SENDER_TS_SAVED jid=' + fallbackJid + ' ts=' + issueTs +
+          ' tokenBytes=' + tokenStoredCount);
       } catch (_) {}
     }
   }
@@ -1533,14 +1640,14 @@ class WhalibmobClient extends EventEmitter {
     const { normalizeJidForTcToken } = require('./messages/TcTokenStore');
 
     const attrs = node.attrs || {};
-    process.stderr.write('[DBG] PRIVACY_TOKEN_NOTIF_ENTER from=' + String(attrs.from || '') +
-      ' sender_lid=' + String(attrs.sender_lid || '') + '\n');
+    _whaDbg('[DBG] PRIVACY_TOKEN_NOTIF_ENTER from=' + String(attrs.from || '') +
+      ' sender_lid=' + String(attrs.sender_lid || ''));
 
     // ── 1. Require <tokens> wrapper (matches Baileys' getBinaryNodeChild check) ──
     const content    = Array.isArray(node.content) ? node.content : [];
     const tokensNode = content.find(n => n && n.description === 'tokens');
     if (!tokensNode) {
-      process.stderr.write('[DBG] PRIVACY_TOKEN_NOTIF no <tokens> wrapper — abort\n');
+      _whaDbg('[DBG] PRIVACY_TOKEN_NOTIF no <tokens> wrapper — abort\n');
       return;
     }
 
@@ -1569,7 +1676,7 @@ class WhalibmobClient extends EventEmitter {
       storageJid = normalizeJidForTcToken(rawFrom);
     }
 
-    process.stderr.write('[DBG] PRIVACY_TOKEN_NOTIF storageJid=' + storageJid + '\n');
+    _whaDbg('[DBG] PRIVACY_TOKEN_NOTIF storageJid=' + storageJid);
 
     // ── 3. Parse <token> children and store bytes (no senderTimestamp update) ──
     // Reuse _storeTcTokenFromIqResult with the full notification node so that its
@@ -1606,15 +1713,15 @@ class WhalibmobClient extends EventEmitter {
           return;
         }
 
-        process.stderr.write('[DBG] REISSUE_TC_TOKEN_AFTER_IDENTITY_CHANGE jid=' + tcJid +
-          ' prevSenderTs=' + senderTs + '\n');
+        _whaDbg('[DBG] REISSUE_TC_TOKEN_AFTER_IDENTITY_CHANGE jid=' + tcJid +
+          ' prevSenderTs=' + senderTs);
 
         const issueTs = Math.floor(Date.now() / 1000);
         const result  = await this._issuePrivacyTokens(tcJid, issueTs);
         this._storeTcTokenFromIqResult(result, tcJid, issueTs);
       } catch (e) {
-        process.stderr.write('[DBG] REISSUE_TC_TOKEN_ERR from=' + from +
-          ' err=' + (e && e.message) + '\n');
+        _whaDbg('[DBG] REISSUE_TC_TOKEN_ERR from=' + from +
+          ' err=' + (e && e.message));
       }
     })();
   }