whalibmob 5.5.30 → 5.5.31

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');
@@ -136,6 +138,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 +184,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 +195,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 +213,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;
   }
@@ -293,11 +299,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 +337,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 +397,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 +415,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 +442,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 +476,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 +505,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 +577,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 +655,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 +668,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 +679,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 +689,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 +702,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 +808,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 +816,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 +824,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 +839,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 +909,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 +930,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 +952,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 +975,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));
   }
 
@@ -1114,7 +1137,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 +1169,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 +1186,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 +1436,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 +1460,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 +1509,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 +1528,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 +1556,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 +1592,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 +1629,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));
       }
     })();
   }

package/lib/DeviceManager.js

@@ -1,7 +1,11 @@
 'use strict';
 
+const { dbg: _whaDbg } = require('./logger');
+
 const { BinaryNode }  = require('./BinaryNode');
 const { NodeCache }   = require('@cacheable/node-cache');
+const fs   = require('fs');
+const path = require('path');
 
 const DEVICE_CACHE_TTL = '5m';
 
@@ -141,6 +145,13 @@ class DeviceManager {
     // own device list cache + expiry timestamp (refreshed every 5 min)
     this._ownDeviceJids   = null;
     this._ownDeviceExpiry = 0;
+    // ─── Disk persistence ─────────────────────────────────────────────
+    this._cacheSnapshot = {};  // mirrors _deviceCache for serialisation
+    this._sessionDir    = null;
+    this._phone         = null;
+    this._cacheFile     = null;
+    this._lidMapFile    = null;
+    this._diskSaveTimer = null;
   }
 
   // ─── NodeCache helper methods ─────────────────────────────────────────────
