whalibmob 5.7.2 → 5.9.0

package/lib/appstate/Mutations.js

@@ -0,0 +1,106 @@
+'use strict';
+
+// Which collection, index and api version each kind of change is filed under.
+//
+// None of this is ours to pick. The server keys a mutation by its index, sorts
+// it by collection, and rejects an api version it does not expect — get any of
+// the three wrong and the patch is either refused or silently lands somewhere
+// the phone will never look. The index is the identity of the setting: writing
+// ['pin_v1', jid] twice replaces, rather than accumulates.
+
+function mutePatch(jid, muteEndTimestampMs) {
+  return {
+    name:  'regular_high',
+    index: ['mute', jid],
+    apiVersion: 2,
+    action: {
+      muteAction: {
+        muted: !!muteEndTimestampMs,
+        muteEndTimestamp: muteEndTimestampMs || undefined
+      }
+    }
+  };
+}
+
+function archivePatch(jid, archived) {
+  return {
+    name:  'regular_low',
+    index: ['archive', jid],
+    apiVersion: 3,
+    action: { archiveChatAction: { archived: !!archived } }
+  };
+}
+
+function markReadPatch(jid, read) {
+  return {
+    name:  'regular_low',
+    index: ['markChatAsRead', jid],
+    apiVersion: 3,
+    action: { markChatAsReadAction: { read: !!read } }
+  };
+}
+
+function pinPatch(jid, pinned) {
+  return {
+    name:  'regular_low',
+    index: ['pin_v1', jid],
+    apiVersion: 5,
+    action: { pinAction: { pinned: !!pinned } }
+  };
+}
+
+// A star is per message, so the index carries the message it belongs to as well
+// as the chat — otherwise starring a second message would unstar the first.
+function starPatch(jid, msgId, fromMe, starred) {
+  return {
+    name:  'regular_low',
+    index: ['star', jid, msgId, fromMe ? '1' : '0', '0'],
+    apiVersion: 2,
+    action: { starAction: { starred: !!starred } }
+  };
+}
+
+function pushNamePatch(name) {
+  return {
+    name:  'critical_block',
+    index: ['setting_pushName'],
+    apiVersion: 1,
+    action: { pushNameSetting: { name } }
+  };
+}
+
+function contactPatch(jid, contact) {
+  return {
+    name:  'critical_unblock_low',
+    index: ['contact', jid],
+    apiVersion: 2,
+    action: { contactAction: contact || {} },
+    // No contact means forget this one, which is a removal rather than an
+    // empty value.
+    operation: contact ? 0 : 1
+  };
+}
+
+// The index tells you what a decoded mutation was about. The first element is
+// the kind; what follows depends on it.
+function describeIndex(index) {
+  if (!Array.isArray(index) || !index.length) return null;
+  const [kind, jid, msgId, fromMe] = index;
+  switch (kind) {
+    case 'mute':            return { kind: 'mute',     jid };
+    case 'archive':         return { kind: 'archive',  jid };
+    case 'markChatAsRead':  return { kind: 'markRead', jid };
+    case 'pin_v1':          return { kind: 'pin',      jid };
+    case 'star':            return { kind: 'star',     jid, msgId, fromMe: fromMe === '1' };
+    case 'contact':         return { kind: 'contact',  jid };
+    case 'setting_pushName':return { kind: 'pushName' };
+    case 'clearChat':       return { kind: 'clear',    jid };
+    case 'deleteChat':      return { kind: 'delete',   jid };
+    default:                return { kind, jid };
+  }
+}
+
+module.exports = {
+  mutePatch, archivePatch, markReadPatch, pinPatch, starPatch,
+  pushNamePatch, contactPatch, describeIndex
+};

package/lib/appstate/SyncdProto.js

