whalibmob 5.5.36 → 5.5.38

package/lib/Client.js

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

package/lib/DeviceManager.js

@@ -43,7 +43,14 @@ function jidStrToObj(jidStr) {
   if (server === 's.whatsapp.net' && device > 0) {
     return { user, agent: 0, device, server, toString() { return self; } };
   }
-  // JID_PAIR: used for @lid, @g.us, and primary (device-0) @s.whatsapp.net
+  // @lid multi-device (e.g. "112713111982325:2@lid"): JID_PAIR with user="112713111982325:2"
+  // so the server receives the colon-device in the user string, not stripped.
+  // Without this, ":2@lid" is encoded as device-0 "@lid" and the server
+  // returns the wrong bundle (or ignores device 2 entirely).
+  if (server === 'lid' && device > 0) {
+    return { user: raw, server, toString() { return self; } };
+  }
+  // JID_PAIR: used for @lid device-0, @g.us, and primary (device-0) @s.whatsapp.net
   return { user, server, toString() { return self; } };
 }
 
@@ -437,33 +444,33 @@ class DeviceManager {
   //    device_orientation="0" is also required by the server.
   //
   //  Fix B — User list format: use <contact>+phone</contact> as Buffer content.
-  //    The BinaryNode encoder encodes string attributes as raw UTF-8 (BINARY_8 tag),
-  //    NOT as JID_PAIR binary format.  The APK sends phone as Buffer content of a
-  //    <contact> child node — this is what the server actually expects in the list.
-  //
   async _doUsyncIq(phones) {
     const iqId = this._client._genMsgId();
     const sid  = this._client._genMsgId();
 
-    // Fix B: <user><contact>+phone</contact></user> — matches APK exactly.
-    // Buffer.from ensures binary encoding (not raw UTF-8 string attribute).
+    // User list: <user><contact>+phone</contact></user>
+    // This is the ONLY format the server responds to for phone-based usync.
+    // The <user jid="..."/> attribute format is silently ignored by the server.
     const listChildren = phones.map(p =>
       new BinaryNode('user', {}, [
         new BinaryNode('contact', {}, Buffer.from('+' + p, 'utf8'))
       ])
     );
 
+    // context="interactive" is REQUIRED.
+    // The server ignores context="message" usync IQs entirely (never replies).
+    // Query includes <devices>, <lid>, AND <contact> so the server returns
+    // the full device list + LID mapping + contact presence in one round-trip.
     const iqNode = new BinaryNode('iq',
       { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
       [new BinaryNode('usync',
-        { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
         [
           new BinaryNode('query', {},
             [
-              // Fix A: fetch_options="5" + device_orientation="0" — required for
-              // the server to return ALL linked devices, not just device 0.
-              new BinaryNode('devices', { version: '2', device_orientation: '0', fetch_options: '5' }, null),
-              new BinaryNode('lid', {}, null)
+              new BinaryNode('devices', { version: '2' }, null),
+              new BinaryNode('lid', {}, null),
+              new BinaryNode('contact', {}, null)
             ]
           ),
           new BinaryNode('list', {}, listChildren),
@@ -472,27 +479,18 @@ class DeviceManager {
       )]
     );
 
-    _whaDbg('[DBG] USYNC_IQ phones=[' + phones.join(',') + ']\n');
+    _whaDbg('[USYNC_IQ] phones=[' + phones.join(',') + ']');
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      _whaDbg('[DBG] USYNC_ERR ' + (err && err.message));
+      _whaDbg('[USYNC_ERR] ' + (err && err.message));
       return null;
     });
 
-    // FIX Bug 4: Correct response structure is:
-    //   <usync>
-    //     <list>
-    //       <user jid="phone@s.whatsapp.net" [lid="lid_user@lid"]>
-    //         <devices>
-    //           <device-list>
-    //             <device id="0"/>
-    //             <device id="2"/>
-    //           </device-list>
-    //         </devices>
-    //       </user>
-    //     </list>
-    //   </usync>
-    if (response) {
+    if (!response) {
+      _whaDbg('[USYNC_NULL_RESP]');
+      // Timed out — fall back to contact usync for LID mapping only.
+      await this._doContactUsync(phones).catch(() => {});
+    } else {
       const usyncNode = findChild(response, 'usync');
       const listNode  = usyncNode
         ? findChild(usyncNode, 'list')
@@ -508,37 +506,47 @@ class DeviceManager {
           const isLidUser = String(userJid).endsWith('@lid');
           const { user: rawUser } = stripUser(String(userJid));
 
-          // Determine phone-based cache key (always a phone number, never a LID)
           let cachePhone;
           if (isLidUser) {
-            // Modern account: server returned LID JID in the user node
+            // Server returned a LID JID — look up the corresponding phone number.
             const pn = this._client._lidToPn && this._client._lidToPn.get(rawUser);
             if (pn) {
               cachePhone = pn;
             } else if (phones.length === 1) {
-              // Single phone queried — this LID must belong to it
               cachePhone = phones[0];
               if (this._client._lidToPn) this._client._lidToPn.set(rawUser, phones[0]);
               if (this._client._pnToLid) this._client._pnToLid.set(phones[0], rawUser);
             } else {
-              cachePhone = rawUser; // last resort: use LID user as key
+              cachePhone = rawUser; // last resort
             }
-            _whaDbg('[DBG] USYNC_LID_USER userJid=' + userJid + ' → cachePhone=' + cachePhone);
+            _whaDbg('[USYNC_LID_USER] jid=' + userJid + ' → phone=' + cachePhone);
           } else {
-            // Normal account: user JID is phone@s.whatsapp.net
+            // Server returned a phone JID (phone@s.whatsapp.net).
             cachePhone = rawUser;
 
-            // Also extract LID from user node's `lid` attribute if the server provided it
-            const lidAttr = userNode.attrs && userNode.attrs.lid;
-            if (lidAttr) {
-              const lidUser = String(lidAttr).split('@')[0].split(':')[0];
-              if (this._client._lidToPn) this._client._lidToPn.set(lidUser, cachePhone);
-              if (this._client._pnToLid) this._client._pnToLid.set(cachePhone, lidUser);
-              _whaDbg('[DBG] USYNC_LID_MAP phone=' + cachePhone + ' ↔ lid=' + lidUser);
+            // The LID is in a <lid val={user:"NNNN",...}> CHILD NODE, NOT an attr.
+            // Extract and populate both directions of the PN↔LID mapping, and
+            // pre-populate the lid: cache key so bulkEnsureSessionsForLid can
+            // skip a second IQ for this recipient.
+            const lidChildNode = findChild(userNode, 'lid');
+            const lidVal       = lidChildNode && lidChildNode.attrs && lidChildNode.attrs.val;
+            if (lidVal) {
+              const lidUser = lidVal.user
+                ? String(lidVal.user)
+                : String(lidVal).split('@')[0].split(':')[0];
+              if (lidUser) {
+                if (this._client._lidToPn) this._client._lidToPn.set(lidUser, cachePhone);
+                if (this._client._pnToLid) this._client._pnToLid.set(cachePhone, lidUser);
+                const store = this._client._signal && this._client._signal.store;
+                if (store && store.setLidMapping) store.setLidMapping(cachePhone, lidUser);
+                _whaDbg('[USYNC_LID_MAP] phone=' + cachePhone + ' ↔ lid=' + lidUser);
+                this._lidForPhone = this._lidForPhone || new Map();
+                this._lidForPhone.set(cachePhone, lidUser);
+              }
             }
           }
 
-          // Navigate user → devices → device-list → device[id=N]
+          // Parse device list: user → devices → device-list → device[id=N]
           const devicesNode    = findChild(userNode, 'devices');
           const deviceListNode = devicesNode ? findChild(devicesNode, 'device-list') : null;
 
@@ -547,37 +555,38 @@ class DeviceManager {
           if (deviceListNode && Array.isArray(deviceListNode.content)) {
             for (const devNode of deviceListNode.content) {
               if (!devNode || devNode.description !== 'device') continue;
-              // FIX: server uses `id` attribute (e.g. id="0"), NOT `jid` attribute
               const devId = devNode.attrs && devNode.attrs.id != null
                 ? parseInt(String(devNode.attrs.id), 10)
                 : 0;
               this._dcAdd(cachePhone, devId);
             }
-            _whaDbg('[DBG] USYNC_DEVICES phone=' + cachePhone +
-              ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']\n');
+
+            // Mirror device IDs to the lid: cache key so _doUsyncIqByJid is
+            // skipped when bulkEnsureSessionsForLid is later called for this LID.
+            const knownLid = this._lidForPhone && this._lidForPhone.get(cachePhone);
+            if (knownLid) {
+              const devIds = this._dcGet(cachePhone) || [];
+              this._dcSet('lid:' + knownLid, devIds.slice());
+              _whaDbg('[USYNC_LID_CACHE] lid=' + knownLid + ' ids=[' + devIds.join(',') + ']');
+            }
+
+            _whaDbg('[USYNC_DEVICES] phone=' + cachePhone +
+              ' ids=[' + (this._dcGet(cachePhone) || []).join(',') + ']');
           } else {
-            // No device-list in response — fall back to device 0
             this._dcAdd(cachePhone, 0);
-            _whaDbg('[DBG] USYNC_NO_DEVLIST phone=' + cachePhone + ' → fallback id=0\n');
+            _whaDbg('[USYNC_NO_DEVLIST] phone=' + cachePhone + ' → device 0 only');
           }
         }
       } else {
-        _whaDbg('[DBG] USYNC_RESP_NO_LIST\n');
+        _whaDbg('[USYNC_RESP_NO_LIST]');
       }
-    } else {
-      _whaDbg('[DBG] USYNC_NULL_RESP\n');
-      // Device usync timed out — fall back to a contact usync (query/contact).
-      // This DOES receive a server response and resolves the phone → LID mapping.
-      // Once _pnToLid is populated here, _sendDMMessage (after its await) will
-      // use the LID JID for routing instead of the stale phone JID.
-      await this._doContactUsync(phones).catch(() => {});
     }
 
-    // For phones with no usync response at all, cache device 0 so we don't re-query
+    // Fallback: any phone not resolved → device 0
     for (const p of phones) {
       if (!this._dcHas(p)) {
         this._dcSet(p, [0]);
-        _whaDbg('[DBG] USYNC_FALLBACK phone=' + p);
+        _whaDbg('[USYNC_FALLBACK] phone=' + p);
       }
     }
     this._scheduleSave();
@@ -680,8 +689,25 @@ class DeviceManager {
       for (const [jid, bundle] of bundles) {
         try {
           await signalProto.buildSessionFromBundle(jid, bundle);
-          readyJids.push(jid);
-          _whaDbg('[DBG] LID_SESSION_BUILT jid=' + jid);
+          // ── CRITICAL: remap bundle JID back to @lid format ────────────────────
+          // fetchBundles always returns JIDs in @s.whatsapp.net format (because the
+          // WA server uses its own AD_JID / JID_PAIR encoding in responses).
+          // But the outer <message to="lidUser@lid"> requires ALL participant <to>
+          // nodes to also use @lid format — mixing @s.whatsapp.net participants with
+          // a @lid routing address causes the server to close the connection.
+          //
+          // The Signal session address is keyed only by (user, device) — the @server
+          // suffix is stripped by jidToAddress() — so the session is reachable via
+          // either @lid or @s.whatsapp.net.  We push the @lid form so the participants
+          // node is consistent with the routing.
+          //
+          // Mapping: strip @s.whatsapp.net / @lid suffix from jid, re-append @lid
+          // e.g. "112713111982325@s.whatsapp.net"   → "112713111982325@lid"
+          //      "112713111982325:2@s.whatsapp.net" → "112713111982325:2@lid"
+          const jidBase = jid.replace(/@(?:s\.whatsapp\.net|lid)$/, '');
+          const lidJidForDevice = jidBase + '@lid';
+          readyJids.push(lidJidForDevice);
+          _whaDbg('[DBG] LID_SESSION_BUILT jid=' + jid + ' → participant=' + lidJidForDevice);
         } catch (e) {
           _whaDbg('[DBG] LID_SESSION_ERR jid=' + jid + ' err=' + e.message);
         }
@@ -725,15 +751,15 @@ class DeviceManager {
       )]
     );
 
-    _whaDbg('[DBG] CONTACT_USYNC phones=[' + phones.join(',') + ']\n');
+    _whaDbg('[CONTACT_USYNC] phones=[' + phones.join(',') + ']');
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      _whaDbg('[DBG] CONTACT_USYNC_ERR ' + (err && err.message));
+      _whaDbg('[CONTACT_USYNC_ERR] ' + (err && err.message));
       return null;
     });
 
     if (!response) {
-      _whaDbg('[DBG] CONTACT_USYNC_NULL\n');
+      _whaDbg('[CONTACT_USYNC_NULL]');
       return;
     }
 
@@ -794,12 +820,13 @@ class DeviceManager {
     const iqNode = new BinaryNode('iq',
       { id: iqId, to: 's.whatsapp.net', type: 'get', xmlns: 'usync' },
       [new BinaryNode('usync',
-        { sid, mode: 'query', last: 'true', index: '0', context: 'message' },
+        { sid, mode: 'query', last: 'true', index: '0', context: 'interactive' },
         [
           new BinaryNode('query', {},
             [
-              // Fix A applied here too: fetch_options="5" + device_orientation="0"
-              new BinaryNode('devices', { version: '2', device_orientation: '0', fetch_options: '5' }, null),
+              // context="interactive" is REQUIRED — server silently ignores
+              // "message" context usync IQs (same as _doUsyncIq).
+              new BinaryNode('devices', { version: '2' }, null),
               new BinaryNode('lid', {}, null)
             ]
           ),
@@ -811,10 +838,10 @@ class DeviceManager {
       )]
     );
 
-    _whaDbg('[DBG] USYNC_LID_IQ jid=' + jid);
+    _whaDbg('[USYNC_LID_IQ] jid=' + jid);
 
     const response = await this._client._sendIq(iqNode).catch(err => {
-      _whaDbg('[DBG] USYNC_LID_IQ_ERR ' + (err && err.message));
+      _whaDbg('[USYNC_LID_ERR] ' + (err && err.message));
       return null;
     });
 
@@ -838,19 +865,19 @@ class DeviceManager {
                 ? parseInt(String(devNode.attrs.id), 10) : 0;
               this._dcAdd(cacheKey, devId);
             }
-            _whaDbg('[DBG] USYNC_LID_DEVICES jid=' + jid +
-              ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']\n');
+            _whaDbg('[USYNC_LID_DEVICES] jid=' + jid +
+              ' ids=[' + (this._dcGet(cacheKey) || []).join(',') + ']');
           } else {
             this._dcAdd(cacheKey, 0);
-            _whaDbg('[DBG] USYNC_LID_NO_DEVLIST jid=' + jid + ' → fallback id=0\n');
+            _whaDbg('[USYNC_LID_NO_DEVLIST] jid=' + jid + ' → device 0 only');
           }
         }
       } else {
-        _whaDbg('[DBG] USYNC_LID_NO_LIST jid=' + jid);
+        _whaDbg('[USYNC_LID_NO_LIST] jid=' + jid);
         this._dcAdd(cacheKey, 0);
       }
     } else {
-      _whaDbg('[DBG] USYNC_LID_NULL_RESP jid=' + jid);
+      _whaDbg('[USYNC_LID_NULL_RESP] jid=' + jid);
       this._dcAdd(cacheKey, 0);
     }
     this._scheduleSave();

package/lib/messages/MessageSender.js

@@ -534,6 +534,18 @@ class MessageSender {
           this._devMgr.clearCache(members.map(phoneFromJid));
           return this._sendGroupMessage(toJid, msgId, plaintext, mediaType, options);
         }
+        // Error 479 = stale/dead Signal session — clear all sessions for every
+        // group member, flush device cache, rebuild from fresh bundles, retry once.
+        if (err && /\b479\b/.test(err.message) && !options._479retry) {
+          _whaDbg('[DBG] 479_GROUP clearing sessions for group ' + toJid);
+          const members = this._client._getGroupMembers
+            ? this._client._getGroupMembers(toJid) : [];
+          for (const memberJid of members) {
+            await this._clearSignalSessionsForRecipient(phoneFromJid(memberJid)).catch(() => {});
+          }
+          return this._sendGroupMessage(toJid, msgId, plaintext, mediaType,
+            Object.assign({}, options, { _479retry: true }));
+        }
         throw err;
       }
     }
@@ -545,10 +557,81 @@ class MessageSender {
         this._devMgr.clearCache([phoneFromJid(toJid)]);
         return this._sendDMMessage(toJid, msgId, plaintext, mediaType, options);
       }
+      // ── Error 479: stale / dead Signal session ────────────────────────────────
+      // The server rejected the ciphertext because it was encrypted with a Signal
+      // session key the server no longer recognises (recipient re-installed WA,
+      // changed device, or their prekey was exhausted / revoked).
+      //
+      // Recovery:
+      //   1. Delete all cached Signal sessions for this recipient (PN + LID).
+      //   2. Flush device-ID cache → forces a fresh usync IQ on next send.
+      //   3. Re-call _sendDMMessage → re-runs usync + fetchBundles + buildSession
+      //      + re-encrypts with a fresh PreKey message (pkmsg).
+      //
+      // _479retry flag prevents infinite loops: if the fresh session also gets
+      // 479 (extremely rare — server bug or banned account) we fail cleanly.
+      if (err && /\b479\b/.test(err.message) && !options._479retry) {
+        await this._clearSignalSessionsForRecipient(phoneFromJid(toJid));
+        // CRITICAL: generate a NEW msgId — the server already ACK'd (with error=479)
+        // the original ID and will close the connection if we re-send the same ID.
+        const retryMsgId = generateMessageId();
+        _whaDbg('[DBG] 479_RETRY new msgId=' + retryMsgId);
+        return this._sendDMMessage(toJid, retryMsgId, plaintext, mediaType,
+          Object.assign({}, options, { _479retry: true }));
+      }
+      // ─────────────────────────────────────────────────────────────────────────
       throw err;
     }
   }
 
