whalibmob 5.1.3 → 5.1.5

package/cli.js

@@ -160,15 +160,45 @@ function attachEvents(client) {
     _rl && _rl.pause();
     out('');
     hr();
-    kv('time',    ts());
-    kv('from',    msg.from);
+    kv('time',   ts());
+    kv('from',   msg.from);
     if (msg.participant && msg.participant !== msg.from) kv('sender', msg.participant);
-    kv('id',      msg.id);
-    if (msg.text) kv('text', msg.text);
-    if (msg.plaintext) {
-      const t = msg.plaintext.toString('utf8').replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
-      if (t.trim()) kv('content', t.substring(0, 400));
+    kv('id',     msg.id);
+
+    const d = msg.decoded;
+    if (d) {
+      switch (d.type) {
+        case 'text':
+          kv('text', d.text);
+          break;
+        case 'image':
+          kv('type', 'image' + (d.caption ? '  caption: ' + d.caption : ''));
+          break;
+        case 'video':
+          kv('type', 'video' + (d.caption ? '  caption: ' + d.caption : ''));
+          break;
+        case 'audio':
+          kv('type', 'audio');
+          break;
+        case 'voice':
+          kv('type', 'voice note');
+          break;
+        case 'document':
+          kv('type', 'document  file: ' + d.fileName);
+          break;
+        case 'sticker':
+          kv('type', 'sticker');
+          break;
+        case 'reaction':
+          kv('type', 'reaction  emoji: ' + d.emoji);
+          break;
+        default:
+          if (msg.text) kv('text', msg.text);
+      }
+    } else if (msg.text) {
+      kv('text', msg.text);
     }
+
     out('');
     _rl && (_rl.resume(), _rl.prompt(true));
   });

package/lib/Client.js