@@ -0,0 +1,263 @@
+'use strict';
+
+// The wire format app state travels in.
+//
+// A collection ("regular_low", "critical_block", …) is a versioned list of
+// mutations. Each mutation names an index — a JSON array like ["pin_v1", jid] —
+// and carries the encrypted value filed under it. The server hands them over
+// either as a snapshot (the whole collection, from scratch) or as patches (what
+// changed since a version you name).
+//
+//   SyncdPatch   { version=1, mutations=2, externalMutations=3,
+//                  snapshotMac=4, patchMac=5, keyId=6 }
+//   SyncdSnapshot{ version=1, records=2, mac=3, keyId=4 }
+//   SyncdMutation{ operation=1 (SET=0 REMOVE=1), record=2 }
+//   SyncdRecord  { index=1, value=2, keyId=3 }
+//   SyncdIndex   { blob=1 }   SyncdValue { blob=1 }   KeyId { id=1 }
+//   SyncdVersion { version=1 }
+//   SyncdMutations { mutations=1 }
+//   ExternalBlobReference { mediaKey=1, directPath=2, handle=3,
+//                           fileSizeBytes=4, fileSha256=5, fileEncSha256=6 }
+//   SyncActionData { index=1, value=2, padding=3, version=4 }
+
+const {
+  decodeFields, field, varint, str, bytes, WIRE_VARINT, WIRE_LEN
+} = require('../proto/MessageProto');
+
+const SET    = 0;
+const REMOVE = 1;
+
+const _b   = v => (v == null ? null : (Buffer.isBuffer(v) ? v : Buffer.from(v)));
+const _arr = v => (v == null ? [] : (Array.isArray(v) ? v : [v]));
+const _num = v => {
+  if (v == null) return 0;
+  if (typeof v === 'number') return v;
+  if (Buffer.isBuffer(v)) { let n = 0; for (let i = v.length - 1; i >= 0; i--) n = n * 256 + v[i]; return n; }
+  return Number(v) || 0;
+};
+const _str = v => (v == null ? '' : (Buffer.isBuffer(v) ? v.toString('utf8') : String(v)));
+
+// ─── decoding ────────────────────────────────────────────────────────────────
+
+function decodeKeyId(buf) {
+  if (!buf) return null;
+  const f = decodeFields(buf);
+  return _b(f[1]);
+}
+
+function decodeRecord(buf) {
+  const f = decodeFields(buf);
+  return {
+    indexBlob: f[1] ? _b(decodeFields(f[1])[1]) : null,
+    valueBlob: f[2] ? _b(decodeFields(f[2])[1]) : null,
+    keyId:     decodeKeyId(f[3])
+  };
+}
+
+// A bare record is a SET; only a SyncdMutation carries an operation of its own.
+function decodeMutation(buf) {
+  const f = decodeFields(buf);
+  if (!f[2]) return Object.assign({ operation: SET }, decodeRecord(buf));
+  return Object.assign({ operation: _num(f[1]) }, decodeRecord(f[2]));
+}
+
+function decodeExternalBlobReference(buf) {
+  if (!buf) return null;
+  const f = decodeFields(buf);
+  return {
+    mediaKey:      _b(f[1]),
+    directPath:    _str(f[2]),
+    handle:        _str(f[3]),
+    fileSizeBytes: _num(f[4]),
+    fileSha256:    _b(f[5]),
+    fileEncSha256: _b(f[6])
+  };
+}
+
+function decodePatch(buf) {
+  const f = decodeFields(buf);
+  return {
+    version:           f[1] ? _num(decodeFields(f[1])[1]) : null,
+    mutations:         _arr(f[2]).filter(Buffer.isBuffer).map(decodeMutation),
+    externalMutations: decodeExternalBlobReference(f[3]),
+    snapshotMac:       _b(f[4]),
+    patchMac:          _b(f[5]),
+    keyId:             decodeKeyId(f[6])
+  };
+}
+
+function decodeSnapshot(buf) {
+  const f = decodeFields(buf);
+  return {
+    version: f[1] ? _num(decodeFields(f[1])[1]) : 0,
+    records: _arr(f[2]).filter(Buffer.isBuffer)
+      .map(r => Object.assign({ operation: SET }, decodeRecord(r))),
+    mac:     _b(f[3]),
+    keyId:   decodeKeyId(f[4])
+  };
+}
+
+// The blob an oversized patch is moved out into.
+function decodeMutations(buf) {
+  const f = decodeFields(buf);
+  return _arr(f[1]).filter(Buffer.isBuffer).map(decodeMutation);
+}
+
+function decodeSyncActionData(buf) {
+  const f = decodeFields(buf);
+  return {
+    index:   _b(f[1]),
+    value:   f[2] ? decodeSyncActionValue(f[2]) : null,
+    version: _num(f[4])
+  };
+}
+
+// ─── SyncActionValue ─────────────────────────────────────────────────────────
+//
+// One field per kind of change. Only the ones this library acts on are decoded;
+// anything else is reported by name so a caller can see it went by.
+const ACTION_FIELDS = {
+  2:  'starAction',
+  3:  'contactAction',
+  4:  'muteAction',
+  5:  'pinAction',
+  7:  'pushNameSetting',
+  17: 'archiveChatAction',
+  20: 'markChatAsReadAction',
+  21: 'clearChatAction',
+  22: 'deleteChatAction'
+};
+
+function decodeSyncActionValue(buf) {
+  const f   = decodeFields(buf);
+  const out = { timestamp: _num(f[1]) };
+
+  for (const [num, name] of Object.entries(ACTION_FIELDS)) {
+    const raw = f[num];
+    if (!Buffer.isBuffer(raw)) continue;
+    const a = decodeFields(raw);
+    switch (name) {
+      case 'starAction':
+        out.starAction = { starred: !!_num(a[1]) }; break;
+      case 'pinAction':
+        out.pinAction = { pinned: !!_num(a[1]) }; break;
+      case 'muteAction':
+        out.muteAction = {
+          muted: !!_num(a[1]),
+          muteEndTimestamp: _num(a[2]),
+          autoMuted: !!_num(a[3])
+        };
+        break;
+      case 'archiveChatAction':
+        out.archiveChatAction = { archived: !!_num(a[1]) }; break;
+      case 'markChatAsReadAction':
+        out.markChatAsReadAction = { read: !!_num(a[1]) }; break;
+      case 'clearChatAction':
+        out.clearChatAction = {}; break;
+      case 'deleteChatAction':
+        out.deleteChatAction = {}; break;
+      case 'pushNameSetting':
+        out.pushNameSetting = { name: _str(a[1]) }; break;
+      case 'contactAction':
+        out.contactAction = {
+          fullName:  _str(a[1]) || null,
+          firstName: _str(a[2]) || null,
+          lidJid:    _str(a[3]) || null,
+          pnJid:     _str(a[5]) || null,
+          username:  _str(a[6]) || null
+        };
+        break;
+      default: break;
+    }
+  }
+
+  // Whatever else the server sent, so a caller is not left guessing why nothing
+  // happened for a mutation that plainly said something.
+  const known    = new Set(['1', ...Object.keys(ACTION_FIELDS)]);
+  out.otherFields = Object.keys(f).filter(k => !known.has(k)).map(Number);
+  return out;
+}
+
+// ─── encoding (the write path) ───────────────────────────────────────────────
+
+function encodeKeyId(id)      { return field(1, WIRE_LEN, bytes(id)); }
+function encodeVersion(v)     { return field(1, WIRE_VARINT, varint(v)); }
+
+function encodeSyncActionValue(action, timestampMs) {
+  const parts = [field(1, WIRE_VARINT, varint(timestampMs))];
+
+  if (action.starAction) {
+    parts.push(field(2, WIRE_LEN,
+      field(1, WIRE_VARINT, varint(action.starAction.starred ? 1 : 0))));
+  }
+  if (action.contactAction) {
+    const c = action.contactAction;
+    parts.push(field(3, WIRE_LEN, Buffer.concat([
+      c.fullName  ? field(1, WIRE_LEN, str(c.fullName))  : Buffer.alloc(0),
+      c.firstName ? field(2, WIRE_LEN, str(c.firstName)) : Buffer.alloc(0)
+    ])));
+  }
+  if (action.muteAction) {
+    const m = action.muteAction;
+    parts.push(field(4, WIRE_LEN, Buffer.concat([
+      field(1, WIRE_VARINT, varint(m.muted ? 1 : 0)),
+      m.muteEndTimestamp
+        ? field(2, WIRE_VARINT, varint(m.muteEndTimestamp))
+        : Buffer.alloc(0)
+    ])));
+  }
+  if (action.pinAction) {
+    parts.push(field(5, WIRE_LEN,
+      field(1, WIRE_VARINT, varint(action.pinAction.pinned ? 1 : 0))));
+  }
+  if (action.pushNameSetting) {
+    parts.push(field(7, WIRE_LEN, field(1, WIRE_LEN, str(action.pushNameSetting.name))));
+  }
+  if (action.archiveChatAction) {
+    parts.push(field(17, WIRE_LEN,
+      field(1, WIRE_VARINT, varint(action.archiveChatAction.archived ? 1 : 0))));
+  }
+  if (action.markChatAsReadAction) {
+    parts.push(field(20, WIRE_LEN,
+      field(1, WIRE_VARINT, varint(action.markChatAsReadAction.read ? 1 : 0))));
+  }
+  return Buffer.concat(parts);
+}
+
+function encodeSyncActionData({ index, value, apiVersion, timestampMs }) {
+  return Buffer.concat([
+    field(1, WIRE_LEN,    bytes(index)),
+    field(2, WIRE_LEN,    encodeSyncActionValue(value, timestampMs)),
+    field(3, WIRE_LEN,    Buffer.alloc(0)),           // padding, always empty
+    field(4, WIRE_VARINT, varint(apiVersion || 1))
+  ]);
+}
+
+function encodeMutation({ operation, indexMac, valueBlob, keyId }) {
+  const record = Buffer.concat([
+    field(1, WIRE_LEN, field(1, WIRE_LEN, bytes(indexMac))),
+    field(2, WIRE_LEN, field(1, WIRE_LEN, bytes(valueBlob))),
+    field(3, WIRE_LEN, encodeKeyId(keyId))
+  ]);
+  return Buffer.concat([
+    field(1, WIRE_VARINT, varint(operation)),
+    field(2, WIRE_LEN,    record)
+  ]);
+}
+
+function encodePatch({ version, mutations, snapshotMac, patchMac, keyId }) {
+  return Buffer.concat([
+    field(1, WIRE_LEN, encodeVersion(version)),
+    ...mutations.map(m => field(2, WIRE_LEN, encodeMutation(m))),
+    field(4, WIRE_LEN, bytes(snapshotMac)),
+    field(5, WIRE_LEN, bytes(patchMac)),
+    field(6, WIRE_LEN, encodeKeyId(keyId))
+  ]);
+}
+
+module.exports = {
+  SET, REMOVE,
+  decodePatch, decodeSnapshot, decodeMutations, decodeMutation,
+  decodeExternalBlobReference, decodeSyncActionData, decodeSyncActionValue,
+  encodePatch, encodeMutation, encodeSyncActionData, encodeSyncActionValue
+};