@@ -149,24 +160,137 @@ class DeviceManager {
 
   _dcHas(key)       { return this._deviceCache.has(key); }
   _dcGet(key)       { return this._deviceCache.get(key) || null; }   // number[] | null
-  _dcSet(key, arr)  { this._deviceCache.set(key, arr); }
+  _dcSet(key, arr)  { this._deviceCache.set(key, arr); this._cacheSnapshot[key] = arr; }
   _dcAdd(key, id) {
     const arr = this._deviceCache.get(key) || [];
     if (!arr.includes(id)) arr.push(id);
     this._deviceCache.set(key, arr);
+    this._cacheSnapshot[key] = arr;
   }
   _dcEnsure(key) {
-    if (!this._deviceCache.has(key)) this._deviceCache.set(key, []);
+    if (!this._deviceCache.has(key)) {
+      this._deviceCache.set(key, []);
+      this._cacheSnapshot[key] = [];
+    }
   }
   _dcDel(keys) {
-    for (const k of keys) this._deviceCache.del(k);
+    for (const k of keys) { this._deviceCache.del(k); delete this._cacheSnapshot[k]; }
   }
   _dcFlush() {
     this._deviceCache.flushAll();
+    this._cacheSnapshot   = {};
     this._ownDeviceJids   = null;
     this._ownDeviceExpiry = 0;
   }
 
+
+  // ─── Session-dir attachment & disk persistence ─────────────────────────────
+  //
+  // Call attachSession(sessionDir, phone) right after DeviceManager construction.
+  // It loads the on-disk device cache so the very first send after a process
+  // restart is instant — no cold-start usync round-trip needed.
+  //
+  // Files saved in session dir (baileys-compatible naming):
+  //   <phone>.device-cache.json                          ← combined cache (internal)
+  //   device-list-447911234567@s.whatsapp.net.json       ← per-phone device IDs
+  //   device-list-139471160877194@lid.json               ← per-LID device IDs
+  //   <phone>.lid-mapping.json                           ← phone ↔ LID mappings
+  //   <phone>.lid-reverse-mapping.json                   ← LID → phone mappings
+  //
+  // Cache validity: only restored if saved < 5 min ago (matches NodeCache TTL).
+  // After 5 min the TTL fires in-memory AND the next usync rewrites the files.
+
+  attachSession(sessionDir, phone) {
+    this._sessionDir = sessionDir;
+    this._phone      = String(phone);
+    this._cacheFile  = path.join(sessionDir, this._phone + '.device-cache.json');
+    this._lidMapFile = path.join(sessionDir, this._phone + '.lid-mapping.json');
+    this._loadFromDisk();
+  }
+
+  _loadFromDisk() {
+    if (!this._cacheFile) return;
+    try {
+      if (fs.existsSync(this._cacheFile)) {
+        const raw  = fs.readFileSync(this._cacheFile, 'utf8');
+        const data = JSON.parse(raw);
+        const age  = Date.now() - (data.saved || 0);
+        if (data.entries && age < 5 * 60 * 1000) {
+          for (const [key, ids] of Object.entries(data.entries)) {
+            if (Array.isArray(ids)) {
+              this._deviceCache.set(key, ids);
+              this._cacheSnapshot[key] = ids;
+            }
+          }
+          _whaDbg('[DBG] DEVICE_CACHE_LOADED entries=' + Object.keys(data.entries).length + ' age=' + Math.round(age / 1000) + 's');
+        } else if (data.entries) {
+          _whaDbg('[DBG] DEVICE_CACHE_STALE age=' + Math.round(age / 1000) + 's — usync will re-query');
+        }
+      }
+    } catch (e) {
+      _whaDbg('[DBG] DEVICE_CACHE_LOAD_ERR ' + e.message);
+    }
+  }
+
+  // Debounced save (300 ms) so rapid usync responses don't cause I/O storms
+  _scheduleSave() {
+    if (!this._cacheFile) return;
+    if (this._diskSaveTimer) clearTimeout(this._diskSaveTimer);
+    this._diskSaveTimer = setTimeout(() => {
+      this._diskSaveTimer = null;
+      this._saveToDisk();
+    }, 300);
+  }
+
+  _saveToDisk() {
+    if (!this._sessionDir || !this._cacheFile) return;
+    try {
+      const entries = Object.assign({}, this._cacheSnapshot);
+
+      // ── Combined cache file ─────────────────────────────────────────────────
+      fs.writeFileSync(
+        this._cacheFile,
+        JSON.stringify({ saved: Date.now(), ttl: 300000, entries }, null, 2),
+        'utf8'
+      );
+
+      // ── Individual device-list files (baileys-compatible) ──────────────────
+      for (const [key, ids] of Object.entries(entries)) {
+        let fileName;
+        if (key.startsWith('lid:')) {
+          fileName = 'device-list-' + key.slice(4) + '@lid.json';
+        } else {
+          fileName = 'device-list-' + key + '@s.whatsapp.net.json';
+        }
+        try {
+          fs.writeFileSync(path.join(this._sessionDir, fileName), JSON.stringify(ids), 'utf8');
+        } catch (_) {}
+      }
+
+      // ── LID mapping files ────────────────────────────────────────────────────
+      if (this._client._pnToLid && this._client._lidToPn) {
+        const pnToLid = {};
+        const lidToPn = {};
+        for (const [pn, lid] of this._client._pnToLid)  { pnToLid[pn]  = lid; }
+        for (const [lid, pn] of this._client._lidToPn)  { lidToPn[lid] = pn; }
+        fs.writeFileSync(
+          this._lidMapFile,
+          JSON.stringify({ pnToLid, lidToPn }, null, 2),
+          'utf8'
+        );
+        fs.writeFileSync(
+          path.join(this._sessionDir, this._phone + '.lid-reverse-mapping.json'),
+          JSON.stringify(lidToPn, null, 2),
+          'utf8'
+        );
+      }
+
+      _whaDbg('[DBG] DEVICE_CACHE_SAVED entries=' + Object.keys(entries).length);
+    } catch (e) {
+      _whaDbg('[DBG] DEVICE_CACHE_SAVE_ERR ' + e.message);
+    }
+  }
+
   // ─── Fetch pre-key bundles for a list of JIDs via encrypt IQ ───────────────
   // Only called for JIDs where no Signal session exists yet.
   // Returns Map<string_jid, bundle> — keys are always normalised strings.
@@ -203,20 +327,20 @@ class DeviceManager {
       [new BinaryNode('key', {}, userNodes)]
     );
 
-    process.stderr.write('[DBG] FETCH_BUNDLES jids=[' + jids.join(',') + ']\n');
+    _whaDbg('[DBG] FETCH_BUNDLES jids=[' + jids.join(',') + ']\n');
 
     const response = await this._client._sendIq(iqNode);
     const bundles  = new Map();
     if (!response) {
-      process.stderr.write('[DBG] FETCH_BUNDLES_NULL\n');
+      _whaDbg('[DBG] FETCH_BUNDLES_NULL\n');
       return bundles;
     }
 
     const listNode = findChild(response, 'list');
     const children = listNode ? listNode.content : (response.content || []);
 
-    process.stderr.write('[DBG] FETCH_BUNDLES_RESP childCount=' +
-      (Array.isArray(children) ? children.length : 0) + '\n');
+    _whaDbg('[DBG] FETCH_BUNDLES_RESP childCount=' +
+      (Array.isArray(children) ? children.length : 0));
 
     for (const userNode of (Array.isArray(children) ? children : [])) {
       if (!userNode || userNode.description !== 'user') continue;
@@ -224,15 +348,15 @@ class DeviceManager {
       if (!jidRaw) continue;
       // Always normalise to a string key so Map lookups are consistent
       const jidStr = String(jidRaw);
-      process.stderr.write('[DBG] FETCH_BUNDLES_USER jid=' + jidStr +
+      _whaDbg('[DBG] FETCH_BUNDLES_USER jid=' + jidStr +
         ' childTags=' + (Array.isArray(userNode.content)
           ? userNode.content.map(c => c && c.description).filter(Boolean).join(',')
-          : '') + '\n');
+          : ''));
       const bundle = parseBundleFromUserNode(userNode);
       if (bundle) bundles.set(jidStr, bundle);
-      else process.stderr.write('[DBG] FETCH_BUNDLES_NO_BUNDLE jid=' + jidStr + '\n');
+      else _whaDbg('[DBG] FETCH_BUNDLES_NO_BUNDLE jid=' + jidStr);
     }
-    process.stderr.write('[DBG] FETCH_BUNDLES_DONE count=' + bundles.size + '\n');
+    _whaDbg('[DBG] FETCH_BUNDLES_DONE count=' + bundles.size);
     return bundles;
   }
 