@@ -445,10 +445,10 @@ class WhalibmobClient extends EventEmitter {
 
   _handleMessage(node) {
     const attrs = node.attrs || {};
-    const from  = attrs.from  || '';
-    const id    = attrs.id    || '';
+    const from  = String(attrs.from  || '');
+    const id    = String(attrs.id    || '');
     const ts    = parseInt(attrs.t || '0', 10);
-    const participant = attrs.participant || from;
+    const participant = String(attrs.participant || from);
 
     // Group: sender is the group JID, participant is the actual sender
     const isGroup = from.endsWith('@g.us');
@@ -492,11 +492,13 @@ class WhalibmobClient extends EventEmitter {
     }
 
     if (skmsgNode && isGroup) {
+      this._sendMessageAck(id, from, participant);
       this._decryptGroupMessage({ node, from, participant, id, ts, skmsgNode });
       return;
     }
 
     if (dmEncNode && this._signal) {
+      this._sendMessageAck(id, from, participant);
       this._decryptDMMessage({ node, from, id, ts, dmEncNode });
       return;
     }
@@ -509,6 +511,7 @@ class WhalibmobClient extends EventEmitter {
         : (bodyNode.content || null)
     ) : null;
 
+    this._sendMessageAck(id, from, participant);
     this.emit('message', { id, from, participant, ts, text, node });
     this._sendReadReceipt(id, from, participant);
   }
@@ -521,11 +524,18 @@ class WhalibmobClient extends EventEmitter {
 
     this._signal.decrypt(from, encType, cipherBuf)
       .then(plaintext => {
-        this.emit('message', { id, from, participant: from, ts, plaintext, node });
+        const decoded = this._decodeMsg(plaintext);
+        if (decoded.type === 'senderKeyDistribution') return;
+        if (decoded.type === 'protocol') return;
+        this.emit('message', { id, from, participant: from, ts, decoded, node });
         this._sendReadReceipt(id, from, from);
       })
       .catch(err => {
         this.emit('decrypt_error', { id, from, err });
+        // Delete the stale session so WhatsApp re-establishes it fresh via pkmsg on retry
+        if (this._signal && this._signal.deleteSession) {
+          this._signal.deleteSession(from).catch(() => {});
+        }
         this._sendRetryRequest(id, from, node);
       });
   }
@@ -537,13 +547,25 @@ class WhalibmobClient extends EventEmitter {
 
     try {
       const plaintext = this._signal.senderKeyDecrypt(from, participant, cipherBuf);
-      this.emit('message', { id, from, participant, ts, plaintext, isGroup: true, node });
+      const decoded   = this._decodeMsg(plaintext);
+      if (decoded.type === 'senderKeyDistribution') return;
+      if (decoded.type === 'protocol') return;
+      this.emit('message', { id, from, participant, ts, decoded, isGroup: true, node });
       this._sendReadReceipt(id, from, participant);
     } catch (err) {
       this.emit('decrypt_error', { id, from, participant, err });
     }
   }
 
+  _decodeMsg(buf) {
+    try {
+      const { decodeMessageContainer } = require('./proto/MessageProto');
+      return decodeMessageContainer(buf);
+    } catch (_) {
+      return { type: 'unknown' };
+    }
+  }
+
   // Process SKDM messages in participants node
   _processSKDMDistribution(groupJid, senderJid, participantsNode) {
     // For incoming group messages, the SKDM for us is in the participants node
@@ -603,6 +625,19 @@ class WhalibmobClient extends EventEmitter {
     }
   }
 
+  // Delivery ack — sent immediately on message receipt.
+  // Mirrors Cobalt's sendAck(messageNode) call.
+  // Signals the server that the message was delivered → gives sender 2 grey checkmarks.
+  _sendMessageAck(msgId, from, participant) {
+    if (!this._socket || !this._connected) return;
+    const attrs = { id: msgId, class: 'message', to: from };
+    if (participant && participant !== from) attrs.participant = participant;
+    this._socket.sendNode(new BinaryNode('ack', attrs, null));
+  }
+
+  // Read receipt — sent after decryption succeeds.
+  // Mirrors Cobalt's sendMessageReceipt(info, "read") call.
+  // Gives sender 2 blue checkmarks.
   _sendReadReceipt(msgId, from, participant) {
     if (!this._socket || !this._connected) return;
     const node = new BinaryNode('receipt', {

package/lib/proto/MessageProto.js

@@ -234,6 +234,158 @@ function encodeExtendedText(text) {
   return field(1, WIRE_LEN, str(text));
 }
 
+// ─── Protobuf decoder ─────────────────────────────────────────────────────────
+// Decodes the raw bytes that come out of Signal decryption into a structured
+// message object — mirrors what Cobalt does with MessageContainerSpec.decode()
+// + .unbox().
+
+function _readVarint(buf, offset) {
+  let result = 0, shift = 0;
+  while (offset < buf.length) {
+    const b = buf[offset++];
+    result += (b & 0x7f) * Math.pow(2, shift);
+    shift += 7;
+    if (!(b & 0x80)) break;
+  }
+  return { value: result, offset };
+}
+
+function _decodeFields(buf) {
+  const fields = {};
+  let offset = 0;
+  while (offset < buf.length) {
+    if (offset >= buf.length) break;
+    const tr = _readVarint(buf, offset);
+    offset = tr.offset;
+    const fieldNum  = tr.value >> 3;
+    const wireType  = tr.value & 0x7;
+    if (wireType === 0) {
+      const vr = _readVarint(buf, offset);
+      fields[fieldNum] = (fields[fieldNum] !== undefined)
+        ? [].concat(fields[fieldNum], vr.value)
+        : vr.value;
+      offset = vr.offset;
+    } else if (wireType === 2) {
+      const lr = _readVarint(buf, offset);
+      offset = lr.offset;
+      const data = buf.slice(offset, offset + lr.value);
+      offset += lr.value;
+      if (fields[fieldNum] !== undefined) {
+        if (!Array.isArray(fields[fieldNum])) fields[fieldNum] = [fields[fieldNum]];
+        fields[fieldNum].push(data);
+      } else {
+        fields[fieldNum] = data;
+      }
+    } else if (wireType === 1) {
+      offset += 8;
+    } else if (wireType === 5) {
+      offset += 4;
+    } else {
+      break;
+    }
+  }
+  return fields;
+}
+
+function _str(buf) {
+  if (!buf) return '';
+  try { return buf.toString('utf8'); } catch (_) { return ''; }
+}
+
+function decodeMessageContainer(buf) {
+  if (!buf || buf.length === 0) return { type: 'unknown' };
+  try {
+    const f = _decodeFields(buf);
+
+    // Field 31: deviceSentMessage — wraps the real message at field 2
+    // (sent to our own linked devices). Unwrap and re-decode.
+    if (f[31]) {
+      const dsm = _decodeFields(f[31]);
+      if (dsm[2]) return decodeMessageContainer(dsm[2]);
+    }
+
+    // Field 35: senderKeyDistributionMessage — used to set up group keys
+    if (f[35]) {
+      const skdm = _decodeFields(f[35]);
+      return { type: 'senderKeyDistribution', groupId: _str(skdm[1]), raw: f[35] };
+    }
+
+    // Field 1: conversation — plain text
+    if (f[1] && Buffer.isBuffer(f[1])) {
+      const text = _str(f[1]);
+      if (text) return { type: 'text', text };
+    }
+
+    // Field 2: extendedTextMessage — field 1 = text, field 17 = contextInfo
+    if (f[2] && Buffer.isBuffer(f[2])) {
+      try {
+        const ext = _decodeFields(f[2]);
+        const text = _str(ext[1]);
+        if (text) return { type: 'text', text };
+      } catch (_) {}
+    }
+
+    // Field 3: imageMessage — field 3 = caption
+    if (f[3] && Buffer.isBuffer(f[3])) {
+      try {
+        const img = _decodeFields(f[3]);
+        return { type: 'image', caption: _str(img[3]) };
+      } catch (_) { return { type: 'image', caption: '' }; }
+    }
+
+    // Field 7: documentMessage — field 8 = fileName, field 3 = title
+    if (f[7] && Buffer.isBuffer(f[7])) {
+      try {
+        const doc = _decodeFields(f[7]);
+        return { type: 'document', fileName: _str(doc[8]) || _str(doc[3]) || 'document' };
+      } catch (_) { return { type: 'document', fileName: 'document' }; }
+    }
+
+    // Field 8: audioMessage — field 6 = ptt (bool)
+    if (f[8] && Buffer.isBuffer(f[8])) {
+      try {
+        const aud = _decodeFields(f[8]);
+        return { type: aud[6] ? 'voice' : 'audio' };
+      } catch (_) { return { type: 'audio' }; }
+    }
+
+    // Field 9: videoMessage — field 7 = caption
+    if (f[9] && Buffer.isBuffer(f[9])) {
+      try {
+        const vid = _decodeFields(f[9]);
+        return { type: 'video', caption: _str(vid[7]) };
+      } catch (_) { return { type: 'video', caption: '' }; }
+    }
+
+    // Field 12: protocolMessage (delete, ephemeral setting, etc.)
+    if (f[12] && Buffer.isBuffer(f[12])) {
+      try {
+        const pm = _decodeFields(f[12]);
+        const pmType = pm[2];
+        const typeNames = { 0: 'revoke', 3: 'ephemeral', 10: 'app_state_sync' };
+        return { type: 'protocol', subtype: typeNames[pmType] || String(pmType) };
+      } catch (_) { return { type: 'protocol', subtype: 'unknown' }; }
+    }
+
+    // Field 26: stickerMessage
+    if (f[26] && Buffer.isBuffer(f[26])) {
+      return { type: 'sticker' };
+    }
+
+    // Field 46: reactionMessage — field 1 = key, field 2 = emoji
+    if (f[46] && Buffer.isBuffer(f[46])) {
+      try {
+        const react = _decodeFields(f[46]);
+        return { type: 'reaction', emoji: _str(react[2]) };
+      } catch (_) { return { type: 'reaction', emoji: '' }; }
+    }
+
+    return { type: 'unknown' };
+  } catch (_) {
+    return { type: 'unknown' };
+  }
+}
+
 module.exports = {
   encodeText,
   encodeImageMessage,
@@ -256,5 +408,6 @@ module.exports = {
   WIRE_VARINT,
   WIRE_LEN,
   PROTOCOL_MSG_REVOKE,
-  PROTOCOL_MSG_EPHEMERAL
+  PROTOCOL_MSG_EPHEMERAL,
+  decodeMessageContainer
 };

package/lib/signal/SignalProtocol.js

@@ -157,6 +157,11 @@ class SignalProtocol {
     return this.store.hasSession(addr.toString());
   }
 
+  async deleteSession(jid) {
+    const addr = jidToAddress(jid);
+    await this.store.deleteSession(addr.toString());
+  }
+
   async buildSessionFromBundle(jid, bundle) {
     const addr    = jidToAddress(jid);
     const builder = new SessionBuilder(this.store, addr);

package/lib/signal/SignalStore.js

@@ -144,6 +144,11 @@ class SignalStore {
     this._save();
   }
 
+  async deleteSession(encodedAddress) {
+    delete this._sessions[encodedAddress];
+    this._save();
+  }
+
   hasSession(encodedAddress) {
     return !!this._sessions[encodedAddress];
   }

package/lib/signal/libsignal/session_cipher.js

@@ -154,10 +154,6 @@ class SessionCipher {
                 errs.push(e);
             }
         }
-        console.error("Failed to decrypt message with any known session...");
-        for (const e of errs) {
-            console.error("Session error:" + e, e.stack);
-        }
         throw new errors.SessionError("No matching sessions found for message");
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.1.3",
+  "version": "5.1.5",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "main": "index.js",
   "bin": {