package/lib/messages/MessageSender.js

@@ -15,6 +15,8 @@ const {
   encodeStickerMessage, encodeReactionMessage,
   encodePollCreationMessage,
   encodeLocationMessage, encodeContactMessage,
+  encodeGroupInviteMessage,
+  GROUP_INVITE_TYPE_DEFAULT, GROUP_INVITE_TYPE_PARENT,
   encodeDeviceSentMessage, encodeProtocolMessage,
   encodeExtendedText,
   encodeSenderKeyDistributionMessage,
@@ -535,6 +537,36 @@ class MessageSender {
       Object.assign({}, opts, { _mediaSubtype: 'vcard' }));
   }
 
+  // ─── Group invite ─────────────────────────────────────────────────────────
+  // sendGroupInvite(to, groupJid, inviteCode, inviteExpiration, opts)
+  //
+  // The bubble that carries a personal invitation into a group. It is what you
+  // fall back to when adding somebody outright is refused because their privacy
+  // settings do not allow it — the server hands back a code with that refusal
+  // and this is what turns the code into something the person can tap.
+  //
+  // opts: { groupName, caption, jpegThumbnail, isCommunity, id, contextInfo }
+
+  async sendGroupInvite(to, groupJid, inviteCode, inviteExpiration, opts) {
+    opts = opts || {};
+    const msgId  = opts.id || generateMessageId();
+    const toJid  = makeJid(to);
+    const invBuf = encodeMessage('groupInvite', encodeGroupInviteMessage({
+      groupJid:         makeJid(groupJid),
+      inviteCode,
+      inviteExpiration: inviteExpiration || 0,
+      groupName:        opts.groupName || '',
+      caption:          opts.caption   || '',
+      jpegThumbnail:    opts.jpegThumbnail || opts.thumbnail || null,
+      groupType:        opts.isCommunity ? GROUP_INVITE_TYPE_PARENT
+                                         : GROUP_INVITE_TYPE_DEFAULT,
+      contextInfo:      opts.contextInfo
+    }));
+    // No media travels with it and it is not a reaction or a poll, so as far as
+    // the envelope is concerned this is an ordinary message.
+    return this._sendMessage(toJid, msgId, invBuf, 'text', opts);
+  }
+
   // ─── Forward decoded message ───────────────────────────────────────────────
   //
   // Forwards a received message to a new recipient without re-uploading media.