@@ -332,10 +456,10 @@ class DeviceManager {
       )]
     );
 
-    process.stderr.write('[DBG] USYNC_IQ phones=[' + phones.join(',') + ']\n');
+    _whaDbg('[DBG] USYNC_IQ phones=[' + phones.join(',') + ']\n');
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      process.stderr.write('[DBG] USYNC_ERR ' + (err && err.message) + '\n');
+      _whaDbg('[DBG] USYNC_ERR ' + (err && err.message));
       return null;
     });
 
@@ -383,7 +507,7 @@ class DeviceManager {
             } else {
               cachePhone = rawUser; // last resort: use LID user as key
             }
-            process.stderr.write('[DBG] USYNC_LID_USER userJid=' + userJid + ' → cachePhone=' + cachePhone + '\n');
+            _whaDbg('[DBG] USYNC_LID_USER userJid=' + userJid + ' → cachePhone=' + cachePhone);
           } else {
             // Normal account: user JID is phone@s.whatsapp.net
             cachePhone = rawUser;
@@ -394,7 +518,7 @@ class DeviceManager {
               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);
-              process.stderr.write('[DBG] USYNC_LID_MAP phone=' + cachePhone + ' ↔ lid=' + lidUser + '\n');
+              _whaDbg('[DBG] USYNC_LID_MAP phone=' + cachePhone + ' ↔ lid=' + lidUser);
             }
           }
 
@@ -413,19 +537,19 @@ class DeviceManager {
                 : 0;
               this._dcAdd(cachePhone, devId);
             }
-            process.stderr.write('[DBG] USYNC_DEVICES phone=' + cachePhone +
+            _whaDbg('[DBG] USYNC_DEVICES phone=' + cachePhone +
               ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']\n');
           } else {
             // No device-list in response — fall back to device 0
             this._dcAdd(cachePhone, 0);
-            process.stderr.write('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
+            _whaDbg('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
           }
         }
       } else {
-        process.stderr.write('[DBG] USYNC_RESP_NO_LIST\n');
+        _whaDbg('[DBG] USYNC_RESP_NO_LIST\n');
       }
     } else {
-      process.stderr.write('[DBG] USYNC_NULL_RESP\n');
+      _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
@@ -437,9 +561,10 @@ class DeviceManager {
     for (const p of phones) {
       if (!this._dcHas(p)) {
         this._dcSet(p, [0]);
-        process.stderr.write('[DBG] USYNC_FALLBACK phone=' + p + '\n');
+        _whaDbg('[DBG] USYNC_FALLBACK phone=' + p);
       }
     }
+    this._scheduleSave();
   }
 
   // ─── Ensure sessions exist for all devices of a set of recipients ──────────
@@ -508,10 +633,10 @@ class DeviceManager {
     // desktop, web) are silently ignored and only device 0 (primary phone) is used.
     if (skipUsync) {
       if (!this._dcHas(cacheKey)) {
-        process.stderr.write('[DBG] LID_SKIP_USYNC_CACHE_MISS lidUser=' + lidUser + ' → real usync\n');
+        _whaDbg('[DBG] LID_SKIP_USYNC_CACHE_MISS lidUser=' + lidUser + ' → real usync\n');
         await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
       } else {
-        process.stderr.write('[DBG] LID_SKIP_USYNC_HIT lidUser=' + lidUser + ' → cache\n');
+        _whaDbg('[DBG] LID_SKIP_USYNC_HIT lidUser=' + lidUser + ' → cache\n');
       }
     } else if (!this._dcHas(cacheKey)) {
       await this._doUsyncIqByJid(lidJid, cacheKey, lidUser);
@@ -520,7 +645,7 @@ class DeviceManager {
     const deviceIds  = this._dcGet(cacheKey) || [0];
     const deviceJids = deviceIds.map(d => makeDeviceJid(lidUser, d, 'lid'));
 
-    process.stderr.write('[DBG] LID_DEVICES lidUser=' + lidUser +
+    _whaDbg('[DBG] LID_DEVICES lidUser=' + lidUser +
       ' deviceJids=[' + deviceJids.join(',') + ']\n');
 
     // Split: existing sessions (ready) vs new (need bundle fetch)
@@ -540,9 +665,9 @@ class DeviceManager {
         try {
           await signalProto.buildSessionFromBundle(jid, bundle);
           readyJids.push(jid);
-          process.stderr.write('[DBG] LID_SESSION_BUILT jid=' + jid + '\n');
+          _whaDbg('[DBG] LID_SESSION_BUILT jid=' + jid);
         } catch (e) {
-          process.stderr.write('[DBG] LID_SESSION_ERR jid=' + jid + ' err=' + e.message + '\n');
+          _whaDbg('[DBG] LID_SESSION_ERR jid=' + jid + ' err=' + e.message);
         }
       }
     }
@@ -584,15 +709,15 @@ class DeviceManager {
       )]
     );
 
-    process.stderr.write('[DBG] CONTACT_USYNC phones=[' + phones.join(',') + ']\n');
+    _whaDbg('[DBG] CONTACT_USYNC phones=[' + phones.join(',') + ']\n');
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      process.stderr.write('[DBG] CONTACT_USYNC_ERR ' + (err && err.message) + '\n');
+      _whaDbg('[DBG] CONTACT_USYNC_ERR ' + (err && err.message));
       return null;
     });
 
     if (!response) {
-      process.stderr.write('[DBG] CONTACT_USYNC_NULL\n');
+      _whaDbg('[DBG] CONTACT_USYNC_NULL\n');
       return;
     }
 
