whalibmob 2.0.0

package/lib/Client.js

@@ -0,0 +1,957 @@
+'use strict';
+
+const EventEmitter  = require('events');
+const path          = require('path');
+const crypto        = require('crypto');
+const { NoiseSocket }     = require('./noise');
+const { MessageSender, generateMessageId, makeJid } = require('./messages/MessageSender');
+const { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode } = require('./Registration');
+const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts } = require('./Store');
+const { BinaryNode }      = require('./BinaryNode');
+const { SignalProtocol }  = require('./signal/SignalProtocol');
+const { DeviceManager }   = require('./DeviceManager');
+
+const PING_INTERVAL_MS    = 25000;
+const KEEPALIVE_INTERVAL  = 20000;
+const RECONNECT_BACKOFF   = [1000, 2000, 4000, 8000, 15000, 30000];
+
+// ─── Key helpers ──────────────────────────────────────────────────────────────
+
+function intToBytes(n, byteLen) {
+  const buf = Buffer.alloc(byteLen);
+  for (let i = byteLen - 1; i >= 0; i--) { buf[i] = n & 0xff; n >>= 8; }
+  return buf;
+}
+
+function stripKeyPrefix(key) {
+  if (!key) return Buffer.alloc(32);
+  const buf = Buffer.from(key);
+  if (buf.length === 33 && buf[0] === 0x05) return buf.slice(1);
+  return buf;
+}
+
+function findChild(node, desc) {
+  if (!node || !Array.isArray(node.content)) return null;
+  return node.content.find(c => c && c.description === desc) || null;
+}
+
+function findChildDeep(node, desc) {
+  if (!node) return null;
+  if (node.description === desc) return node;
+  if (!Array.isArray(node.content)) return null;
+  for (const child of node.content) {
+    const found = findChildDeep(child, desc);
+    if (found) return found;
+  }
+  return null;
+}
+
+function getNodeContent(node) {
+  if (!node) return null;
+  if (Buffer.isBuffer(node.content)) return node.content;
+  if (typeof node.content === 'string') return Buffer.from(node.content);
+  return null;
+}
+
+function intFromBuf(buf) {
+  if (!buf) return 0;
+  let v = 0;
+  for (const b of buf) v = (v << 8) | b;
+  return v;
+}
+
+function toSignalKey(raw) {
+  if (!raw) return null;
+  if (raw.length === 33 && raw[0] === 0x05) return Buffer.from(raw);
+  if (raw.length === 32) return Buffer.concat([Buffer.from([0x05]), raw]);
+  return Buffer.from(raw);
+}
+
+// ─── WhalibmobClient ──────────────────────────────────────────────────────────
+
+class WhalibmobClient extends EventEmitter {
+  constructor(opts) {
+    super();
+    opts                = opts || {};
+    this._store         = null;
+    this._socket        = null;
+    this._sender        = null;
+    this._signal        = null;
+    this._devMgr        = null;
+    this._sessionDir    = opts.sessionDir || process.env.HOME + '/.waSession';
+    this._pingTimer     = null;
+    this._keepTimer     = null;
+    this._connected     = false;
+    this._reconnecting  = false;
+    this._reconnectTry  = 0;
+    this._phoneNumber   = null;
+    this._mediaConn     = null;
+    this._pendingIqs       = new Map();   // id → resolve fn
+    this._pendingAcks      = new Map();   // msgId → resolve fn
+    this._groupMembers     = new Map();   // groupJid → Set<memberJid>
+    this._retryPending     = new Map();   // msgId → {node, retryCount}
+    this._appStateVersions = {};          // collectionName → version (int)
+  }
+
+  get store()     { return this._store; }
+  get sender()    { return this._sender; }
+  get connected() { return this._connected; }
+
+  // ─── Registration statics ─────────────────────────────────────────────────
+
+  static async register(phoneNumber, opts) {
+    return checkIfRegistered(phoneNumber, opts || {});
+  }
+
+  static async requestCode(phoneNumber, method, opts) {
+    return requestSmsCode(phoneNumber, method || 'sms', opts || {});
+  }
+
+  static async confirmCode(phoneNumber, code, opts) {
+    return verifyCode(phoneNumber, code, opts || {});
+  }
+
+  // ─── Connect ──────────────────────────────────────────────────────────────
+
+  async connect(phoneNumber) {
+    return this.init(phoneNumber);
+  }
+
+  async init(phoneNumber) {
+    phoneNumber = String(phoneNumber).replace(/\D/g, '');
+    this._phoneNumber = phoneNumber;
+
+    const sessionFile = path.join(this._sessionDir, `${phoneNumber}.json`);
+    this._store = loadStore(sessionFile);
+    if (!this._store) {
+      throw new Error(`No session for ${phoneNumber}. Run 'wa registration -R <code>' first.`);
+    }
+
+    const signalFile = path.join(this._sessionDir, `${phoneNumber}.signal.json`);
+    const skFile     = path.join(this._sessionDir, `${phoneNumber}.sk.json`);
+
+    this._signal = SignalProtocol.fromStore(this._store, signalFile, skFile);
+    this._devMgr = new DeviceManager(this);
+
+    await this._connectSocket();
+    return this;
+  }
+
+  async _connectSocket() {
+    const socket = new NoiseSocket(this._store);
+    this._socket = socket;
+
+    // Recreate sender with updated socket reference
+    this._sender = new MessageSender(this);
+
+    socket.on('open',  (sn)  => this._onOpen(sn));
+    socket.on('node',  node  => this._onNode(node));
+    socket.on('close', ()    => this._onClose());
+    socket.on('error', err   => this.emit('error', err));
+
+    await socket.connect();
+    return socket;
+  }
+
+  disconnect() {
+    this._reconnecting = false;
+    this._reconnectTry = 0;
+    this._stopTimers();
+    if (this._socket) {
+      try { this._socket.close(); } catch (_) {}
+      this._socket = null;
+    }
+    this._connected = false;
+    this.emit('close');
+  }
+
+  // ─── Reconnection ─────────────────────────────────────────────────────────
+
+  _scheduleReconnect() {
+    if (this._reconnecting) return;
+    this._reconnecting = true;
+    const delay = RECONNECT_BACKOFF[Math.min(this._reconnectTry, RECONNECT_BACKOFF.length - 1)];
+    this._reconnectTry++;
+    this.emit('reconnecting', { delay, attempt: this._reconnectTry });
+
+    setTimeout(async () => {
+      if (!this._reconnecting) return;
+      try {
+        await this._connectSocket();
+        this._reconnecting = false;
+        this._reconnectTry = 0;
+        this.emit('reconnected');
+      } catch (err) {
+        this._reconnecting = false;
+        this._scheduleReconnect();
+      }
+    }, delay);
+  }
+
+  // ─── Connection events ────────────────────────────────────────────────────
+
+  _onOpen(successNode) {
+    this._connected = true;
+    this._startTimers();
+
+    // ── Feature 1: Parse <success> node ──────────────────────────────────────
+    // Extract ADVSignedDeviceIdentity, platform, and other account info that
+    // the server provides on each successful authentication.
+    this._parseSuccessNode(successNode);
+
+    // ── Feature 3 (part A): Send <active> IQ ─────────────────────────────────
+    // WhatsApp opens sessions as "passive" — the client must explicitly
+    // activate the connection before the server will deliver messages.
+    this._sendActiveIq();
+
+    this._requestMediaConnection();
+    this._uploadPreKeys();
+    this.emit('connected');
+  }
+
+  // ── Feature 1: Parse the <success> node ────────────────────────────────────
+  //
+  // The <success> node from WhatsApp contains:
+  //   attrs.platform  — server-reported client platform
+  //   attrs.lid       — linked-device ID (for multi-device)
+  //   child <device-identity> — raw ADVSignedDeviceIdentity protobuf bytes
+  //
+  // ADVSignedDeviceIdentity fields (all bytes / wire type 2):
+  //   1: details             — ADVDeviceIdentityDetails proto
+  //   2: accountSignatureKey — 32-byte public key (we strip this when sending)
+  //   3: accountSignature    — 64-byte Ed25519 signature
+  //   4: deviceSignature     — 64-byte Ed25519 signature (empty on primary)
+  //
+  // We persist the bytes so device_identity nodes can be attached to pkmsg
+  // stanzas on every subsequent send — even after a reconnect.
+  _parseSuccessNode(node) {
+    if (!node) return;
+    const attrs = node.attrs || {};
+    if (attrs.platform) this._platform = attrs.platform;
+
+    const devIdNode = findChild(node, 'device-identity');
+    if (devIdNode) {
+      const bytes = getNodeContent(devIdNode);
+      if (bytes && bytes.length > 0) {
+        this._store.advIdentity = bytes;
+        // Persist to session file so it survives restart
+        const sessionFile = path.join(
+          this._sessionDir,
+          `${this._store.phoneNumber}.json`
+        );
+        try {
+          const { saveStore } = require('./Store');
+          saveStore(this._store, sessionFile);
+        } catch (_) {}
+      }
+    } else if (this._store.advIdentity) {
+      // Already have it persisted from a previous session — keep using it
+    }
+  }
+
+  // ── Feature 3 (part A): Activate the connection ────────────────────────────
+  //
+  // WhatsApp starts every Noise session in "passive" mode.  The client must
+  // send this IQ to become "active" so the server starts delivering messages.
+  _sendActiveIq() {
+    if (!this._socket) return;
+    const id = this._genMsgId();
+    this._socket.sendNode(new BinaryNode('iq', {
+      id,
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'passive'
+    }, [new BinaryNode('active', {}, null)]));
+  }
+
+  // ── Feature 3 (part B): Handle <ib> dirty-state notifications ──────────────
+  //
+  // After login the server sends <ib><dirty type="account_sync"…/></ib> to
+  // tell the client that its app state is stale.  We respond with a sync IQ
+  // for each dirty collection.  We track the version number for each
+  // collection in _appStateVersions so we don't repeatedly request version 0.
+  _handleIb(node) {
+    const children = Array.isArray(node.content) ? node.content : [];
+
+    const dirtyTypes = [];
+    for (const child of children) {
+      if (!child || child.description !== 'dirty') continue;
+      const type = child.attrs && child.attrs.type;
+      if (type) dirtyTypes.push(type);
+    }
+
+    if (dirtyTypes.length > 0) {
+      this._sendAppStateSyncForTypes(dirtyTypes);
+    }
+
+    this.emit('ib', { node });
+  }
+
+  // ── Feature 3 (part C): Send an app-state-sync IQ ──────────────────────────
+  //
+  // Maps WhatsApp dirty-type names → the actual collection names used in the
+  // sync IQ.  We use return_snapshot=true on the first request (version 0) so
+  // the server sends a full snapshot; subsequent requests use the stored
+  // version and return_snapshot=false (incremental patches only).
+  //
+  // 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.
+  _sendAppStateSyncForTypes(dirtyTypes) {
+    if (!this._socket || !this._connected) return;
+
+    const COLLECTION_MAP = {
+      account_sync:        ['critical_block', 'critical_unblock_low', 'regular_low', 'regular_high', 'regular'],
+      critical_block:      ['critical_block'],
+      critical_unblock_low:['critical_unblock_low'],
+      regular_low:         ['regular_low'],
+      regular_high:        ['regular_high'],
+      regular:             ['regular']
+    };
+
+    const collections = new Set();
+    for (const type of dirtyTypes) {
+      const mapped = COLLECTION_MAP[type] || [type];
+      for (const c of mapped) collections.add(c);
+    }
+
+    const id = this._genMsgId();
+    const collectionNodes = [...collections].map(name => {
+      const version = String(this._appStateVersions[name] || 0);
+      return new BinaryNode('collection', {
+        name,
+        version,
+        return_snapshot: version === '0' ? 'true' : 'false'
+      }, null);
+    });
+
+    this._socket.sendNode(new BinaryNode('iq', {
+      id,
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'w:sync:app:state'
+    }, [new BinaryNode('sync', {}, collectionNodes)]));
+
+    // When the server replies, update our version numbers so future syncs
+    // request incremental patches rather than a full snapshot.
+    this._pendingIqs.set(id, (resp) => {
+      if (!resp || !Array.isArray(resp.content)) return;
+      const syncNode = findChild(resp, 'sync');
+      if (!syncNode || !Array.isArray(syncNode.content)) return;
+      for (const colNode of syncNode.content) {
+        if (!colNode || colNode.description !== 'collection') continue;
+        const colAttrs = colNode.attrs || {};
+        if (colAttrs.name && colAttrs.version !== undefined) {
+          this._appStateVersions[colAttrs.name] = parseInt(colAttrs.version, 10) || 0;
+        }
+      }
+    });
+  }
+
+  _onClose() {
+    this._connected = false;
+    this._stopTimers();
+    this.emit('disconnected');
+
+    // Reject all pending IQs / acks
+    for (const [, resolve] of this._pendingIqs) {
+      resolve(null);
+    }
+    this._pendingIqs.clear();
+
+    for (const [, resolve] of this._pendingAcks) {
+      resolve({ error: 'disconnected' });
+    }
+    this._pendingAcks.clear();
+
+    this._scheduleReconnect();
+  }
+
+  // ─── Timers ───────────────────────────────────────────────────────────────
+
+  _startTimers() {
+    this._pingTimer = setInterval(() => {
+      if (this._sender && this._connected) this._sender.ping();
+    }, PING_INTERVAL_MS);
+
+    this._keepTimer = setInterval(() => {
+      if (this._socket && this._connected) {
+        this._socket.sendNode(new BinaryNode('iq', {
+          id:    this._genMsgId(),
+          to:    's.whatsapp.net',
+          type:  'get',
+          xmlns: 'w:p'
+        }, [new BinaryNode('ping', {}, null)]));
+      }
+    }, KEEPALIVE_INTERVAL);
+  }
+
+  _stopTimers() {
+    if (this._pingTimer) { clearInterval(this._pingTimer); this._pingTimer = null; }
+    if (this._keepTimer) { clearInterval(this._keepTimer); this._keepTimer = null; }
+  }
+
+  // ─── Node dispatch ────────────────────────────────────────────────────────
+
+  _onNode(node) {
+    if (!node || !node.description) return;
+    const tag = node.description;
+
+    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.emit('stream_error', { reason: node.attrs && node.attrs.reason });
+    else                             this.emit('node', node);
+  }
+
+  // ─── IQ handling ──────────────────────────────────────────────────────────
+
+  _handleIq(node) {
+    const id    = node.attrs && node.attrs.id;
+    const type  = node.attrs && node.attrs.type;
+    const xmlns = node.attrs && node.attrs.xmlns;
+
+    // Resolve pending IQ
+    if (id) {
+      const handler = this._pendingIqs.get(id);
+      if (handler) {
+        this._pendingIqs.delete(id);
+        handler(node);
+        return;
+      }
+    }
+
+    // Media connection result
+    if (type === 'result' && xmlns === 'w:m') {
+      this._onMediaConnectionResult(node);
+    }
+
+    // Pre-key upload ack — could also replenish
+    if (type === 'result' && xmlns === 'encrypt') {
+      this._checkAndReplenishPreKeys();
+    }
+
+    this.emit('iq', { id, type, xmlns, node });
+  }
+
+  // ─── Message handling ─────────────────────────────────────────────────────
+
+  _handleMessage(node) {
+    const attrs = node.attrs || {};
+    const from  = attrs.from  || '';
+    const id    = attrs.id    || '';
+    const ts    = parseInt(attrs.t || '0', 10);
+    const participant = attrs.participant || from;
+
+    // Group: sender is the group JID, participant is the actual sender
+    const isGroup = from.endsWith('@g.us');
+
+    // Find enc node(s) — could be skmsg for groups, or msg/pkmsg for DMs
+    const encNodes = Array.isArray(node.content)
+      ? node.content.filter(c => c && c.description === 'enc')
+      : [];
+
+    // Find participants node (multi-device DMs, or SKDM distribution in groups)
+    const participantsNode = findChild(node, 'participants');
+    const myJid = `${this._store.phoneNumber}@s.whatsapp.net`;
+
+    // For groups: look for skmsg enc node
+    const skmsgNode = encNodes.find(n => n.attrs && n.attrs.type === 'skmsg');
+
+    // For DMs: look for direct enc node or enc in participant targeting us
+    let dmEncNode = encNodes.find(n => n.attrs && (n.attrs.type === 'msg' || n.attrs.type === 'pkmsg'));
+
+    // Multi-device: check participants node for our JID
+    if (!dmEncNode && participantsNode && Array.isArray(participantsNode.content)) {
+      for (const toNode of participantsNode.content) {
+        if (!toNode || toNode.description !== 'to') continue;
+        const toJid = toNode.attrs && toNode.attrs.jid;
+        if (!toJid) continue;
+        // Match our main JID or any of our device JIDs
+        const toPhone = toJid.split('@')[0].split(':')[0];
+        if (toPhone === this._store.phoneNumber) {
+          const enc = findChild(toNode, 'enc');
+          if (enc) {
+            dmEncNode = enc;
+            break;
+          }
+        }
+      }
+    }
+
+    // Process SKDM from participants (group messages)
+    if (isGroup && participantsNode) {
+      this._processSKDMDistribution(from, participant, participantsNode);
+    }
+
+    if (skmsgNode && isGroup) {
+      this._decryptGroupMessage({ node, from, participant, id, ts, skmsgNode });
+      return;
+    }
+
+    if (dmEncNode && this._signal) {
+      this._decryptDMMessage({ node, from, id, ts, dmEncNode });
+      return;
+    }
+
+    // Plain text (no encryption) — rare
+    const bodyNode = findChild(node, 'body');
+    const text = bodyNode ? (
+      Buffer.isBuffer(bodyNode.content)
+        ? bodyNode.content.toString('utf8')
+        : (bodyNode.content || null)
+    ) : null;
+
+    this.emit('message', { id, from, participant, ts, text, node });
+    this._sendReadReceipt(id, from, participant);
+  }
+
+  _decryptDMMessage({ node, from, id, ts, dmEncNode }) {
+    const encType   = dmEncNode.attrs && dmEncNode.attrs.type;
+    const cipherBuf = Buffer.isBuffer(dmEncNode.content)
+      ? dmEncNode.content
+      : Buffer.from(dmEncNode.content || '');
+
+    this._signal.decrypt(from, encType, cipherBuf)
+      .then(plaintext => {
+        this.emit('message', { id, from, participant: from, ts, plaintext, node });
+        this._sendReadReceipt(id, from, from);
+      })
+      .catch(err => {
+        this.emit('decrypt_error', { id, from, err });
+        this._sendRetryRequest(id, from, node);
+      });
+  }
+
+  _decryptGroupMessage({ node, from, participant, id, ts, skmsgNode }) {
+    const cipherBuf = Buffer.isBuffer(skmsgNode.content)
+      ? skmsgNode.content
+      : Buffer.from(skmsgNode.content || '');
+
+    try {
+      const plaintext = this._signal.senderKeyDecrypt(from, participant, cipherBuf);
+      this.emit('message', { id, from, participant, ts, plaintext, isGroup: true, node });
+      this._sendReadReceipt(id, from, participant);
+    } catch (err) {
+      this.emit('decrypt_error', { id, from, participant, err });
+    }
+  }
+
+  // Process SKDM messages in participants node
+  _processSKDMDistribution(groupJid, senderJid, participantsNode) {
+    // For incoming group messages, the SKDM for us is in the participants node
+    if (!Array.isArray(participantsNode.content)) return;
+    for (const toNode of participantsNode.content) {
+      if (!toNode || toNode.description !== 'to') continue;
+      const toJid = toNode.attrs && toNode.attrs.jid;
+      if (!toJid) continue;
+      const toPhone = toJid.split('@')[0].split(':')[0];
+      if (toPhone !== String(this._store.phoneNumber)) continue;
+
+      const enc = findChild(toNode, 'enc');
+      if (!enc) continue;
+
+      const encType   = enc.attrs && enc.attrs.type;
+      const cipherBuf = Buffer.isBuffer(enc.content) ? enc.content : Buffer.from(enc.content || '');
+
+      // Decrypt SKDM with our Signal session
+      this._signal.decrypt(senderJid, encType, cipherBuf)
+        .then(skdmBytes => {
+          this._signal.processSKDM(groupJid, senderJid, skdmBytes);
+        })
+        .catch(() => {});
+    }
+  }
+
+  // ─── Receipt / ack ────────────────────────────────────────────────────────
+
+  _handleReceipt(node) {
+    const attrs = node.attrs || {};
+    this.emit('receipt', {
+      id:   attrs.id   || '',
+      from: attrs.from || '',
+      type: attrs.type || ''
+    });
+    // ACK the receipt back to server
+    if (this._socket && this._connected) {
+      this._socket.sendNode(new BinaryNode('ack', {
+        id:    attrs.id || '',
+        class: 'receipt',
+        to:    attrs.from || ''
+      }, null));
+    }
+  }
+
+  _handleAck(node) {
+    const attrs  = node.attrs || {};
+    const id     = attrs.id   || '';
+    const cls    = attrs.class || '';
+
+    if (cls === 'message') {
+      const handler = this._pendingAcks.get(id);
+      if (handler) {
+        this._pendingAcks.delete(id);
+        handler(attrs);
+      }
+    }
+  }
+
+  _sendReadReceipt(msgId, from, participant) {
+    if (!this._socket || !this._connected) return;
+    const node = new BinaryNode('receipt', {
+      id:   msgId,
+      type: 'read',
+      to:   from
+    }, null);
+    if (participant && participant !== from) {
+      node.attrs.participant = participant;
+    }
+    this._socket.sendNode(node);
+  }
+
+  // ─── Retry request (when decryption fails) ────────────────────────────────
+
+  _sendRetryRequest(msgId, from, origNode) {
+    const pending = this._retryPending.get(msgId);
+    const count   = pending ? pending.count + 1 : 1;
+    if (count > 3) return;
+    this._retryPending.set(msgId, { node: origNode, count });
+
+    if (!this._socket || !this._connected) return;
+    this._socket.sendNode(new BinaryNode('receipt', {
+      id:   msgId,
+      type: 'retry',
+      to:   from,
+      t:    String(Math.floor(Date.now() / 1000))
+    }, [
+      new BinaryNode('retry', { count: String(count), id: msgId, t: String(Math.floor(Date.now() / 1000)), v: '1' }, null),
+      new BinaryNode('registration', {}, intToBytes(this._store.registrationId, 4))
+    ]));
+  }
+
+  // ─── Notification handling ────────────────────────────────────────────────
+
+  _handleNotification(node) {
+    const attrs = node.attrs || {};
+    const type  = attrs.type || '';
+
+    this.emit('notification', { type, attrs, node });
+
+    if (type === 'encrypt') {
+      // Server tells us pre-keys are running low
+      this._checkAndReplenishPreKeys();
+    }
+
+    if (type === 'account_sync') {
+      // Account sync notification — may contain device list updates
+      const devicesNode = findChildDeep(node, 'devices');
+      if (devicesNode) this._processDeviceUpdate(devicesNode);
+    }
+
+    if (type === 'w:gp2') {
+      // Group update: member add/remove
+      this._processGroupUpdate(node);
+    }
+
+    // Ack the notification
+    if (this._socket && this._connected) {
+      this._socket.sendNode(new BinaryNode('ack', {
+        id:    attrs.id    || '',
+        class: 'notification',
+        type:  type,
+        to:    attrs.from  || 's.whatsapp.net'
+      }, null));
+    }
+  }
+
+  _processDeviceUpdate(devicesNode) {
+    if (!Array.isArray(devicesNode.content)) return;
+    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);
+      }
+    }
+  }
+
+  _processGroupUpdate(node) {
+    const groupJid = node.attrs && node.attrs.from;
+    if (!groupJid) return;
+    if (!this._groupMembers.has(groupJid)) this._groupMembers.set(groupJid, new Set());
+    const members = this._groupMembers.get(groupJid);
+
+    if (!Array.isArray(node.content)) return;
+    for (const child of node.content) {
+      if (!child) continue;
+      if (child.description === 'add' || child.description === 'promote') {
+        for (const p of (child.content || [])) {
+          if (p && p.description === 'participant' && p.attrs && p.attrs.jid) {
+            members.add(p.attrs.jid);
+          }
+        }
+      }
+      if (child.description === 'remove' || child.description === 'demote') {
+        for (const p of (child.content || [])) {
+          if (p && p.description === 'participant' && p.attrs && p.attrs.jid) {
+            members.delete(p.attrs.jid);
+          }
+        }
+      }
+    }
+  }
+
+  // ─── Presence ─────────────────────────────────────────────────────────────
+
+  _handlePresence(node) {
+    const attrs = node.attrs || {};
+    this.emit('presence', {
+      from:      attrs.from || '',
+      available: attrs.type !== 'unavailable'
+    });
+  }
+
+  // ─── Call ─────────────────────────────────────────────────────────────────
+
+  _handleCall(node) {
+    const attrs = node.attrs || {};
+    this.emit('call', { from: attrs.from || '', node });
+    // Reject call automatically
+    if (this._socket && this._connected) {
+      const offer = findChild(node, 'offer');
+      const callId = offer && offer.attrs && offer.attrs.call_id;
+      if (callId) {
+        this._socket.sendNode(new BinaryNode('call', {
+          to: attrs.from || '',
+          id: this._genMsgId()
+        }, [new BinaryNode('reject', { call_id: callId, call_creator: attrs.from || '' }, null)]));
+      }
+    }
+  }
+
+  // ─── Auth failure (server forces logout during active session) ──────────────
+
+  _handleFailure(node) {
+    const attrs  = (node && node.attrs) || {};
+    const reason = attrs.reason || attrs.location || 'unknown';
+    this.emit('auth_failure', { reason, node });
+    // The session is no longer valid — stop reconnecting and disconnect
+    this._reconnecting = false;
+    this.disconnect();
+  }
+
+  // ─── Media connection ─────────────────────────────────────────────────────
+
+  _requestMediaConnection() {
+    if (!this._socket || !this._connected) return;
+    this._socket.sendNode(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'w:m'
+    }, [new BinaryNode('media_conn', {}, null)]));
+  }
+
+  _onMediaConnectionResult(node) {
+    const connNode = findChild(node, 'media_conn');
+    if (!connNode) return;
+    const auth  = (connNode.attrs && connNode.attrs.auth) || '';
+    const hosts = [];
+    if (Array.isArray(connNode.content)) {
+      for (const child of connNode.content) {
+        if (child && child.description === 'host') {
+          const hostname = child.attrs && child.attrs.hostname;
+          if (hostname) hosts.push(hostname);
+        }
+      }
+    }
+    this._mediaConn = { hosts, auth };
+    if (this._sender) this._sender.setMediaConnection(hosts, auth);
+    this.emit('media_conn', { hosts, auth });
+  }
+
+  // ─── Pre-key upload ───────────────────────────────────────────────────────
+
+  _uploadPreKeys() {
+    if (!this._signal || !this._socket || !this._connected) return;
+
+    const preKeys  = this._signal.getPreKeysForUpload(50);
+    const spk      = this._signal.getSignedPreKeyForUpload();
+    const identKey = this._signal.getIdentityKey();
+    if (!preKeys.length || !spk) return;
+
+    const preKeyNodes = preKeys.map(pk => new BinaryNode('key', {}, [
+      new BinaryNode('id',    {}, intToBytes(pk.keyId, 3)),
+      new BinaryNode('value', {}, stripKeyPrefix(pk.pubKey))
+    ]));
+
+    const skNode = new BinaryNode('skey', {}, [
+      new BinaryNode('id',        {}, intToBytes(spk.keyId, 3)),
+      new BinaryNode('value',     {}, stripKeyPrefix(spk.keyPair.pubKey)),
+      new BinaryNode('signature', {}, spk.signature)
+    ]);
+
+    this._socket.sendNode(new BinaryNode('iq', {
+      id:    this._genMsgId(),
+      to:    's.whatsapp.net',
+      type:  'set',
+      xmlns: 'encrypt'
+    }, [
+      new BinaryNode('registration', {}, intToBytes(this._store.registrationId, 4)),
+      new BinaryNode('type',         {}, Buffer.from([5])),
+      new BinaryNode('identity',     {}, stripKeyPrefix(identKey)),
+      new BinaryNode('list',         {}, preKeyNodes),
+      skNode
+    ]));
+  }
+
+  _checkAndReplenishPreKeys() {
+    if (!this._signal) return;
+    const count = this._signal.preKeyCount();
+    if (count < 20) {
+      const newKeys = this._signal.replenishPreKeys();
+      if (newKeys.length > 0) this._uploadPreKeys();
+    }
+  }
+
+  // ─── IQ helper (send + await response) ────────────────────────────────────
+
+  _sendIq(node) {
+    return new Promise((resolve, reject) => {
+      const id = node.attrs && node.attrs.id;
+      if (!id) return reject(new Error('IQ node has no id'));
+
+      const timer = setTimeout(() => {
+        this._pendingIqs.delete(id);
+        resolve(null);  // Resolve null on timeout rather than reject
+      }, 15000);
+
+      this._pendingIqs.set(id, (result) => {
+        clearTimeout(timer);
+        resolve(result);
+      });
+
+      try {
+        this._socket.sendNode(node);
+      } catch (err) {
+        clearTimeout(timer);
+        this._pendingIqs.delete(id);
+        reject(err);
+      }
+    });
+  }
+
+  // ─── Group metadata ───────────────────────────────────────────────────────
+
+  async getGroupMetadata(groupJid) {
+    const id   = this._genMsgId();
+    const node = new BinaryNode('iq', {
+      id,
+      to:    groupJid,
+      type:  'get',
+      xmlns: 'w:g2'
+    }, [new BinaryNode('query', { request: 'interactive' }, null)]);
+
+    const response = await this._sendIq(node);
+    if (!response) return null;
+
+    // Parse members from response and update cache
+    const groupNode = findChild(response, 'group');
+    if (groupNode && Array.isArray(groupNode.content)) {
+      if (!this._groupMembers.has(groupJid)) this._groupMembers.set(groupJid, new Set());
+      const members = this._groupMembers.get(groupJid);
+      for (const child of groupNode.content) {
+        if (child && child.description === 'participant' && child.attrs && child.attrs.jid) {
+          members.add(child.attrs.jid);
+        }
+      }
+    }
+    return response;
+  }
+
+  // ─── Group member helpers ─────────────────────────────────────────────────
+
+  _getGroupMembers(groupJid) {
+    const members = this._groupMembers.get(groupJid);
+    return members ? [...members] : [];
+  }
+
+  async refreshGroupMembers(groupJid) {
+    await this.getGroupMetadata(groupJid);
+    return this._getGroupMembers(groupJid);
+  }
+
+  // ─── Message ID generator ─────────────────────────────────────────────────
+
+  _genMsgId() {
+    return crypto.randomBytes(8).toString('hex').toUpperCase();
+  }
+
+  // ─── Public API ───────────────────────────────────────────────────────────
+
+  setPresence(available) {
+    if (this._sender) this._sender.sendPresence(available);
+  }
+
+  markRead(jid, messageIds) {
+    if (this._sender) this._sender.markRead(jid, messageIds);
+  }
+
+  async sendText(to, text, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendText(to, text, opts);
+  }
+
+  async sendImage(to, data, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendImage(to, data, opts);
+  }
+
+  async sendVideo(to, data, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendVideo(to, data, opts);
+  }
+
+  async sendAudio(to, data, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendAudio(to, data, opts);
+  }
+
+  async sendDocument(to, data, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendDocument(to, data, opts);
+  }
+
+  async sendSticker(to, data, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendSticker(to, data, opts);
+  }
+
+  async sendReaction(to, messageId, emoji, opts) {
+    if (!this._sender || !this._connected) throw new Error('Not connected');
+    return this._sender.sendReaction(to, messageId, emoji, opts);
+  }
+}
+
+module.exports = {
+  WhalibmobClient,
+  checkIfRegistered,
+  checkNumberStatus,
+  requestSmsCode,
+  verifyCode,
+  createNewStore,
+  saveStore,
+  loadStore,
+  toSixParts,
+  fromSixParts
+};