package/lib/messages/TcTokenStore.js

@@ -166,6 +166,50 @@ class TcTokenStore {
     return true;
   }
 
+  /**
+   * Fold an entry filed under one JID into the entry for another.
+   *
+   * The same contact can end up with two entries — one under their phone JID
+   * and one under their LID — when a send happens before the LID mapping is
+   * known. That is not just untidy: whichever key the next send resolves to is
+   * the only one it looks at, so a live token under the LID goes unused and the
+   * message ships without one.
+   *
+   * The live token wins, newest first. The sender timestamp takes the newer of
+   * the two, since an older one would say we are due to issue again when we are
+   * not.
+   *
+   * @returns {boolean} whether anything was moved
+   */
+  mergeEntry(fromJid, toJid) {
+    const fromKey = normalizeJidForTcToken(fromJid);
+    const toKey   = normalizeJidForTcToken(toJid);
+    if (fromKey === toKey) return false;
+
+    const from = this._map.get(fromKey);
+    if (!from) return false;
+
+    const to = this._map.get(toKey) || {};
+
+    const fromLive = !!(from.token && from.token.length) && !tcTokenExpired(from.timestamp);
+    const toLive   = !!(to.token   && to.token.length)   && !tcTokenExpired(to.timestamp);
+
+    let token     = to.token != null ? to.token : null;
+    let timestamp = to.timestamp != null ? to.timestamp : null;
+    if (fromLive && (!toLive || Number(from.timestamp) > Number(to.timestamp || 0))) {
+      token     = from.token;
+      timestamp = from.timestamp;
+    }
+
+    const senderTimestamp =
+      Math.max(Number(to.senderTimestamp || 0), Number(from.senderTimestamp || 0)) || null;
+
+    this._map.set(toKey, { token, timestamp, senderTimestamp });
+    this._map.delete(fromKey);
+    this._save();
+    return true;
+  }
+
   clearToken(jid) {
     const key      = normalizeJidForTcToken(jid);
     const existing = this._map.get(key) || {};

package/lib/proto/MessageProto.js

@@ -281,6 +281,34 @@ function encodeContactMessage(opts) {
   return Buffer.concat(parts);
 }
 
+// ─── GroupInviteMessage (field 28 of Message) ────────────────────────────────
+//
+// The bubble you send someone directly when they cannot simply be added to a
+// group: it carries the group's JID plus a one-off invite code and the moment
+// that code stops working. Tapping it makes their client send the accept IQ.
+//
+// GroupInviteMessage { groupJid=1, inviteCode=2, inviteExpiration=3,
+//                      groupName=4, jpegThumbnail=5, caption=6, contextInfo=7,
+//                      groupType=8 }
+//
+// groupType is 0 for an ordinary group and 1 for a community.
+const GROUP_INVITE_TYPE_DEFAULT = 0;
+const GROUP_INVITE_TYPE_PARENT  = 1;
+
+function encodeGroupInviteMessage(opts) {
+  const parts = [
+    field(1, WIRE_LEN,    str(opts.groupJid || '')),
+    field(2, WIRE_LEN,    str(opts.inviteCode || '')),
+    field(3, WIRE_VARINT, varint(Number(opts.inviteExpiration) || 0))
+  ];
+  if (opts.groupName)     parts.push(field(4, WIRE_LEN, str(opts.groupName)));
+  if (opts.jpegThumbnail) parts.push(field(5, WIRE_LEN, bytes(opts.jpegThumbnail)));
+  if (opts.caption)       parts.push(field(6, WIRE_LEN, str(opts.caption)));
+  if (opts.contextInfo)   parts.push(field(7, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  if (opts.groupType)     parts.push(field(8, WIRE_VARINT, varint(Number(opts.groupType) || 0)));
+  return Buffer.concat(parts);
+}
+
 function encodeReactionMessage(opts) {
   const parts = [
     field(1, WIRE_LEN,    encodeMessageKey(opts.key)),
@@ -306,6 +334,7 @@ function encodeMessage(type, payload) {
     case 'audio':        return field(8,  WIRE_LEN, payload);
     case 'video':        return field(9,  WIRE_LEN, payload);
     case 'sticker':      return field(26, WIRE_LEN, payload);
+    case 'groupInvite':  return field(28, WIRE_LEN, payload);
     case 'reaction':     return field(46, WIRE_LEN, payload);
     case 'protocol':     return field(12, WIRE_LEN, payload);
     // extendedTextMessage is field 6. It used to be written to field 2, which is
@@ -548,6 +577,27 @@ function decodeMessageContainer(buf) {
       } catch (_) { msgResult = { type: 'location', latitude: 0, longitude: 0 }; }
     }
 
+    // Field 28: groupInviteMessage — groupJid=1, inviteCode=2, inviteExpiration=3,
+    // groupName=4, jpegThumbnail=5, caption=6, groupType=8
+    //
+    // Everything acceptGroupInviteMessage() needs is in here, so an invite that
+    // arrives can be acted on without the caller re-parsing the payload.
+    if (!msgResult && f[28] && Buffer.isBuffer(f[28])) {
+      try {
+        const inv = _decodeFields(f[28]);
+        msgResult = {
+          type:             'groupInvite',
+          groupJid:         _str(inv[1]),
+          inviteCode:       _str(inv[2]),
+          inviteExpiration: _num(inv[3]),
+          groupName:        _str(inv[4]),
+          jpegThumbnail:    inv[5] || null,
+          caption:          _str(inv[6]),
+          isCommunity:      _num(inv[8]) === 1
+        };
+      } catch (_) { msgResult = { type: 'groupInvite', groupJid: '', inviteCode: '' }; }
+    }
+
     // Field 7: documentMessage
     if (!msgResult && f[7] && Buffer.isBuffer(f[7])) {
       try {
@@ -757,6 +807,7 @@ module.exports = {
   encodePollCreationMessage,
   encodeLocationMessage,
   encodeContactMessage,
+  encodeGroupInviteMessage,
   encodeMessageKey,
   encodeMessage,
   encodeDeviceSentMessage,
@@ -766,6 +817,8 @@ module.exports = {
   encodeSenderKeyDistributionMessage,
   encodeMessageContextInfo,
   encodeVarint,
+  // The generic field walker, for the protobufs that live outside this file.
+  decodeFields: _decodeFields,
   field,
   varint,
   str,
@@ -774,5 +827,7 @@ module.exports = {
   WIRE_LEN,
   PROTOCOL_MSG_REVOKE,
   PROTOCOL_MSG_EPHEMERAL,
+  GROUP_INVITE_TYPE_DEFAULT,
+  GROUP_INVITE_TYPE_PARENT,
   decodeMessageContainer
 };

package/package.json

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