@@ -600,7 +725,7 @@ class DeviceManager {
     const listNode  = usyncNode ? findChild(usyncNode, 'list') : findChild(response, 'list');
 
     if (!listNode || !Array.isArray(listNode.content)) {
-      process.stderr.write('[DBG] CONTACT_USYNC_NO_LIST\n');
+      _whaDbg('[DBG] CONTACT_USYNC_NO_LIST\n');
       return;
     }
 
@@ -620,7 +745,7 @@ class DeviceManager {
         // unambiguous; for multi-phone queries match by index.
         const phone = phones.length === 1 ? phones[0] : phones[i];
         if (phone) {
-          process.stderr.write('[DBG] CONTACT_USYNC_LID phone=' + phone + ' → lid=' + lidUser + '\n');
+          _whaDbg('[DBG] CONTACT_USYNC_LID phone=' + phone + ' → lid=' + lidUser);
           if (this._client._pnToLid) this._client._pnToLid.set(phone, lidUser);
           if (this._client._lidToPn) this._client._lidToPn.set(lidUser, phone);
           // Persist the mapping so future sessions don't need to re-query
@@ -631,9 +756,10 @@ class DeviceManager {
         // PN account — note it (still on phone-based routing, no LID needed)
         const { user: pnUser } = stripUser(actualJidStr);
         const phone = phones.length === 1 ? phones[0] : phones[i];
-        process.stderr.write('[DBG] CONTACT_USYNC_PN phone=' + phone + ' jid=' + actualJidStr + '\n');
+        _whaDbg('[DBG] CONTACT_USYNC_PN phone=' + phone + ' jid=' + actualJidStr);
       }
     }
+    this._scheduleSave();
   }
 
   // ─── usync IQ for a specific JID (LID or phone-based) ─────────────────────
@@ -658,10 +784,10 @@ class DeviceManager {
       )]
     );
 
-    process.stderr.write('[DBG] USYNC_LID_IQ jid=' + jid + '\n');
+    _whaDbg('[DBG] USYNC_LID_IQ jid=' + jid);
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      process.stderr.write('[DBG] USYNC_LID_IQ_ERR ' + (err && err.message) + '\n');
+      _whaDbg('[DBG] USYNC_LID_IQ_ERR ' + (err && err.message));
       return null;
     });
 
@@ -685,21 +811,22 @@ class DeviceManager {
                 ? parseInt(String(devNode.attrs.id), 10) : 0;
               this._dcAdd(cacheKey, devId);
             }
-            process.stderr.write('[DBG] USYNC_LID_DEVICES jid=' + jid +
+            _whaDbg('[DBG] USYNC_LID_DEVICES jid=' + jid +
               ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']\n');
           } else {
             this._dcAdd(cacheKey, 0);
-            process.stderr.write('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
+            _whaDbg('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
           }
         }
       } else {
-        process.stderr.write('[DBG] USYNC_LID_NO_LIST jid=' + jid + '\n');
+        _whaDbg('[DBG] USYNC_LID_NO_LIST jid=' + jid);
         this._dcAdd(cacheKey, 0);
       }
     } else {
-      process.stderr.write('[DBG] USYNC_LID_NULL_RESP jid=' + jid + '\n');
+      _whaDbg('[DBG] USYNC_LID_NULL_RESP jid=' + jid);
       this._dcAdd(cacheKey, 0);
     }