+  // ─── Clear all Signal sessions for a phone-number recipient ─────────────────
+  //
+  // Called on error 479 (stale session).  Deletes:
+  //   • All Signal sessions keyed by phone-number device JIDs (e.g. 40756469325:0)
+  //   • The corresponding LID device session if a LID mapping is known
+  //
+  // Then flushes the device-ID cache for that phone so the next send re-runs
+  // usync (gets current device list) and re-fetches fresh prekey bundles.
+  async _clearSignalSessionsForRecipient(phone) {
+    _whaDbg('[DBG] 479_RECOVERY phone=' + phone + ' — clearing sessions + device cache');
+    const signal  = this._signal;
+    const devMgr  = this._devMgr;
+    const client  = this._client;
+
+    // ── 1. Get all known device JIDs for this phone (from cache) ──────────────
+    const devJids = devMgr._jidsFromCache([phone]);
+    for (const jid of devJids) {
+      try {
+        await signal.deleteSession(jid);
+        _whaDbg('[DBG] 479_DEL_SESSION jid=' + jid);
+      } catch (_) {}
+    }
+
+    // ── 2. Clear LID session if we have a LID mapping for this phone ──────────
+    // NOTE: LID JIDs use @lid server, NOT @s.whatsapp.net. Cannot use
+    // _jidsFromCache() (it hard-codes @s.whatsapp.net) — build JIDs manually.
+    const lidUser = client._pnToLid && client._pnToLid.get(phone);
+    if (lidUser) {
+      // Get all device IDs for this LID from cache (or assume device 0 primary)
+      const lidDeviceIds = (devMgr._dcGet && devMgr._dcGet('lid:' + lidUser)) || [0];
+      for (const devId of lidDeviceIds) {
+        const jid = (devId === 0) ? `${lidUser}@lid` : `${lidUser}:${devId}@lid`;
+        try {
+          await signal.deleteSession(jid);
+          _whaDbg('[DBG] 479_DEL_LID_SESSION jid=' + jid);
+        } catch (_) {}
+      }
+      // Always delete the bare primary JID too (in case it was stored without device suffix)
+      try { await signal.deleteSession(`${lidUser}@lid`); } catch (_) {}
+      // Flush LID device-ID cache so next send re-runs usync for LID
+      devMgr.clearCache(['lid:' + lidUser]);
+    }
+
+    // ── 3. Flush phone device cache → usync re-runs on next send ──────────────
+    devMgr.clearCache([phone]);
+    _whaDbg('[DBG] 479_CACHE_FLUSHED phone=' + phone);
+  }
+
   // ─── 1-to-1 multi-device fanout ───────────────────────────────────────────
 
   async _sendDMMessage(toJid, msgId, plaintext, mediaType, options) {

package/package.json

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