whalibmob 5.10.5 → 5.10.7

package/README.md

@@ -1460,11 +1460,17 @@ client.on('account_restriction', (r) => {
 > was tried against a live server, which responded by dropping the stanza
 > entirely and answering nothing.
 >
-> Some accounts get an answer with no restriction data in it at all — a bare
-> `false` rather than a result. That throws, with the decoded value on
-> `err.mexDecoded`, rather than being reported as "not restricted": an
-> all-clear invented from an answer that never said so would have you send more
-> messages and lengthen the very restriction you were asking about.
+> Some servers answer tersely — a bare `false` or `true` rather than the object
+> with the expiry in it. `false` is taken as "no restriction", because it is a
+> definite answer rather than a missing one. `true` sets `active` with
+> `expiryUnknown: true`, since it says there is a restriction but not when it
+> ends; the countdown then comes from the announcement.
+>
+> An answer that is neither — `null`, or anything that says nothing either way —
+> throws with the decoded value on `err.mexDecoded`, rather than being reported
+> as "not restricted". An all-clear invented from an answer that never gave one
+> would have you send more messages and lengthen the very restriction you were
+> asking about.
 >
 > The `account_restriction` event does not depend on any of this. The server
 > *announces* a restriction starting and lifting, and those announcements carry
@@ -2143,8 +2149,12 @@ Both methods accept a **Buffer** (use `fs.readFileSync` to load a file).
 ```js
 const fs = require('fs')
 
-// change your own profile picture
-await client.changeProfilePicture(fs.readFileSync('./avatar.jpg'))
+// change your own profile picture — any image, any shape, any size
+// returns the new picture id, or 'remove' when it was taken down
+const picId = await client.changeProfilePicture(fs.readFileSync('./avatar.jpg'))
+
+// pass null to remove it
+await client.changeProfilePicture(null)
 
 // change a group's picture (you must be admin)
 // returns the new picture id, or 'remove' when the picture was taken down
@@ -2155,8 +2165,25 @@ const picId = await client.changeGroupPicture('120363000000000000@g.us',
 await client.changeGroupPicture('120363000000000000@g.us', null)
 ```
 
-`changeGroupPicture` throws when the server refuses — `406` for an image that is
-not a JPEG it will take, `403` when you are not an admin of that group.
+`changeGroupPicture` throws when the server refuses — `406` for an image it will
+not take, `403` when you are not an admin of that group.
+
+**Both calls re-encode the image before sending it.** WhatsApp wants a square
+640×640 JPEG, and a picture that is not one is *dropped without an answer*
+rather than refused — so an unprepared file fails as a timeout that looks like a
+network fault. The image is cropped square, scaled and written out as a fresh
+JPEG, which also strips EXIF and any progressive encoding the file was carrying.
+
+This needs `jimp` (an optional dependency) or `sharp`. Without either, the file
+is sent as it is and an already-correct picture still works.
+
+```js
+// skip the re-encode if you have prepared the image yourself
+await client.changeProfilePicture(buf, { raw: true })
+
+// or choose the size
+await client.changeProfilePicture(buf, { size: 640, quality: 50 })
+```
 
 ## Privacy
 
@@ -2199,6 +2226,32 @@ await client.changePrivacySetting('groups_add',       'contacts')
 await client.changePrivacySetting('call_add',         'known')
 ```
 
+**Each setting takes its own values**, and they are not interchangeable:
+
+| setting | accepts |
+|---|---|
+| `last_seen`, `profile_picture`, `status`, `groups_add` | `all` · `contacts` · `contact_blacklist` · `none` |
+| `read_receipts` | `all` · `none` |
+| `online` | `all` · `match_last_seen` |
+| `call_add` | `all` · `known` |
+| `messages` | `all` · `contacts` |
+| `defense` | `on_standard` · `off` |
+| `stickers` | `contacts` · `contact_allowlist` · `none` |
+
+Friendlier words are translated: `on`, `off`, `everyone`, `nobody`,
+`my_contacts`, `contacts_except`, `contact_whitelist`. `on` becomes `all` — or
+`on_standard` for `defense`, which spells its on-state differently.
+
+```js
+await client.changePrivacySetting('read_receipts', 'on')    // sent as 'all'
+await client.changePrivacySetting('read_receipts', 'off')   // sent as 'none'
+```
+
+A value the setting does not take throws before anything is sent. This matters
+more than it looks: the server does not refuse an unknown value, it drops the
+stanza and never answers, so the mistake would otherwise surface as a timeout
+that looks like a network problem.
+
 ### Read Privacy Settings
 
 ```js
@@ -3286,20 +3339,6 @@ wa> /restriction --demo
 `--demo 90` uses ninety seconds instead of the default five hours, which is
 short enough to watch it reach zero and stop on its own.
 
-Some accounts get a reply that decodes cleanly but holds no restriction data.
-The command says that, rather than reading it as an all-clear:
-
-```sh
-wa> /restriction
-checking account restriction...
-error: mex query 23983697327930364: the server answered false rather than a result — this query returns no data for this account
-
-  The reply was read successfully — it simply contains no restriction
-  data. This query returns nothing usable for your account.
-
-  You will still be told about a restriction: the server announces one when
-  it starts and when it lifts, and those announcements carry the countdown.
-```
 
 An account that is fine says so and returns immediately:
 

package/cli.js

@@ -447,7 +447,7 @@ const HELP = `
   Profile
     /name    <text>                          change display name
     /about   <text>                          change own bio / about text
-    /photo   <file>                          change own profile picture (JPEG)
+    /photo   <file>|remove                   change or remove own profile picture (JPEG)
     /privacy [<type> <value>]                show or change privacy settings
                                                types:  last_seen profile_picture status
                                                        online read_receipts groups_add
@@ -1387,6 +1387,9 @@ async function handleLine(line) {
           out('  types:  last_seen  profile_picture  status  online  read_receipts');
           out('          groups_add  call_add  messages  defense  stickers');
           out('  values: all  contacts  contact_blacklist  contact_allowlist  none');
+          out('          not every setting takes every value — read_receipts is');
+          out('          all/none, online is all/match_last_seen. on and off are');
+          out('          accepted and translated.');
           out('          match_last_seen  known  on_standard  off');
           break;
         }
@@ -1398,11 +1401,12 @@ async function handleLine(line) {
       case '/photo': {
         requireConn();
         const file = p[1];
-        if (!file) { fail('usage: /photo <file>'); break; }
-        if (!fs.existsSync(file)) { fail('file not found: ' + file); break; }
-        const buf = fs.readFileSync(file);
-        await _client.changeProfilePicture(buf);
-        out('profile picture updated');
+        if (!file) { fail('usage: /photo <file>   (or /photo remove)'); break; }
+        if (file !== 'remove' && !fs.existsSync(file)) { fail('file not found: ' + file); break; }
+        const buf = file === 'remove' ? null : fs.readFileSync(file);
+        const picId = await _client.changeProfilePicture(buf);
+        out(picId === 'remove' ? 'profile picture removed'
+                               : 'profile picture updated' + (picId ? '  id=' + picId : ''));
         break;
       }
 
@@ -1518,13 +1522,11 @@ async function handleLine(line) {
           fail(e.message);
           if (e.mexDecoded !== undefined) {
             out('');
-            out('  The reply was read successfully — it simply contains no restriction');
-            out('  data. This query returns nothing usable for your account.');
+            out('  The reply was read, but it says nothing about a restriction either');
+            out('  way — so it is not being reported as an all-clear.');
             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 carry the countdown.');
-            out('  Leave the session connected and watch for:');
-            out('    ACCOUNT RESTRICTED — <reason>, HH:MM:SS remaining');
+            out('  You will still be told if one starts: the server announces that, and');
+            out('  the announcement carries the countdown.');
           } else if (e.mexFormat) {
             out('');
             out('  The query worked, but the reply is in an encoding that could not be');

package/lib/Client.js

@@ -10,6 +10,7 @@ const { NoiseSocket }     = require('./noise');
 const { MessageSender, generateMessageId, makeJid, buildOrGetAdvIdentity } = require('./messages/MessageSender');
 const { checkIfRegistered, checkNumberStatus, requestSmsCode, verifyCode, assertRegistrationKeys, fetchIosVersion, fetchWaVersion } = require('./Registration');
 const { getDeviceConfig } = require('./DeviceConfig');
+const { prepareProfilePicture } = require('./MediaThumbnail');
 const { createNewStore, saveStore, loadStore, toSixParts, fromSixParts } = require('./Store');
 const { BinaryNode }      = require('./BinaryNode');
 const { AppStateStore, COLLECTIONS } = require('./appstate/AppStateStore');
@@ -74,6 +75,46 @@ const PRIVACY_NAME_ALIASES = {
   stickers: 'stickers'
 };
 
+// What each setting will actually accept. The server does not argue with a
+// value it does not know — it drops the stanza and never answers, so a typo
+// looks exactly like a network problem. Checking here turns that into a
+// sentence naming the choices.
+const PRIVACY_ALLOWED_VALUES = {
+  last:         ['all', 'contacts', 'contact_blacklist', 'none'],
+  profile:      ['all', 'contacts', 'contact_blacklist', 'none'],
+  status:       ['all', 'contacts', 'contact_blacklist', 'none'],
+  groupadd:     ['all', 'contacts', 'contact_blacklist', 'none'],
+  readreceipts: ['all', 'none'],
+  online:       ['all', 'match_last_seen'],
+  calladd:      ['all', 'known'],
+  messages:     ['all', 'contacts'],
+  defense:      ['on_standard', 'off'],
+  stickers:     ['contacts', 'contact_allowlist', 'none']
+};
+
+// The words people reach for, mapped to the ones the protocol uses. "on" and
+// "off" are the obvious things to type for read receipts and mean nothing on
+// the wire, which is exactly the mistake worth absorbing.
+const PRIVACY_VALUE_ALIASES = {
+  everyone:            'all',
+  my_contacts:         'contacts',
+  contacts_except:     'contact_blacklist',
+  contact_whitelist:   'contact_allowlist',
+  nobody:              'none',
+  off:                 'none',
+  on:                  'all',
+  same_as_last_seen:   'match_last_seen',
+  last_seen:           'match_last_seen',
+  standard:            'on_standard'
+};
+
+// Where a word means something different for one setting than for the rest.
+// "on" is "all" everywhere except defense, whose on-state has its own name.
+const PRIVACY_VALUE_ALIASES_BY_NAME = {
+  defense: { on: 'on_standard' },
+  online:  { on: 'all', off: 'match_last_seen' }
+};
+
 // Wire name → the key it is reported under in the settings object.
 const PRIVACY_WIRE_TO_KEY = {
   last:         'lastSeen',
@@ -4288,19 +4329,60 @@ class WhalibmobClient extends EventEmitter {
 
   // Change profile picture
   // buf: Buffer with JPEG image data
-  async changeProfilePicture(buf) {
+  // Change your own profile picture.
+  //
+  // buf: a Buffer holding any image, or null to remove the current picture.
+  // Returns the new picture id, or 'remove' when it was taken down.
+  //
+  // The image is re-encoded to the square 640x640 JPEG the server expects
+  // before it goes out. Sending a file as it came off disk is what a person
+  // naturally tries and what the server silently drops — pass { raw: true } to
+  // skip that if you have already prepared it yourself.
+  //
+  // The picture is not addressed by sending the IQ *to* yourself: it goes to
+  // the server with the account named in `target`, the same shape a group
+  // picture uses. Addressed the other way the server files it nowhere and never
+  // answers, which looked from the outside like the picture had been set — the
+  // stanza went out, nothing came back, and nothing checked.
+  async changeProfilePicture(buf, opts) {
     if (!this._store) throw new Error('Not connected');
-    const selfJid = `${this._store.phoneNumber}@s.whatsapp.net`;
-    const id = this._genMsgId();
+    opts = opts || {};
+    const selfJid = this._ownDeviceJid
+      ? toNonAdJid(this._ownDeviceJid())
+      : `${this._store.phoneNumber}@s.whatsapp.net`;
+
+    const picture = (buf && !opts.raw) ? await prepareProfilePicture(buf, opts) : buf;
+
     const node = new BinaryNode('iq', {
-      id,
-      xmlns: 'w:profile:picture',
-      to:    selfJid,
-      type:  'set'
-    }, [
-      new BinaryNode('picture', { type: 'image' }, buf)
-    ]);
-    return this._sendIq(node);
+      id:     this._genMsgId(),
+      xmlns:  'w:profile:picture',
+      to:     's.whatsapp.net',
+      target: jidStrToObj(selfJid),
+      type:   'set'
+    }, picture ? [new BinaryNode('picture', { type: 'image' }, picture)] : null);
+
+    const resp = await this._sendIq(node);
+    if (!resp) {
+      throw new Error('changeProfilePicture: no reply from server (IQ timed out). ' +
+        'The server drops a picture it will not take rather than refusing it, so ' +
+        'this usually means the image was not in the form it wants' +
+        (opts.raw ? ' — this call passed { raw: true }, so nothing was re-encoded'
+                  : '. Install jimp if it is not present, so the image can be ' +
+                    're-encoded before sending') + '.');
+    }
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('changeProfilePicture: ' +
+        (String(code) === '406' ? 'the image was rejected (must be a JPEG)'
+       : String(code) === '401' ? 'not authorised to change this picture'
+       : 'server rejected the request' + (code ? ' (' + code + ')' : '')));
+    }
+
+    if (!buf) return 'remove';
+    const picNode = findChild(resp, 'picture');
+    return (picNode && picNode.attrs && picNode.attrs.id)
+      ? String(picNode.attrs.id) : null;
   }
 
   // ─── Privacy settings ─────────────────────────────────────────────────────
@@ -4373,6 +4455,8 @@ class WhalibmobClient extends EventEmitter {
         Object.keys(PRIVACY_NAME_ALIASES).join(', '));
     }
 
+    const wireValue = this._privacyWireValue(name, value);
+
     // WhatsApp Web does not put <user> children on this IQ; the exclusion list
     // is maintained separately. Kept for callers that pass it,
     // and only emitted when they do.
@@ -4390,7 +4474,7 @@ class WhalibmobClient extends EventEmitter {
       type:  'set'
     }, [
       new BinaryNode('privacy', {}, [
-        new BinaryNode('category', { name, value: String(value) },
+        new BinaryNode('category', { name, value: wireValue },
           children.length > 0 ? children : null)
       ])
     ]);
@@ -4401,7 +4485,7 @@ class WhalibmobClient extends EventEmitter {
       const errNode = findChild(resp, 'error');
       const code    = errNode && errNode.attrs && errNode.attrs.code;
       const text    = errNode && errNode.attrs && errNode.attrs.text;
-      throw new Error('changePrivacySetting: server rejected ' + name + '=' + value +
+      throw new Error('changePrivacySetting: server rejected ' + name + '=' + wireValue +
         (code ? ' (' + code + (text ? ' ' + text : '') + ')' : ''));
     }
 
@@ -4409,10 +4493,31 @@ class WhalibmobClient extends EventEmitter {
     // rather than making the caller re-query.
     const key = PRIVACY_WIRE_TO_KEY[name];
     this._privacySettings = Object.assign({}, this._privacySettings || {},
-      { [key]: String(value) });
+      { [key]: wireValue });
     return this._privacySettings;
   }
 
+  // Resolve what the caller typed to what this particular setting accepts.
+  //
+  // The allowed set differs per setting — read receipts are all-or-none, online
+  // is all-or-match-last-seen — so "contacts" is right for one and meaningless
+  // for another. Sending a meaningless one gets no reply at all.
+  _privacyWireValue(name, value) {
+    const allowed = PRIVACY_ALLOWED_VALUES[name];
+    const raw     = String(value == null ? '' : value).trim().toLowerCase();
+    const perName = PRIVACY_VALUE_ALIASES_BY_NAME[name] || {};
+    const mapped  = allowed && allowed.includes(raw)
+      ? raw
+      : (perName[raw] || PRIVACY_VALUE_ALIASES[raw] || raw);
+
+    if (allowed && !allowed.includes(mapped)) {
+      throw new Error('changePrivacySetting: "' + value + '" is not a value ' +
+        name + ' accepts — use one of ' + allowed.join(', ') +
+        '. The server ignores anything else without answering.');
+    }
+    return mapped;
+  }
+
   // ──────────────────────────────────────────────────────────────────────────
   // MESSAGING — editMessage, deleteMessage, sendStatus, forwardMessage
   // ──────────────────────────────────────────────────────────────────────────
@@ -4901,8 +5006,26 @@ class WhalibmobClient extends EventEmitter {
   async fetchReachoutTimelock() {
     const payload = await this._mexQuery(MEX_QUERY_REACHOUT_TIMELOCK, {},
       'xwa2_fetch_account_reachout_timelock');
+
+    // Some servers answer this one tersely: a bare boolean rather than the
+    // object with the expiry in it. `false` is a definite "no restriction" and
+    // is taken at face value; `true` says there is one but not when it ends, so
+    // it is marked as an expiry we do not know and the announcement supplies
+    // the countdown.
+    if (typeof payload === 'boolean') {
+      return this._setReachoutTimelock(
+        ReachoutTimelock.parseTimelockPayload({ is_active: payload }), 'query');
+    }
+
+    if (payload == null || typeof payload !== 'object') {
+      const err = new Error('the server answered ' + JSON.stringify(payload) +
+        ', which says nothing about a restriction either way');
+      err.mexDecoded = payload;
+      throw err;
+    }
+
     return this._setReachoutTimelock(
-      ReachoutTimelock.parseTimelockPayload(payload || {}), 'query');
+      ReachoutTimelock.parseTimelockPayload(payload), 'query');
   }
 
   /**
@@ -5035,16 +5158,10 @@ class WhalibmobClient extends EventEmitter {
         return dataPath ? decoded[dataPath] : decoded;
       }
 
-      // The server answered something that is not a GraphQL result at all —
-      // a bare boolean, most often. There is no data in it to return, and
-      // saying so beats handing back a shape the caller will misread.
-      const err = new Error('mex query ' + queryId + ': the server answered ' +
-        JSON.stringify(decoded) + ' rather than a result — this query returns ' +
-        'no data for this account');
-      err.mexFormat  = format ? String(format) : null;
-      err.mexPayload = raw;
-      err.mexDecoded = decoded;
-      throw err;
+      // Not a GraphQL envelope but still an answer — a bare boolean, most
+      // often. Handed back as-is for the caller to interpret, since only the
+      // caller knows what its own query means.
+      return decoded;
     }
 
     if (format && String(format).toLowerCase() !== 'json') {
@@ -5822,7 +5939,12 @@ class WhalibmobClient extends EventEmitter {
   //
   // Removal is the IQ with no body at all — an empty <picture> node is a
   // malformed upload rather than a delete, and the server answers 406 for it.
-  async changeGroupPicture(groupJid, buf) {
+  //
+  // The image is re-encoded to a square 640x640 JPEG first, on the same terms
+  // as a profile picture; { raw: true } skips that.
+  async changeGroupPicture(groupJid, buf, opts) {
+    opts = opts || {};
+    const picture = (buf && !opts.raw) ? await prepareProfilePicture(buf, opts) : buf;
     const id = this._genMsgId();
     const node = new BinaryNode('iq', {
       id,
@@ -5830,9 +5952,13 @@ class WhalibmobClient extends EventEmitter {
       target: jidStrToObj(makeJid(groupJid)),
       to:     's.whatsapp.net',
       type:   'set'
-    }, buf ? [new BinaryNode('picture', { type: 'image' }, buf)] : null);
+    }, picture ? [new BinaryNode('picture', { type: 'image' }, picture)] : null);
     const resp = await this._sendIq(node);
-    if (!resp) throw new Error('changeGroupPicture: no reply from server (IQ timed out)');
+    if (!resp) {
+      throw new Error('changeGroupPicture: no reply from server (IQ timed out). ' +
+        'The server drops a picture it will not take rather than refusing it, so ' +
+        'this usually means the image was not in the form it wants.');
+    }
     if (resp.attrs && resp.attrs.type === 'error') {
       const errNode = findChild(resp, 'error');
       const code    = errNode && errNode.attrs && errNode.attrs.code;

package/lib/MediaThumbnail.js

@@ -290,6 +290,70 @@ async function imageThumbnail(buf, opts) {
   return out;
 }
 
+// ─── Profile pictures ────────────────────────────────────────────────────────
+
+// What WhatsApp's own apps upload. The server will not take an arbitrary file:
+// it wants a square JPEG at this size, and a picture that is not one is dropped
+// without an answer rather than refused, so the failure gives no clue.
+const AVATAR_SIZE    = 640;
+const AVATAR_QUALITY = 50;
+
+/**
+ * Re-encode an image into the form a profile picture has to be in.
+ *
+ * Cropped square from the top-left of the shorter side, scaled to 640x640, and
+ * written out as a fresh JPEG. Re-encoding is the point rather than a side
+ * effect: it strips EXIF, progressive scans and unusual chroma subsampling —
+ * anything the file happened to carry — and produces a plain baseline JPEG.
+ *
+ * Returns the original buffer untouched when no image library is installed,
+ * which at least gives an already-correct picture a chance to go through.
+ */
+async function prepareProfilePicture(buf, opts) {
+  opts = opts || {};
+  if (!Buffer.isBuffer(buf) || !buf.length) return buf;
+
+  const size    = opts.size    || AVATAR_SIZE;
+  const quality = opts.quality || AVATAR_QUALITY;
+
+  try {
+    const lib = await loadImageLib();
+
+    if (lib && lib.kind === 'sharp') {
+      return await lib.sharp(buf)
+        .resize(size, size, { fit: 'cover' })
+        .jpeg({ quality })
+        .toBuffer();
+    }
+
+    if (lib && lib.kind === 'jimp1') {
+      const img = await lib.Jimp.read(buf);
+      const min = Math.min(img.width, img.height);
+      const sq  = img.crop({ x: 0, y: 0, w: min, h: min });
+      const resizeOpts = { w: size, h: size };
+      if (lib.ResizeStrategy && lib.ResizeStrategy.BILINEAR) {
+        resizeOpts.mode = lib.ResizeStrategy.BILINEAR;
+      }
+      return await sq.resize(resizeOpts).getBuffer('image/jpeg', { quality });
+    }
+
+    if (lib && lib.kind === 'jimp0') {
+      const Jimp = lib.Jimp;
+      const img  = await Jimp.read(buf);
+      const min  = Math.min(img.bitmap.width, img.bitmap.height);
+      img.crop(0, 0, min, min).resize(size, size).quality(quality);
+      return await img.getBufferAsync(Jimp.MIME_JPEG);
+    }
+  } catch (err) {
+    _whaDbg('[DBG] AVATAR could not re-encode: ' + (err && err.message));
+    return buf;
+  }
+
+  _whaDbg('[DBG] AVATAR no image library — sending the file as it is. ' +
+    'WhatsApp wants a square JPEG; install jimp to have that done for you.');
+  return buf;
+}
+
 // ─── ffmpeg ──────────────────────────────────────────────────────────────────
 
 function run(cmd, args) {
@@ -385,8 +449,11 @@ module.exports = {
   probeImageSize,
   extractExifThumbnail,
   imageThumbnail,
+  prepareProfilePicture,
   videoThumbnail,
   hasFfmpeg,
   THUMB_WIDTH,
-  THUMB_QUALITY
+  THUMB_QUALITY,
+  AVATAR_SIZE,
+  AVATAR_QUALITY
 };

package/package.json

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