+    this._scheduleSave();
   }
 
   // ─── Ensure sessions for own linked devices (device != 0) ─────────────────

package/lib/Registration.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { dbg: _whaDbg } = require('./logger');
+
 const crypto = require('crypto');
 const https  = require('https');
 const tls    = require('tls');
@@ -691,7 +693,7 @@ async function requestSmsCode(store, method, opts) {
   // Auto-fallback on no_routes
   if (result && result._noRoutes && !autoFallbackDone) {
     autoFallbackDone = true;
-    process.stderr.write(`[REG] ${method} returned no_routes — auto-trying ${fallbackMethod}\n`);
+    _whaDbg(`[REG] ${method} returned no_routes — auto-trying ${fallbackMethod}`);
     result = await _tryMethod(fallbackMethod);
   }
 

package/lib/Store.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { warn: _whaWarn } = require('./logger');
+
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
@@ -182,7 +184,7 @@ function storeFromJson(obj) {
 function saveStore(store, filePath) {
   // MAIN FIX: avoid crashing when called with undefined/null store
   if (!store) {
-    console.warn('saveStore: called with empty store, skipping write for', filePath);
+    _whaWarn('saveStore: called with empty store, skipping write for ' + filePath);
     return;
   }
 

package/lib/logger.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const _noop = {
+  trace: () => {},
+  debug: () => {},
+  info:  () => {},
+  warn:  () => {},
+  error: () => {}
+};
+
+let _logger = _noop;
+
+function configureLogger(opts) {
+  if (!opts || opts === false) {
+    _logger = _noop;
+    return;
+  }
+  try {
+    const pino = require('pino');
+    const pinoOpts = (opts === true) ? { level: 'debug' } : opts;
+    _logger = pino(pinoOpts);
+  } catch (_) {
+    _logger = _noop;
+  }
+}
+
+function getLogger() {
+  return _logger;
+}
+
+function dbg(msg)  { _logger.debug(msg); }
+function warn(msg) { _logger.warn(msg); }
+function err(msg)  { _logger.error(msg); }
+function info(msg) { _logger.info(msg); }
+
+module.exports = { configureLogger, getLogger, dbg, warn, err, info };

package/lib/messages/MessageSender.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { dbg: _whaDbg } = require('../logger');
+
 const crypto         = require('crypto');
 const { Mutex }      = require('async-mutex');
 const path     = require('path');
@@ -129,10 +131,10 @@ function _buildOrGetAdvIdentity(store) {
 
     const adv     = _encodeADVSignedIdentity(details, pub32, acctSig, devSig);
     store.advIdentity = adv;
-    process.stderr.write('[DBG] ADV_BUILT from primary iOS keys (' + adv.length + 'b)\n');
+    _whaDbg('[DBG] ADV_BUILT from primary iOS keys (' + adv.length + 'b)\n');
     return adv;
   } catch (e) {
-    process.stderr.write('[DBG] ADV_BUILD_ERR: ' + e.message + '\n');
+    _whaDbg('[DBG] ADV_BUILD_ERR: ' + e.message);
     return null;
   }
 }
@@ -581,8 +583,8 @@ class MessageSender {
     const lidUser      = this._client._pnToLid && this._client._pnToLid.get(recipientPhone);
     const routingToJid = lidUser ? `${lidUser}@lid` : toJid;
 
-    process.stderr.write('[DBG] DM_ROUTE phone=' + recipientPhone +
-      ' routing=' + routingToJid + (lidUser ? ' (LID)' : ' (PN)') + '\n');
+    _whaDbg('[DBG] DM_ROUTE phone=' + recipientPhone +
+      ' routing=' + routingToJid + (lidUser ? ' (LID)' : ' (PN)'));
 
     let otherJids;
     if (lidUser) {
@@ -652,11 +654,11 @@ class MessageSender {
       if (tcEntry && tcEntry.token && tcEntry.token.length) {
         if (!tcTokenExpired(tcEntry.timestamp)) {
           msgContent.push(new BinaryNode('tctoken', {}, tcEntry.token));
-          process.stderr.write('[DBG] TCTOKEN_ATTACH jid=' + tcJid + '\n');
+          _whaDbg('[DBG] TCTOKEN_ATTACH jid=' + tcJid);
         } else {
           // Expired token — clear it, keep senderTimestamp for dedupe
           tcStore.clearToken(tcJid);
-          process.stderr.write('[DBG] TCTOKEN_EXPIRED jid=' + tcJid + ' — cleared\n');
+          _whaDbg('[DBG] TCTOKEN_EXPIRED jid=' + tcJid + ' — cleared\n');
         }
       }
     }
@@ -665,16 +667,15 @@ class MessageSender {
     const msgNode = new BinaryNode('message', stanzaAttrs, msgContent);
 
     // Debug: log outgoing stanza details
-    process.stderr.write('[DBG] DM_SEND to=' + toJid +
+    _whaDbg('[DBG] DM_SEND to=' + toJid +
       ' otherJids=[' + otherJids.join(',') + ']' +
       ' ownLinked=[' + ownLinkedJids.join(',') + ']' +
       ' encrypted=' + encryptedList.length +
       ' hasPkmsg=' + hasPkmsg +
-      ' hasAdv=' + !!(advBytes) +
-      '\n');
+      ' hasAdv=' + !!(advBytes));
     if (encryptedList.length > 0) {
-      process.stderr.write('[DBG] DM_PARTICIPANTS ' +
-        encryptedList.map(e => e.jid + '(' + e.type + ')').join(', ') + '\n');
+      _whaDbg('[DBG] DM_PARTICIPANTS ' +
+        encryptedList.map(e => e.jid + '(' + e.type + ')').join(', '));
     }
 
     // Cache plaintext so Client can re-send with fresh session on recipient retry
@@ -722,7 +723,7 @@ class MessageSender {
     let members = this._client._getGroupMembers(groupJid);
     if (members.length === 0 && typeof this._client.getGroupMetadata === 'function') {
       try {
-        process.stderr.write('[DBG] GROUP_SEND auto-fetch metadata for ' + groupJid + '\n');
+        _whaDbg('[DBG] GROUP_SEND auto-fetch metadata for ' + groupJid);
         await this._client.getGroupMetadata(groupJid);
         members = this._client._getGroupMembers(groupJid);
       } catch (_) {}
@@ -745,7 +746,7 @@ class MessageSender {
         if (isLid) {
           const pn = this._client._lidToPn && this._client._lidToPn.get(raw);
           if (!pn) {
-            process.stderr.write('[DBG] GROUP_SEND skip LID member with no PN mapping: ' + jid + '\n');
+            _whaDbg('[DBG] GROUP_SEND skip LID member with no PN mapping: ' + jid);
             return null;
           }
           return pn;
@@ -859,16 +860,14 @@ class MessageSender {
             const tcJid   = normalizeJidForTcToken(
               ackFrom || String(node.attrs && node.attrs.to || '')
             );
-            process.stderr.write(
-              '[DBG] ACK_463 from=' + ackFrom + ' id=' + id +
-              ' tcJid=' + tcJid + ' — issuing tctoken then retrying\n'
-            );
+            _whaDbg('[DBG] ACK_463 from=' + ackFrom + ' id=' + id +
+              ' tcJid=' + tcJid + ' — issuing tctoken then retrying\n');
 
             if (client._inFlight463Recoveries.has(tcJid)) {
               // Another concurrent recovery in progress for this JID —
               // wait ~3 s for it to finish then retry with whatever token
               // is now stored (may or may not succeed).
-              process.stderr.write('[DBG] ACK_463 already in-flight for ' + tcJid + ' — retrying after delay\n');
+              _whaDbg('[DBG] ACK_463 already in-flight for ' + tcJid + ' — retrying after delay\n');
               setTimeout(() => {
                 const retryId   = crypto.randomBytes(8).toString('hex').toUpperCase();
                 const retryNode = new BinaryNode(
@@ -897,16 +896,14 @@ class MessageSender {
                 const entry   = tcStore && tcStore.get(tcJid);
                 const hasToken = entry && entry.token && entry.token.length > 0;
                 if (!hasToken) {
-                  process.stderr.write(
-                    '[DBG] ACK_463 IQ timeout or server refused — no token bytes stored for ' +
-                    tcJid + ', giving up (account may be restricted)\n'
-                  );
+                  _whaDbg('[DBG] ACK_463 IQ timeout or server refused — no token bytes stored for ' +
+                    tcJid + ', giving up (account may be restricted)\n');
                   throw new Error(
                     'Send error 463: server did not issue a tctoken for ' + tcJid +
                     ' (IQ timeout or account restricted)'
                   );
                 }
-                process.stderr.write('[DBG] ACK_463 token stored for ' + tcJid + ' — retrying send\n');
+                _whaDbg('[DBG] ACK_463 token stored for ' + tcJid + ' — retrying send\n');
                 const retryId   = crypto.randomBytes(8).toString('hex').toUpperCase();
                 const retryNode = new BinaryNode(
                   node.description,
@@ -917,7 +914,7 @@ class MessageSender {
               })
               .then(r => resolve(r))
               .catch(err => {
-                process.stderr.write('[DBG] ACK_463 recovery failed: ' + (err && err.message) + '\n');
+                _whaDbg('[DBG] ACK_463 recovery failed: ' + (err && err.message));
                 reject(new Error('Send error 463: tctoken recovery failed — ' + (err && err.message)));
               })
               .finally(() => client._inFlight463Recoveries.delete(tcJid));

package/lib/noise.js

@@ -202,6 +202,8 @@ class NoiseSocket extends EventEmitter {
     this._awaitingAuth = false;  // true after ClientFinish sent, before server <success>/<failure>
     this.rxBuf        = Buffer.alloc(0);
     this._ephemeralKeyPair = null;
+    this._lastRxAt           = Date.now();   // updated on every TCP data received
+    this._connectTimeoutTimer = null;         // cleared once TCP connect fires
   }
 
   connect() {
@@ -210,7 +212,23 @@ class NoiseSocket extends EventEmitter {
       this._connectReject  = reject;
 
       this.socket = net.createConnection({ host: WHATSAPP_HOST, port: WHATSAPP_PORT });
-      this.socket.on('connect', () => this._onTcpConnect());
+      // OS-level TCP keepalive: detects silently-dead NAT connections that never send FIN/RST
+      this.socket.setKeepAlive(true, 15000);
+      // Connect-phase watchdog: abort if TCP handshake takes >20s
+      this._connectTimeoutTimer = setTimeout(() => {
+        if (this._connectReject) {
+          const err = new Error('WA TCP connect timeout (20s)');
+          this._connectReject(err);
+          this._connectResolve = null;
+          this._connectReject  = null;
+        }
+        try { this.socket.destroy(); } catch (_) {}
+      }, 20000);
+      this.socket.on('connect', () => {
+        clearTimeout(this._connectTimeoutTimer);
+        this._connectTimeoutTimer = null;
+        this._onTcpConnect();
+      });
       this.socket.on('data',    (data) => this._onData(data));
       this.socket.on('error',   (err)  => this._onTcpError(err));
       this.socket.on('close',   ()     => this._onTcpClose());
@@ -238,6 +256,7 @@ class NoiseSocket extends EventEmitter {
   }
 
   _onData(data) {
+    this._lastRxAt = Date.now();   // watchdog uses this to detect dead connections
     this.rxBuf = Buffer.concat([this.rxBuf, data]);
     this._processBuffer();
   }
@@ -294,7 +313,7 @@ class NoiseSocket extends EventEmitter {
         shortConnect:       false,
         connectType:        1,
         connectReason:      1,
-        connectAttemptCount: 0,
+        connectAttemptCount: (this.store.connectAttemptCount || 0),
         device:             0,
         oc:                 false,
         userAgent: {
@@ -407,6 +426,8 @@ class NoiseSocket extends EventEmitter {
   }
 
   _onTcpError(err) {
+    clearTimeout(this._connectTimeoutTimer);
+    this._connectTimeoutTimer = null;
     if (this._connectReject) {
       this._connectReject(err);
       this._connectResolve = null;
@@ -416,8 +437,17 @@ class NoiseSocket extends EventEmitter {
   }
 
   _onTcpClose() {
+    clearTimeout(this._connectTimeoutTimer);
+    this._connectTimeoutTimer = null;
     this.connected = false;
     this.secured   = false;
+    // If the TCP connection closed while the WA handshake was still in progress,
+    // the Promise returned by connect() would hang forever — reject it now.
+    if (this._connectReject) {
+      this._connectReject(new Error('WA TCP closed during handshake'));
+      this._connectResolve = null;
+      this._connectReject  = null;
+    }
     this.emit('close');
   }
 

package/lib/signal/SignalProtocol.js

@@ -7,8 +7,8 @@ const { SenderKeyStore, SenderKeyCrypto } = require('./SenderKey');
 
 const { SessionCipher, SessionBuilder, ProtocolAddress, keyhelper } = libsignal;
 
-const PRE_KEY_COUNT   = 100;
-const PRE_KEY_MIN     = 10;
+const PRE_KEY_COUNT   = 800;
+const PRE_KEY_MIN     = 50;
 const PRE_KEY_START   = 1;
 
 // ─── Per-JID async mutex ────────────

package/lib/signal/libsignal/curve.js

@@ -1,3 +1,5 @@
+const { dbg: _whaDbg, warn: _whaWarn, err: _whaErr, info: _whaInfo } = require('../../logger');
+
 
 'use strict';
 
@@ -40,7 +42,7 @@ function scrubPubKeyFormat(pubKey) {
     if (pubKey.byteLength == 33) {
         return pubKey.slice(1);
     } else {
-        console.error("WARNING: Expected pubkey of length 33, please report the ST and client that generated the pubkey");
+        _whaErr('WARNING: Expected pubkey of length 33, please report the ST and client that generated the pubkey');
         return pubKey;
     }
 }

package/lib/signal/libsignal/queue_job.js

@@ -1,3 +1,5 @@
+const { dbg: _whaDbg, warn: _whaWarn, err: _whaErr, info: _whaInfo } = require('../../logger');
+
 // vim: ts=4:sw=4:expandtab
  
  /*
@@ -47,7 +49,7 @@ module.exports = function(bucket, awaitable) {
         if (typeof bucket === 'string') {
             awaitable.name = bucket;
         } else {
-            console.warn("Unhandled bucket type (for naming):", typeof bucket, bucket);
+            _whaWarn('Unhandled bucket type (for naming): ' + typeof bucket);
         }
     }
     let inactive;

package/lib/signal/libsignal/session_builder.js

@@ -1,3 +1,5 @@
+const { dbg: _whaDbg, warn: _whaWarn, err: _whaErr, info: _whaInfo } = require('../../logger');
+
 
 'use strict';
 
@@ -71,7 +73,7 @@ class SessionBuilder {
         }   
         const existingOpenSession = record.getOpenSession();
         if (existingOpenSession) {
-            console.warn("Closing open session in favor of incoming prekey bundle");
+            _whaWarn('Closing open session in favor of incoming prekey bundle');
             record.closeSession(existingOpenSession);
         }
         record.setSession(await this.initSession(false, preKeyPair, signedPreKeyPair,

package/lib/signal/libsignal/session_cipher.js

@@ -1,3 +1,5 @@
+const { dbg: _whaDbg, warn: _whaWarn, err: _whaErr, info: _whaInfo } = require('../../logger');
+
 // vim: ts=4:sw=4:expandtab
 
 const ChainType = require('./chain_type');
@@ -175,7 +177,7 @@ class SessionCipher {
                 // was the most current.  Simply make a note of it and continue.  If our
                 // actual open session is for reason invalid, that must be handled via
                 // a full SessionError response.
-                console.warn("Decrypted message with closed session.");
+                _whaWarn('Decrypted message with closed session.');
             }
             await this.storeRecord(record);
             return result.plaintext;

package/lib/signal/libsignal/session_record.js

@@ -1,3 +1,5 @@
+const { dbg: _whaDbg, warn: _whaWarn, err: _whaErr, info: _whaInfo } = require('../../logger');
+
 // vim: ts=4:sw=4
 
 const BaseKeyType = require('./base_key_type');
@@ -170,9 +172,7 @@ const migrations = [{
         } else {
             for (const key in sessions) {
                 if (sessions[key].indexInfo.closed === -1) {
-                    console.error('V1 session storage migration error: registrationId',
-                                  data.registrationId, 'for open session version',
-                                  data.version);
+                    _whaErr('V1 session storage migration error: registrationId ' + data.registrationId + ' for open session version ' + data.version);
                 }
             }
         }
@@ -190,7 +190,7 @@ class SessionRecord {
         let run = (data.version === undefined);
         for (let i = 0; i < migrations.length; ++i) {
             if (run) {
-                console.info("Migrating session to:", migrations[i].version);
+                _whaInfo('Migrating session to: ' + migrations[i].version);
                 migrations[i].migrate(data);
             } else if (migrations[i].version === data.version) {
                 run = true;
@@ -267,18 +267,18 @@ class SessionRecord {
 
     closeSession(session) {
         if (this.isClosed(session)) {
-            console.warn("Session already closed", session);
+            _whaWarn('Session already closed');
             return;
         }
-        console.info("Closing session:", session);
+        _whaInfo('Closing session');
         session.indexInfo.closed = Date.now();
     }
 
     openSession(session) {
         if (!this.isClosed(session)) {
-            console.warn("Session already open");
+            _whaWarn('Session already open');
         }
-        console.info("Opening session:", session);
+        _whaInfo('Opening session');
         session.indexInfo.closed = -1;
     }
 
@@ -298,7 +298,7 @@ class SessionRecord {
                 }
             }
             if (oldestKey) {
-                console.info("Removing old closed session:", oldestSession);
+                _whaInfo('Removing old closed session');
                 delete this.sessions[oldestKey];
             } else {
                 throw new Error('Corrupt sessions object');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.5.30",
+  "version": "5.5.31",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto20",
   "main": "index.js",
@@ -46,6 +46,7 @@
     "protobufjs": "^6.11.4",
     "uuid": "^11.1.0",
     "async-mutex": "^0.5.0",
-    "@cacheable/node-cache": "^3.0.1"
+    "@cacheable/node-cache": "^3.0.1",
+    "pino": "^9.0.0"
   }
 }