whalibmob 5.10.0 → 5.10.1

package/README.md

@@ -1449,6 +1449,21 @@ client.on('account_restriction', (r) => {
 > client-side shortens it; the only thing that helps is not sending more
 > unanswered first messages while it is on.
 
+> [!WARNING]
+> **Some servers answer this query in Argo, not JSON.** Argo is Meta's binary
+> GraphQL encoding, and this library cannot read it. When that happens
+> `fetchReachoutTimelock()` throws with `err.mexFormat === 'argo'` and the raw
+> bytes on `err.mexPayload`.
+>
+> It never guesses. Reporting "not restricted" from an answer nobody decoded
+> would have you send more messages and make the restriction longer, so an
+> unreadable reply is an error rather than an all-clear.
+>
+> The `account_restriction` event is unaffected: the server *announces* a
+> restriction starting and lifting, and those announcements arrive as readable
+> JSON on a different route. Keep a listener attached and you will still be
+> told, with the countdown, without ever calling the query.
+
 ### What Is Automatic vs What You Need to Do
 
 **Everything in the "Automatic" column requires zero code from you.**
@@ -3247,6 +3262,21 @@ For the numbers without the countdown:
 wa> /restriction --once
 ```
 
+If your server encodes this answer in Argo, the command says so rather than
+guessing — and points you at the announcements, which stay readable:
+
+```sh
+wa> /restriction
+checking account restriction...
+error: mex query 23983697327930364: the server answered in "argo" rather than JSON, which this library cannot read (10 bytes: 0402300c000002010303)
+
+  The query itself worked — your server encodes this answer in a binary
+  format this library cannot read yet, so the countdown cannot be polled.
+
+  You will still be told about a restriction: the server announces one when
+  it starts and when it lifts, and those announcements do arrive readable.
+```
+
 An account that is fine says so and returns immediately:
 
 ```sh

package/cli.js

@@ -1482,7 +1482,31 @@ async function handleLine(line) {
         requireConn();
         const watch = !p.includes('--once');
         out('checking account restriction...');
-        const st = await _client.fetchReachoutTimelock();
+        let st;
+        try {
+          st = await _client.fetchReachoutTimelock();
+        } catch (e) {
+          fail(e.message);
+          if (e.mexFormat) {
+            out('');
+            out('  The query itself worked — your server encodes this answer in a binary');
+            out('  format this library cannot read yet, so the countdown cannot be polled.');
+            out('');
+            out('  You will still be told about a restriction: the server announces one when');
+            out('  it starts and when it lifts, and those announcements do arrive readable.');
+            out('  Leave the session connected and watch for:');
+            out('    ACCOUNT RESTRICTED — <reason>, HH:MM:SS remaining');
+            out('');
+            out('  The payload above is worth keeping. Run this again while the account IS');
+            out('  restricted: the two payloads differ only where the answer differs, which');
+            out('  is what makes this format readable without its schema.');
+          } else {
+            out('');
+            out('  If the reply is sketched above, paste that line when reporting this —');
+            out('  it is the server\'s actual answer. Run with --debug for the raw stanza.');
+          }
+          break;
+        }
         hr();
         if (!st.active) {
           kv('status', 'not restricted — you can start new chats');

package/lib/Client.js

@@ -177,6 +177,39 @@ function findChildDeep(node, desc) {
   return null;
 }
 
+// A one-line sketch of a stanza, for an error message that has to be useful to
+// somebody who cannot see the wire. Shows the tag tree and a short preview of
+// any content, so an unexpected reply can be reported rather than guessed at.
+function describeNodeBriefly(node, depth) {
+  if (!node) return '(nothing)';
+  depth = depth || 0;
+  const attrs = Object.entries(node.attrs || {})
+    .map(([k, v]) => k + '=' + String(v))
+    .join(' ');
+  let out = '<' + node.description + (attrs ? ' ' + attrs : '');
+
+  if (Array.isArray(node.content)) {
+    if (depth >= 3) return out + ' …>';
+    const kids = node.content
+      .filter(c => c && c.description)
+      .map(c => describeNodeBriefly(c, depth + 1));
+    return out + '>' + kids.join('');
+  }
+
+  const buf = getNodeContent(node);
+  if (buf && buf.length) {
+    const text = buf.toString('utf8');
+    // Printable content is far more use than hex; fall back to hex when it is
+    // not text at all.
+    const printable = /^[\x09\x0a\x0d\x20-\x7e]*$/.test(text);
+    const shown = printable
+      ? JSON.stringify(text.length > 120 ? text.slice(0, 120) + '…' : text)
+      : '0x' + buf.slice(0, 40).toString('hex') + (buf.length > 40 ? '…' : '');
+    return out + '>' + buf.length + 'B ' + shown;
+  }
+  return out + '/>';
+}
+
 function getNodeContent(node) {
   if (!node) return null;
   if (Buffer.isBuffer(node.content)) return node.content;
@@ -4926,37 +4959,104 @@ class WhalibmobClient extends EventEmitter {
    * caller concludes the account is fine.
    */
   async _mexQuery(queryId, variables, dataPath) {
-    const resp = await this._sendIq(new BinaryNode('iq', {
-      id:    this._genMsgId(),
-      to:    's.whatsapp.net',
-      type:  'get',
-      xmlns: 'w:mex'
-    }, [
-      new BinaryNode('query', { query_id: String(queryId) },
-        Buffer.from(JSON.stringify({ variables: variables || {} }), 'utf8'))
-    ]));
+    const body = Buffer.from(JSON.stringify({ variables: variables || {} }), 'utf8');
+
+    const send = (askForJson) => {
+      const attrs = { query_id: String(queryId) };
+      // Newer servers answer this transport in Argo, Meta's binary GraphQL
+      // encoding, which nothing here can read. The reply labels its own format,
+      // so the format is evidently negotiable — ask for the one we can parse.
+      // A server that does not know the attribute ignores it, and one that
+      // refuses the stanza over it is handled below.
+      if (askForJson) attrs.format = 'json';
+      return this._sendIq(new BinaryNode('iq', {
+        id:    this._genMsgId(),
+        to:    's.whatsapp.net',
+        type:  'get',
+        xmlns: 'w:mex'
+      }, [new BinaryNode('query', attrs, body)]));
+    };
+
+    const hinted = this._mexJsonHintWorks !== false;
+    let resp     = await send(hinted);
+
+    // The hint is the only thing that changed, so a refusal means the server
+    // does not accept it. Drop it for this session and ask again plainly.
+    if (hinted && resp && resp.attrs && resp.attrs.type === 'error') {
+      this._mexJsonHintWorks = false;
+      _whaDbg('[DBG] MEX format=json hint refused — retrying without it');
+      resp = await send(false);
+    }
 
     if (!resp) throw new Error('mex query ' + queryId + ': no reply from server (IQ timed out)');
-    if (resp.attrs && resp.attrs.type === 'error') {
-      const errNode = findChild(resp, 'error');
-      const code    = errNode && errNode.attrs && errNode.attrs.code;
+
+    // An <error> child is the refusal whether or not the iq is typed as one.
+    const errNode = (resp.attrs && resp.attrs.type === 'error')
+      ? findChildDeep(resp, 'error') : findChild(resp, 'error');
+    if (errNode) {
+      const a    = errNode.attrs || {};
+      const code = a.code ? String(a.code) : null;
+      const text = a.text ? String(a.text) : null;
       throw new Error('mex query ' + queryId + ': server rejected the request' +
-        (code ? ' (' + code + ')' : ''));
+        (code ? ' (' + code + (text ? ' ' + text : '') + ')' : ''));
     }
 
-    const resultNode = findChild(resp, 'result');
-    const buf        = resultNode ? getNodeContent(resultNode) : null;
-    if (!buf) throw new Error('mex query ' + queryId + ': reply carried no result');
+    // The JSON normally sits in <result>, but not every build wraps it the same
+    // way, so take it from wherever in the reply it turns up rather than from
+    // one fixed path.
+    const json = this._mexJsonFrom(resp);
+    if (json) {
+      if (json.errors && json.errors.length) {
+        throw new Error('mex query ' + queryId + ': ' +
+          json.errors.map(e => (e && e.message) || 'unknown error').join(', '));
+      }
+      return dataPath ? (json.data && json.data[dataPath]) : json.data;
+    }
 
-    let json;
-    try { json = JSON.parse(buf.toString('utf8')); }
-    catch (_) { throw new Error('mex query ' + queryId + ': reply was not JSON'); }
+    // The query itself worked — this is purely about how the answer was
+    // encoded, and saying so is the difference between a fixable report and a
+    // shrug.
+    const resultNode = findChildDeep(resp, 'result');
+    const format     = resultNode && resultNode.attrs && resultNode.attrs.format;
+    if (format && String(format).toLowerCase() !== 'json') {
+      const raw = getNodeContent(resultNode);
+      const err = new Error('mex query ' + queryId + ': the server answered in "' +
+        format + '" rather than JSON, which this library cannot read' +
+        (raw ? ' (' + raw.length + ' bytes: ' + raw.toString('hex') + ')' : ''));
+      err.mexFormat  = String(format);
+      err.mexPayload = raw || null;
+      _whaDbg('[DBG] MEX_REPLY_FORMAT ' + format + ' — cannot decode');
+      throw err;
+    }
+
+    _whaDbg('[DBG] MEX_REPLY_UNPARSED ' + JSON.stringify(describeNodeBriefly(resp)));
+    throw new Error('mex query ' + queryId + ': the reply carried no JSON — ' +
+      describeNodeBriefly(resp));
+  }
 
-    if (json.errors && json.errors.length) {
-      throw new Error('mex query ' + queryId + ': ' +
-        json.errors.map(e => (e && e.message) || 'unknown error').join(', '));
+  // Walk the reply for the first node whose content parses as a JSON object.
+  //
+  // Content arrives as bytes for a long payload and as a plain string when the
+  // encoder had a token for it, so both are tried.
+  _mexJsonFrom(node) {
+    if (!node) return null;
+    const raw = getNodeContent(node);
+    if (raw && raw.length) {
+      const text = raw.toString('utf8').trim();
+      if (text.startsWith('{') || text.startsWith('[')) {
+        try {
+          const parsed = JSON.parse(text);
+          if (parsed && typeof parsed === 'object') return parsed;
+        } catch (_) { /* not this node */ }
+      }
     }
-    return dataPath ? (json.data && json.data[dataPath]) : json.data;
+    if (Array.isArray(node.content)) {
+      for (const child of node.content) {
+        const found = this._mexJsonFrom(child);
+        if (found) return found;
+      }
+    }
+    return null;
   }
 
   /**

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whalibmob",
-  "version": "5.10.0",
+  "version": "5.10.1",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
-  "author": "Kunboruto50",
+  "author": "Kunboruto20",
   "main": "index.js",
   "bin": {
     "wa": "./cli.js"