whalibmob 5.5.84 → 5.5.86

package/README.md

@@ -157,6 +157,7 @@ npm install -g whalibmob
     - [Quoted Reply](#quoted-reply)
     - [Location Message](#location-message)
     - [Contact Message (vCard)](#contact-message-vcard)
+    - [Call Link](#call-link)
     - [Media Messages](#media-messages)
       - [Image Message](#image-message)
       - [Video Message](#video-message)
@@ -1137,6 +1138,7 @@ const { id, encKey } = await client.sendPoll(
   1            // voters may pick 1 option (0 = unlimited)
 )
 // encKey (32-byte Buffer) is needed to decrypt incoming poll votes
+// (also returned as `messageSecret`, which is the name the protocol uses)
 ```
 
 ### Quoted Reply
@@ -1181,6 +1183,12 @@ await client.sendLocation('919634847671@s.whatsapp.net', 48.8566, 2.3522, {
 await client.sendLocation('120363000000000000@g.us', 51.5074, -0.1278, {
   name: 'London'
 })
+
+// with a map image for the bubble — WhatsApp draws a blank card without one
+await client.sendLocation('919634847671@s.whatsapp.net', 48.8566, 2.3522, {
+  name: 'Eiffel Tower',
+  thumbnail: jpegBuffer
+})
 ```
 
 ### Contact Message (vCard)
@@ -1200,8 +1208,37 @@ const vcard = [
 await client.sendContact('919634847671@s.whatsapp.net', 'Alice Smith', vcard)
 ```
 
+### Call Link
+
+Ask WhatsApp for a link that lets someone join a call by tapping it, instead of
+being rung. Returns the token, the shareable link and the media type.
+
+```js
+const { link } = await client.createCallLink('video')
+// https://call.whatsapp.com/video/XXXXXXXX
+
+// audio is the default
+const audio = await client.createCallLink()
+
+// schedule it — startTime is seconds since the epoch
+await client.createCallLink('video', { startTime: 1800000000 })
+
+// create it and send it in one step
+await client.sendCallLink('919634847671@s.whatsapp.net', 'video', {
+  text: 'Join me here:'
+})
+```
+
 ## Media Messages
 
+Photos and videos are sent with an inline preview so they show up in the chat
+directly, rather than as a placeholder the recipient has to tap. The dimensions
+are read out of the file header with no dependency at all. The preview itself
+uses `jimp` (installed automatically as an optional dependency) or `sharp` if
+you have it; failing both, a photo that carries an EXIF thumbnail still gets
+one. Video previews need `ffmpeg` on PATH — on Termux, `pkg install ffmpeg`.
+Without any of these the media still sends, just without the preview.
+
 ### Image Message
 
 ```js

package/lib/Client.js

@@ -30,6 +30,10 @@ const {
   HistorySyncType
 } = require('./HistorySyncHandler');
 
+// The two prefixes a call-link token is wrapped in, as WhatsApp Web uses them.
+const CALL_AUDIO_PREFIX = 'https://call.whatsapp.com/voice/';
+const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';
+
 // whatsmeow's InviteLinkPrefix — the one prefix group invite codes are wrapped in.
 const INVITE_LINK_PREFIX = 'https://chat.whatsapp.com/';
 
@@ -1392,6 +1396,20 @@ class WhalibmobClient extends EventEmitter {
 
   _handleCall(node) {
     const attrs = node.attrs || {};
+
+    // A <call> can also be the answer to something we asked for — creating a
+    // call link, for one. Those come back on the same tag with the id we sent,
+    // so they have to be handed to the waiting caller and not treated as an
+    // incoming call to reject.
+    if (attrs.id) {
+      const handler = this._pendingIqs.get(attrs.id);
+      if (handler) {
+        this._pendingIqs.delete(attrs.id);
+        handler(node);
+        return;
+      }
+    }
+
     this.emit('call', { from: attrs.from || '', node });
     // Reject call automatically
     if (this._socket && this._connected) {
@@ -3264,6 +3282,56 @@ class WhalibmobClient extends EventEmitter {
     return this._chatStates[key];
   }
 
+  // ──────────────────────────────────────────────────────────────────────────
+  // CALL LINKS
+  // ──────────────────────────────────────────────────────────────────────────
+
+  // Ask the server for a call link that can be shared in a chat, so the other
+  // side joins by tapping it instead of being rung.
+  //
+  //   type  'audio' (default) or 'video'
+  //   opts  { startTime } — seconds since the epoch, to schedule the call
+  //
+  // Returns { token, link, type }. The stanza is the one WhatsApp Web sends:
+  // <call to="@call"><link_create media="..."/></call>, answered with the token
+  // on a link_create of its own.
+  async createCallLink(type, opts) {
+    opts = opts || {};
+    const media = type === 'video' ? 'video' : 'audio';
+    const id    = this._genMsgId();
+    const children = opts.startTime
+      ? [new BinaryNode('event', { start_time: String(opts.startTime) }, null)]
+      : null;
+
+    const resp = await this._sendIq(new BinaryNode('call', { id, to: '@call' }, [
+      new BinaryNode('link_create', { media }, children)
+    ]));
+
+    if (!resp) throw new Error('createCallLink: no reply from server (timed out)');
+    if (resp.attrs && resp.attrs.type === 'error') {
+      const errNode = findChild(resp, 'error');
+      const code    = errNode && errNode.attrs && errNode.attrs.code;
+      throw new Error('createCallLink: server rejected the request' +
+        (code ? ' (' + code + ')' : ''));
+    }
+    const created = findChild(resp, 'link_create');
+    const token   = created && created.attrs && created.attrs.token;
+    if (!token) throw new Error('createCallLink: server reply carried no token');
+
+    const prefix = media === 'video' ? CALL_VIDEO_PREFIX : CALL_AUDIO_PREFIX;
+    return { token: String(token), link: prefix + token, type: media };
+  }
+
+  // Create a call link and send it as a message in one step.
+  // Returns the send result with the link attached.
+  async sendCallLink(to, type, opts) {
+    opts = opts || {};
+    const { link } = await this.createCallLink(type, opts);
+    const text = opts.text ? (opts.text + ' ' + link) : link;
+    const res  = await this.sendText(to, text, opts);
+    return Object.assign({}, res, { link });
+  }
+
   // ──────────────────────────────────────────────────────────────────────────
   // GROUP OPERATIONS
   // ──────────────────────────────────────────────────────────────────────────

package/lib/MediaThumbnail.js

@@ -0,0 +1,394 @@
+'use strict';
+
+// ─── Media probing and inline thumbnails ─────────────────────────────────────
+//
+// WhatsApp renders a photo or video inline in the chat from the small JPEG
+// carried in the message itself (ImageMessage.jpegThumbnail, field 16) together
+// with the width and height. A message that arrives without them cannot be
+// drawn, so the recipient gets the grey placeholder with a download arrow and
+// has to tap it before seeing anything.
+//
+// Baileys builds that preview by resizing the source to 32 pixels wide at JPEG
+// quality 50, and takes the original dimensions from the same decode. This does
+// the same, with the difference that none of it is mandatory:
+//
+//   • Dimensions are read straight out of the file header — JPEG, PNG, WebP,
+//     GIF and BMP — with no library at all.
+//   • The thumbnail is made with sharp or jimp when either is installed. When
+//     neither is, a JPEG that carries an EXIF thumbnail (which is to say, most
+//     photos taken on a phone) still yields one, again with no library.
+//   • Video frames need ffmpeg. Without it the video still sends, just without
+//     an inline preview.
+//
+// Nothing here throws: every entry point resolves to whatever it managed to
+// work out, so a missing library degrades the preview and never the send.
+
+const { dbg: _whaDbg } = require('./logger');
+
+const fs   = require('fs');
+const os   = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+
+// Baileys' numbers — the preview is deliberately tiny, it is only ever shown
+// blurred behind the real image while that downloads.
+const THUMB_WIDTH   = 32;
+const THUMB_QUALITY = 50;
+
+// An EXIF thumbnail is usually ~160x120 and a few KB. Anything much larger is
+// not a thumbnail worth embedding in every copy of an E2EE message.
+const MAX_EXIF_THUMB = 12 * 1024;
+
+const EXEC_TIMEOUT_MS = 20000;
+
+// ─── Dimensions from the file header ─────────────────────────────────────────
+
+function probeImageSize(buf) {
+  // Only enough to tell the formats apart; each branch below checks that the
+  // bytes it actually reads are there. A single large minimum would reject
+  // small-but-valid files.
+  if (!Buffer.isBuffer(buf) || buf.length < 12) return null;
+
+  // PNG — 8-byte signature, then IHDR with width/height as big-endian uint32.
+  if (buf.readUInt32BE(0) === 0x89504e47 && buf.readUInt32BE(4) === 0x0d0a1a0a) {
+    if (buf.length < 24) return null;
+    return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+  }
+
+  // GIF — "GIF87a"/"GIF89a", then the logical screen descriptor, little-endian.
+  if (buf.slice(0, 3).toString('latin1') === 'GIF') {
+    if (buf.length < 10) return null;
+    return { width: buf.readUInt16LE(6), height: buf.readUInt16LE(8) };
+  }
+
+  // BMP
+  if (buf[0] === 0x42 && buf[1] === 0x4d && buf.length >= 26) {
+    return { width: buf.readInt32LE(18), height: Math.abs(buf.readInt32LE(22)) };
+  }
+
+  // WebP — RIFF container, three different chunk layouts.
+  if (buf.slice(0, 4).toString('latin1') === 'RIFF' &&
+      buf.slice(8, 12).toString('latin1') === 'WEBP') {
+    const chunk = buf.slice(12, 16).toString('latin1');
+    if (chunk === 'VP8 ' && buf.length >= 30) {
+      // Lossy: 14-bit dimensions in the keyframe header.
+      return {
+        width:  buf.readUInt16LE(26) & 0x3fff,
+        height: buf.readUInt16LE(28) & 0x3fff
+      };
+    }
+    if (chunk === 'VP8L' && buf.length >= 25) {
+      // Lossless: 14 bits of (width-1) then 14 bits of (height-1), packed.
+      const b = buf.readUInt32LE(21);
+      return {
+        width:  (b & 0x3fff) + 1,
+        height: ((b >> 14) & 0x3fff) + 1
+      };
+    }
+    if (chunk === 'VP8X' && buf.length >= 30) {
+      // Extended: 24-bit (width-1) and (height-1), little-endian.
+      const w = buf[24] | (buf[25] << 8) | (buf[26] << 16);
+      const h = buf[27] | (buf[28] << 8) | (buf[29] << 16);
+      return { width: w + 1, height: h + 1 };
+    }
+    return null;
+  }
+
+  // JPEG — walk the marker chain to the start-of-frame, which holds the size.
+  if (buf[0] === 0xff && buf[1] === 0xd8) {
+    let off = 2;
+    while (off + 8 < buf.length) {
+      if (buf[off] !== 0xff) { off++; continue; }         // resync on padding
+      const marker = buf[off + 1];
+      if (marker === 0xd8 || marker === 0x01 ||
+          (marker >= 0xd0 && marker <= 0xd7)) { off += 2; continue; }
+      if (marker === 0xd9 || marker === 0xda) break;      // end / scan data
+      const len = buf.readUInt16BE(off + 2);
+      if (len < 2) break;
+      // SOF0..SOF15, minus DHT (c4), JPG (c8) and DAC (cc) which share the range
+      const isSOF = marker >= 0xc0 && marker <= 0xcf &&
+                    marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc;
+      if (isSOF) {
+        return { height: buf.readUInt16BE(off + 5), width: buf.readUInt16BE(off + 7) };
+      }
+      off += 2 + len;
+    }
+  }
+
+  return null;
+}
+
+// ─── EXIF thumbnail, straight out of a JPEG ──────────────────────────────────
+//
+// Phone cameras embed a small JPEG preview in the APP1/EXIF segment, in the
+// second IFD. Tag 0x0201 is its offset from the start of the TIFF header and
+// 0x0202 its length. Pulling that out gives a usable inline preview on a
+// machine with no image library installed at all.
+
+function extractExifThumbnail(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 4) return null;
+  if (buf[0] !== 0xff || buf[1] !== 0xd8) return null;
+
+  // Find the APP1 segment that starts with "Exif\0\0".
+  let off = 2, tiff = -1, app1End = -1;
+  while (off + 4 < buf.length) {
+    if (buf[off] !== 0xff) { off++; continue; }
+    const marker = buf[off + 1];
+    if (marker === 0xd9 || marker === 0xda) break;
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) { off += 2; continue; }
+    const len = buf.readUInt16BE(off + 2);
+    if (len < 2) break;
+    if (marker === 0xe1 && off + 10 < buf.length &&
+        buf.slice(off + 4, off + 10).toString('latin1') === 'Exif\0\0') {
+      tiff    = off + 10;
+      app1End = off + 2 + len;
+      break;
+    }
+    off += 2 + len;
+  }
+  if (tiff < 0 || tiff + 8 > buf.length) return null;
+
+  const bom = buf.slice(tiff, tiff + 2).toString('latin1');
+  if (bom !== 'II' && bom !== 'MM') return null;
+  const le  = bom === 'II';
+  const u16 = (o) => le ? buf.readUInt16LE(o) : buf.readUInt16BE(o);
+  const u32 = (o) => le ? buf.readUInt32LE(o) : buf.readUInt32BE(o);
+
+  if (u16(tiff + 2) !== 42) return null;
+
+  // IFD0, then hop to IFD1 — the thumbnail lives in the second one.
+  const ifd0 = tiff + u32(tiff + 4);
+  if (ifd0 + 2 > buf.length) return null;
+  const count0 = u16(ifd0);
+  const nextPtr = ifd0 + 2 + count0 * 12;
+  if (nextPtr + 4 > buf.length) return null;
+  const ifd1Off = u32(nextPtr);
+  if (!ifd1Off) return null;
+  const ifd1 = tiff + ifd1Off;
+  if (ifd1 + 2 > buf.length) return null;
+
+  const count1 = u16(ifd1);
+  let thumbOff = 0, thumbLen = 0;
+  for (let i = 0; i < count1; i++) {
+    const e = ifd1 + 2 + i * 12;
+    if (e + 12 > buf.length) break;
+    const tag = u16(e);
+    if (tag === 0x0201) thumbOff = u32(e + 8);
+    else if (tag === 0x0202) thumbLen = u32(e + 8);
+  }
+  if (!thumbOff || !thumbLen || thumbLen > MAX_EXIF_THUMB) return null;
+
+  const start = tiff + thumbOff;
+  const end   = start + thumbLen;
+  if (end > buf.length || (app1End > 0 && end > app1End)) return null;
+
+  const thumb = buf.slice(start, end);
+  // Must actually be a JPEG, or WhatsApp will render nothing.
+  if (thumb.length < 4 || thumb[0] !== 0xff || thumb[1] !== 0xd8) return null;
+  return Buffer.from(thumb);
+}
+
+// ─── Optional image library ──────────────────────────────────────────────────
+
+let _imageLib;   // undefined = not looked for yet, null = none available
+
+async function loadImageLib() {
+  if (_imageLib !== undefined) return _imageLib;
+  _imageLib = null;
+
+  try {
+    const sharp = require('sharp');
+    _imageLib = { kind: 'sharp', sharp };
+    _whaDbg('[DBG] THUMB using sharp');
+    return _imageLib;
+  } catch (_) {}
+
+  // jimp 1.x is ESM-only, 0.x is CommonJS — accept either.
+  try {
+    const mod = await import('jimp');
+    const jimp = mod.default && mod.default.Jimp ? mod.default : mod;
+    if (jimp && jimp.Jimp) {
+      _imageLib = { kind: 'jimp1', Jimp: jimp.Jimp, ResizeStrategy: jimp.ResizeStrategy };
+      _whaDbg('[DBG] THUMB using jimp (v1)');
+      return _imageLib;
+    }
+    const legacy = mod.default || mod;
+    if (legacy && typeof legacy.read === 'function') {
+      _imageLib = { kind: 'jimp0', Jimp: legacy };
+      _whaDbg('[DBG] THUMB using jimp (v0)');
+      return _imageLib;
+    }
+  } catch (_) {}
+
+  _whaDbg('[DBG] THUMB no image library — install jimp for inline previews ' +
+    'on images an EXIF thumbnail cannot cover');
+  return _imageLib;
+}
+
+// ─── Image: dimensions + inline preview ──────────────────────────────────────
+//
+// Returns { width, height, thumbnail } with whatever could be worked out; any
+// field may be missing. Never rejects.
+
+async function imageThumbnail(buf, opts) {
+  opts = opts || {};
+  const out = {};
+  if (!Buffer.isBuffer(buf) || buf.length === 0) return out;
+
+  const size = probeImageSize(buf);
+  if (size && size.width > 0 && size.height > 0) {
+    out.width  = size.width;
+    out.height = size.height;
+  }
+
+  const width   = opts.width   || THUMB_WIDTH;
+  const quality = opts.quality || THUMB_QUALITY;
+
+  try {
+    const lib = await loadImageLib();
+    if (lib && lib.kind === 'sharp') {
+      const img  = lib.sharp(buf);
+      const meta = await img.metadata();
+      if (meta && meta.width && meta.height) {
+        out.width = meta.width; out.height = meta.height;
+      }
+      out.thumbnail = await lib.sharp(buf).resize(width).jpeg({ quality }).toBuffer();
+      return out;
+    }
+    if (lib && lib.kind === 'jimp1') {
+      const img = await lib.Jimp.read(buf);
+      if (img.width && img.height) { out.width = img.width; out.height = img.height; }
+      const resizeOpts = { w: width };
+      if (lib.ResizeStrategy && lib.ResizeStrategy.BILINEAR) {
+        resizeOpts.mode = lib.ResizeStrategy.BILINEAR;
+      }
+      out.thumbnail = await img.resize(resizeOpts).getBuffer('image/jpeg', { quality });
+      return out;
+    }
+    if (lib && lib.kind === 'jimp0') {
+      const Jimp = lib.Jimp;
+      const img  = await Jimp.read(buf);
+      if (img.bitmap) { out.width = img.bitmap.width; out.height = img.bitmap.height; }
+      img.resize(width, Jimp.AUTO).quality(quality);
+      out.thumbnail = await img.getBufferAsync(Jimp.MIME_JPEG);
+      return out;
+    }
+  } catch (err) {
+    _whaDbg('[DBG] THUMB image library failed: ' + (err && err.message));
+  }
+
+  // No library, or it could not read this file — fall back to whatever the
+  // camera already embedded.
+  const exif = extractExifThumbnail(buf);
+  if (exif) {
+    out.thumbnail = exif;
+    _whaDbg('[DBG] THUMB using embedded EXIF thumbnail (' + exif.length + ' bytes)');
+  } else {
+    _whaDbg('[DBG] THUMB none available — the image will show as a download ' +
+      'placeholder; install jimp to fix');
+  }
+  return out;
+}
+
+// ─── ffmpeg ──────────────────────────────────────────────────────────────────
+
+function run(cmd, args) {
+  return new Promise((resolve) => {
+    execFile(cmd, args, { timeout: EXEC_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024 },
+      (err, stdout) => resolve(err ? null : String(stdout)));
+  });
+}
+
+let _ffmpegChecked;
+async function hasFfmpeg() {
+  if (_ffmpegChecked !== undefined) return _ffmpegChecked;
+  _ffmpegChecked = (await run('ffmpeg', ['-version'])) !== null;
+  if (!_ffmpegChecked) {
+    _whaDbg('[DBG] THUMB ffmpeg not found — videos will send without an inline ' +
+      'preview (Termux: pkg install ffmpeg)');
+  }
+  return _ffmpegChecked;
+}
+
+function tmpFile(ext) {
+  return path.join(os.tmpdir(),
+    'whalibmob-' + crypto.randomBytes(8).toString('hex') + ext);
+}
+
+// ─── Video: dimensions, duration, first-frame preview ────────────────────────
+//
+// input may be a file path or a Buffer; a Buffer is spilled to a temp file
+// because ffmpeg needs to seek. Returns { width, height, seconds, thumbnail }
+// with whatever could be worked out. Never rejects.
+
+async function videoThumbnail(input, opts) {
+  opts = opts || {};
+  const out = {};
+  if (!(await hasFfmpeg())) return out;
+
+  let src = null, spilled = null;
+  try {
+    if (Buffer.isBuffer(input)) {
+      spilled = tmpFile('.mp4');
+      fs.writeFileSync(spilled, input);
+      src = spilled;
+    } else if (typeof input === 'string' && fs.existsSync(input)) {
+      src = input;
+    }
+    if (!src) return out;
+
+    // ffprobe ships with ffmpeg; when it is missing the frame grab below still
+    // works, the message just goes out without dimensions.
+    const probe = await run('ffprobe', [
+      '-v', 'error',
+      '-select_streams', 'v:0',
+      '-show_entries', 'stream=width,height:format=duration',
+      '-of', 'json', src
+    ]);
+    if (probe) {
+      try {
+        const j  = JSON.parse(probe);
+        const st = j.streams && j.streams[0];
+        if (st && st.width && st.height) {
+          out.width = Number(st.width); out.height = Number(st.height);
+        }
+        const dur = j.format && parseFloat(j.format.duration);
+        if (Number.isFinite(dur) && dur > 0) out.seconds = Math.round(dur);
+      } catch (_) {}
+    }
+
+    // Same frame grab Baileys runs: first frame, scaled to the preview width
+    // with the aspect ratio kept.
+    const dest = tmpFile('.jpg');
+    try {
+      const ok = await run('ffmpeg', [
+        '-ss', '00:00:00', '-i', src, '-y',
+        '-vf', 'scale=' + (opts.width || THUMB_WIDTH) + ':-1',
+        '-vframes', '1', '-f', 'image2', dest
+      ]);
+      if (ok !== null && fs.existsSync(dest)) {
+        const thumb = fs.readFileSync(dest);
+        if (thumb.length > 0) out.thumbnail = thumb;
+      }
+    } finally {
+      try { fs.unlinkSync(dest); } catch (_) {}
+    }
+  } catch (err) {
+    _whaDbg('[DBG] THUMB video failed: ' + (err && err.message));
+  } finally {
+    if (spilled) { try { fs.unlinkSync(spilled); } catch (_) {} }
+  }
+
+  return out;
+}
+
+module.exports = {
+  probeImageSize,
+  extractExifThumbnail,
+  imageThumbnail,
+  videoThumbnail,
+  hasFfmpeg,
+  THUMB_WIDTH,
+  THUMB_QUALITY
+};

package/lib/messages/MessageSender.js

@@ -18,9 +18,11 @@ const {
   encodeDeviceSentMessage, encodeProtocolMessage,
   encodeExtendedText,
   encodeSenderKeyDistributionMessage,
+  encodeMessageContextInfo,
   PROTOCOL_MSG_REVOKE, PROTOCOL_MSG_EPHEMERAL
 } = require('../proto/MessageProto');
 const { uploadMedia } = require('../MediaService');
+const { imageThumbnail, videoThumbnail, probeImageSize } = require('../MediaThumbnail');
 const { tcTokenExpired, shouldSendNewTcToken, normalizeJidForTcToken } = require('./TcTokenStore');
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
@@ -255,20 +257,32 @@ class MessageSender {
     const msgId  = options.id || generateMessageId();
     const toJid  = makeJid(to);
     const cdn    = options._cdnForward;
-    const upload = cdn ? cdn : await this._uploadMedia('image', imageData);
+    // The inline preview and the dimensions come from the same pass over the
+    // source bytes. Without them WhatsApp has nothing to draw and shows the
+    // grey download placeholder instead of the photo.
+    let upload, meta = {};
+    if (cdn) {
+      upload = cdn;
+    } else {
+      const buf = this._toMediaBuffer(imageData);
+      [upload, meta] = await Promise.all([
+        this._uploadMedia('image', buf),
+        imageThumbnail(buf).catch(() => ({}))
+      ]);
+    }
     const imgBuf = encodeMessage('image', encodeImageMessage({
       url:               upload.url,
       mimetype:          options.mimetype || upload.mimetype || guessMime(imageData, 'image/jpeg'),
       caption:           options.caption  || upload.caption || '',
       fileSha256:        upload.fileSha256,
       fileLength:        upload.fileLength || 0,
-      height:            options.height   || upload.height || 0,
-      width:             options.width    || upload.width  || 0,
+      height:            options.height   || upload.height || meta.height || 0,
+      width:             options.width    || upload.width  || meta.width  || 0,
       mediaKey:          upload.mediaKey,
       fileEncSha256:     upload.fileEncSha256,
       directPath:        upload.directPath,
       mediaKeyTimestamp: upload.mediaKeyTimestamp || Math.floor(Date.now() / 1000),
-      jpegThumbnail:     options.thumbnail || null,
+      jpegThumbnail:     options.thumbnail || upload.jpegThumbnail || meta.thumbnail || null,
       contextInfo:       options.contextInfo
     }));
     return this._sendMessage(toJid, msgId, imgBuf, 'media', { ...options, _mediaSubtype: 'image' });
@@ -281,25 +295,41 @@ class MessageSender {
     const msgId  = options.id || generateMessageId();
     const toJid  = makeJid(to);
     const cdn    = options._cdnForward;
-    const upload = cdn ? cdn : await this._uploadMedia('video', videoData);
+    // Same as an image, except the preview frame has to be cut by ffmpeg. When
+    // ffmpeg is not installed the video still sends — it just arrives without
+    // an inline preview.
+    let upload, meta = {};
+    if (cdn) {
+      upload = cdn;
+    } else {
+      const buf = this._toMediaBuffer(videoData);
+      [upload, meta] = await Promise.all([
+        this._uploadMedia('video', buf),
+        // ffmpeg needs to seek, so hand it the path when we have one rather
+        // than making it re-read a copy of the bytes.
+        videoThumbnail(typeof videoData === 'string' ? videoData : buf).catch(() => ({}))
+      ]);
+    }
     const vidBuf = encodeMessage('video', encodeVideoMessage({
       url:               upload.url,
       mimetype:          options.mimetype || upload.mimetype || guessMime(videoData, 'video/mp4'),
       fileSha256:        upload.fileSha256,
       fileLength:        upload.fileLength || 0,
-      seconds:           options.seconds   || upload.seconds || 0,
+      seconds:           options.seconds   || upload.seconds || meta.seconds || 0,
       mediaKey:          upload.mediaKey,
       caption:           options.caption   || upload.caption || '',
-      height:            options.height    || upload.height  || 0,
-      width:             options.width     || upload.width   || 0,
+      height:            options.height    || upload.height  || meta.height || 0,
+      width:             options.width     || upload.width   || meta.width  || 0,
       fileEncSha256:     upload.fileEncSha256,
       directPath:        upload.directPath,
       mediaKeyTimestamp: upload.mediaKeyTimestamp || Math.floor(Date.now() / 1000),
-      jpegThumbnail:     options.thumbnail  || null,
+      jpegThumbnail:     options.thumbnail  || upload.jpegThumbnail || meta.thumbnail || null,
       gifPlayback:       options.gifPlayback || false,
       contextInfo:       options.contextInfo
     }));
-    return this._sendMessage(toJid, msgId, vidBuf, 'media', { ...options, _mediaSubtype: 'video' });
+    // whatsmeow labels a video with gifPlayback as mediatype "gif", not "video".
+    return this._sendMessage(toJid, msgId, vidBuf, 'media',
+      { ...options, _mediaSubtype: options.gifPlayback ? 'gif' : 'video' });
   }
 
   // ─── Audio / PTT ──────────────────────────────────────────────────────────
@@ -346,7 +376,7 @@ class MessageSender {
       fileEncSha256:     upload.fileEncSha256,
       directPath:        upload.directPath,
       mediaKeyTimestamp: upload.mediaKeyTimestamp || Math.floor(Date.now() / 1000),
-      jpegThumbnail:     options.thumbnail || null,
+      jpegThumbnail:     options.thumbnail || upload.jpegThumbnail || null,
       contextInfo:       options.contextInfo
     }));
     return this._sendMessage(toJid, msgId, docBuf, 'media', { ...options, _mediaSubtype: 'document' });
@@ -360,14 +390,20 @@ class MessageSender {
     const toJid  = makeJid(to);
     const cdn    = options._cdnForward;
     const upload = cdn ? cdn : await this._uploadMedia('sticker', stickerData);
+    // A sticker that is not actually 512x512 was being described as if it were,
+    // which stretches it in the bubble. The WebP header says what it really is.
+    let stkSize = null;
+    if (!cdn && (!options.width || !options.height)) {
+      try { stkSize = probeImageSize(this._toMediaBuffer(stickerData)); } catch (_) {}
+    }
     const stkBuf = encodeMessage('sticker', encodeStickerMessage({
       url:               upload.url,
       fileSha256:        upload.fileSha256,
       fileEncSha256:     upload.fileEncSha256,
       mediaKey:          upload.mediaKey,
       mimetype:          options.mimetype  || upload.mimetype || 'image/webp',
-      height:            options.height    || upload.height   || 512,
-      width:             options.width     || upload.width    || 512,
+      height:            options.height    || upload.height   || (stkSize && stkSize.height) || 512,
+      width:             options.width     || upload.width    || (stkSize && stkSize.width)  || 512,
       directPath:        upload.directPath,
       fileLength:        upload.fileLength || 0,
       mediaKeyTimestamp: upload.mediaKeyTimestamp || Math.floor(Date.now() / 1000),
@@ -407,11 +443,22 @@ class MessageSender {
       question,
       options: options || [],
       selectableOptionsCount: selectableCount != null ? selectableCount : 0,
-      encKey: opts.encKey || null
+      messageSecret: opts.messageSecret || opts.encKey || null
+    });
+    // whatsmeow's BuildPollCreation pairs the poll with a messageContextInfo
+    // holding the secret. It is a sibling field of the poll inside Message, not
+    // part of the poll — a voter derives their vote key from this copy, so a
+    // poll sent without it cannot be voted on.
+    const pollBuf = Buffer.concat([
+      encodeMessage('poll', result.payload),
+      encodeMessageContextInfo({ messageSecret: result.messageSecret })
+    ]);
+    const sendResult = await this._sendMessage(toJid, msgId, pollBuf, 'poll',
+      Object.assign({}, opts, { _encKey: result.messageSecret }));
+    return Object.assign({}, sendResult, {
+      encKey: result.messageSecret,
+      messageSecret: result.messageSecret
     });
-    const pollBuf    = encodeMessage('poll', result.payload);
-    const sendResult = await this._sendMessage(toJid, msgId, pollBuf, 'poll', Object.assign({}, opts, { _encKey: result.encKey }));
-    return Object.assign({}, sendResult, { encKey: result.encKey });
   }
 
   // ─── Location ─────────────────────────────────────────────────────────────
@@ -427,9 +474,19 @@ class MessageSender {
       longitude,
       name:    opts.name    || '',
       address: opts.address || '',
-      url:     opts.url     || ''
+      url:     opts.url     || '',
+      isLive:  opts.isLive  || false,
+      accuracyInMeters: opts.accuracyInMeters,
+      // A map image for the bubble. WhatsApp draws a blank grey card without
+      // one, exactly as it does for a photo with no preview.
+      jpegThumbnail: opts.thumbnail || opts.jpegThumbnail || null,
+      contextInfo:   opts.contextInfo
     }));
-    return this._sendMessage(toJid, msgId, locBuf, 'location', opts);
+    // A location is a plain message as far as the envelope is concerned.
+    // whatsmeow's getTypeFromMessage has only text, media, reaction and poll —
+    // LocationMessage is in none of the media cases, so it falls through to
+    // text. Sending type="location" hands the server a type it has no case for.
+    return this._sendMessage(toJid, msgId, locBuf, 'text', opts);
   }
 
   // ─── Quoted Reply ─────────────────────────────────────────────────────────
@@ -455,8 +512,15 @@ class MessageSender {
     opts = opts || {};
     const msgId  = opts.id || generateMessageId();
     const toJid  = makeJid(to);
-    const conBuf = encodeMessage('contact', encodeContactMessage({ displayName, vcard }));
-    return this._sendMessage(toJid, msgId, conBuf, 'contact', opts);
+    const conBuf = encodeMessage('contact', encodeContactMessage({
+      displayName, vcard, contextInfo: opts.contextInfo
+    }));
+    // getMediaTypeFromMessage answers "vcard" for a ContactMessage, which makes
+    // getTypeFromMessage answer "media" — so the envelope is a media stanza and
+    // the enc nodes carry mediatype="vcard". type="contact" was not a type the
+    // server has a case for.
+    return this._sendMessage(toJid, msgId, conBuf, 'media',
+      Object.assign({}, opts, { _mediaSubtype: 'vcard' }));
   }
 
   // ─── Forward decoded message ───────────────────────────────────────────────
@@ -485,7 +549,10 @@ class MessageSender {
             url: d.url, directPath: d.directPath, mediaKey: d.mediaKey,
             fileSha256: d.fileSha256, fileEncSha256: d.fileEncSha256,
             fileLength: d.fileLength || 0, height: d.height || 0, width: d.width || 0,
-            mimetype: d.mimetype || 'image/jpeg', caption: d.caption || ''
+            mimetype: d.mimetype || 'image/jpeg', caption: d.caption || '',
+            // Carry the sender's preview across: a forward re-uses their upload,
+            // so there are no bytes here to build a new one from.
+            jpegThumbnail: d.jpegThumbnail || null
           }
         }));
 
@@ -497,7 +564,8 @@ class MessageSender {
             fileSha256: d.fileSha256, fileEncSha256: d.fileEncSha256,
             fileLength: d.fileLength || 0, mimetype: d.mimetype || 'video/mp4',
             caption: d.caption || '', seconds: d.seconds || 0,
-            height: d.height || 0, width: d.width || 0
+            height: d.height || 0, width: d.width || 0,
+            jpegThumbnail: d.jpegThumbnail || null
           }
         }));
 
@@ -522,7 +590,8 @@ class MessageSender {
             url: d.url, directPath: d.directPath, mediaKey: d.mediaKey,
             fileSha256: d.fileSha256, fileEncSha256: d.fileEncSha256,
             fileLength: d.fileLength || 0, mimetype: d.mimetype || 'application/octet-stream',
-            title: d.fileName || 'file', fileName: d.fileName || 'file'
+            title: d.title || d.fileName || 'file', fileName: d.fileName || 'file',
+            jpegThumbnail: d.jpegThumbnail || null
           }
         }));
 
@@ -1432,7 +1501,9 @@ class MessageSender {
       key:  { remoteJid: toJid, fromMe: !!fromMe, id: origMsgId }
     });
     const msgBuf = encodeMessage('protocol', revokePayload);
-    return this._sendMessage(toJid, msgId, msgBuf, 'protocol', { ...opts, edit: editBit });
+    // ProtocolMessage is one of the explicit "text" cases in whatsmeow's
+    // getTypeFromMessage; there is no "protocol" stanza type.
+    return this._sendMessage(toJid, msgId, msgBuf, 'text', { ...opts, edit: editBit });
   }
 
   // ─── Ephemeral timer DM ───────────────────────────────────────────────────
@@ -1447,7 +1518,7 @@ class MessageSender {
       ephemeralExpiration:  seconds
     });
     const msgBuf = encodeMessage('protocol', payload);
-    return this._sendMessage(toJid, msgId, msgBuf, 'protocol', opts);
+    return this._sendMessage(toJid, msgId, msgBuf, 'text', opts);
   }
 
   // ─── Utility: mark read, presence, receipt, ping ─────────────────────────
@@ -1482,14 +1553,19 @@ class MessageSender {
 
   // ─── Media upload ─────────────────────────────────────────────────────────
 
+  // Resolve a caller's media argument to bytes. Shared by the upload and the
+  // thumbnail pass so a file on disk is read once, not twice.
+  _toMediaBuffer(data) {
+    if (Buffer.isBuffer(data))         return data;
+    if (typeof data === 'string')      return fs.readFileSync(data);
+    throw new Error('Media must be a Buffer or file path');
+  }
+
   async _uploadMedia(mediaType, data) {
     if (this._isMediaConnExpired()) {
       await this._fetchMediaConn();
     }
-    let buf;
-    if (Buffer.isBuffer(data))         buf = data;
-    else if (typeof data === 'string') buf = fs.readFileSync(data);
-    else throw new Error('Media must be a Buffer or file path');
+    const buf = this._toMediaBuffer(data);
     // Force-refresh callback: invoked by uploadMedia when a CDN host rejects the
     // auth token mid-upload, so the retry runs with fresh credentials instead of
     // failing with "connection expired".

package/lib/proto/MessageProto.js

@@ -197,15 +197,34 @@ function encodeStickerMessage(opts) {
 //   field 2 = vote                   (PollVote — encrypted bytes)
 //   field 3 = senderTimestampMs      (int64)
 
+// ─── MessageContextInfo (field 35 of Message) ────────────────────────────────
+// MessageContextInfo { deviceListMetadata=1, deviceListMetadataVersion=2,
+//                      messageSecret=3, ... }
+//
+// The message secret is what votes on a poll are encrypted against, so a poll
+// sent without one can never be voted on.
+function encodeMessageContextInfo(opts) {
+  const parts = [];
+  if (opts.messageSecret) parts.push(field(3, WIRE_LEN, bytes(opts.messageSecret)));
+  if (parts.length === 0) return Buffer.alloc(0);
+  return field(35, WIRE_LEN, Buffer.concat(parts));
+}
+
 function encodePollOption(name) {
   return field(1, WIRE_LEN, str(name));
 }
 
+// PollCreationMessage { encKey=1, name=2, options=3, selectableOptionsCount=4 }
+//
+// The 32-byte secret was being written to encKey, inside the poll itself.
+// whatsmeow's BuildPollCreation leaves encKey unset and puts the secret in
+// Message.messageContextInfo.messageSecret instead — which is the copy a voter
+// derives their vote key from. In the wrong place it reached nobody, so the
+// poll could not be voted on.
 function encodePollCreationMessage(opts) {
-  // encKey: 32 random bytes (generate if not provided)
-  const encKey = opts.encKey || require('crypto').randomBytes(32);
+  const messageSecret = opts.messageSecret || opts.encKey ||
+    require('crypto').randomBytes(32);
   const parts = [
-    field(1, WIRE_LEN,    bytes(encKey)),
     field(2, WIRE_LEN,    str(opts.name || opts.question || '')),
   ];
   for (const opt of (opts.options || [])) {
@@ -214,12 +233,18 @@ function encodePollCreationMessage(opts) {
   if (opts.selectableOptionsCount != null) {
     parts.push(field(4, WIRE_VARINT, varint(opts.selectableOptionsCount)));
   }
-  return { payload: Buffer.concat(parts), encKey };
+  // encKey is the historical name this returned it under; kept so callers that
+  // stored it keep working.
+  return { payload: Buffer.concat(parts), messageSecret, encKey: messageSecret };
 }
 
 // ─── LocationMessage (field 5 of Message) ────────────────────────────────────
 // LocationMessage { degreesLatitude=1(double), degreesLongitude=2(double),
-//                   name=3, address=4, url=5 }
+//                   name=3, address=4, url=5, isLive=6, accuracyInMeters=7,
+//                   jpegThumbnail=16, contextInfo=17 }
+//
+// jpegThumbnail is the map image drawn in the bubble. Without it the location
+// arrives as a blank grey card, the same way a photo without a preview does.
 function encodeLocationMessage(opts) {
   const parts = [];
   if (opts.latitude  != null) parts.push(encodeDouble(1, opts.latitude));
@@ -227,16 +252,24 @@ function encodeLocationMessage(opts) {
   if (opts.name)     parts.push(field(3, WIRE_LEN, str(opts.name)));
   if (opts.address)  parts.push(field(4, WIRE_LEN, str(opts.address)));
   if (opts.url)      parts.push(field(5, WIRE_LEN, str(opts.url)));
+  if (opts.isLive)   parts.push(field(6, WIRE_VARINT, bool(true)));
+  if (opts.accuracyInMeters != null) {
+    parts.push(field(7, WIRE_VARINT, varint(opts.accuracyInMeters)));
+  }
+  if (opts.jpegThumbnail) parts.push(field(16, WIRE_LEN, bytes(opts.jpegThumbnail)));
+  if (opts.contextInfo)   parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
   return Buffer.concat(parts);
 }
 
 // ─── ContactMessage (field 4 of Message) ─────────────────────────────────────
-// ContactMessage { displayName=1, vcard=16 }
+// ContactMessage { displayName=1, vcard=16, contextInfo=17 }
 function encodeContactMessage(opts) {
-  return Buffer.concat([
+  const parts = [
     field(1,  WIRE_LEN, str(opts.displayName || opts.name || '')),
     field(16, WIRE_LEN, str(opts.vcard || ''))
-  ]);
+  ];
+  if (opts.contextInfo) parts.push(field(17, WIRE_LEN, encodeContextInfo(opts.contextInfo)));
+  return Buffer.concat(parts);
 }
 
 function encodeReactionMessage(opts) {
@@ -373,6 +406,12 @@ function _str(buf) {
   try { return buf.toString('utf8'); } catch (_) { return ''; }
 }
 
+// Varint fields come back from _decodeFields already as numbers; anything else
+// (a missing field, or bytes where a number was expected) counts as zero.
+function _num(v) {
+  return typeof v === 'number' && Number.isFinite(v) ? v : 0;
+}
+
 function _dbl(buf) {
   if (!buf || buf.length < 8) return 0;
   return buf.readDoubleLE(0);
@@ -409,6 +448,16 @@ function decodeMessageContainer(buf) {
       };
     }
 
+    // Field 35: messageContextInfo — carries the message secret a poll's votes
+    // are encrypted against. Attached to whatever message is decoded below.
+    let messageSecret = null;
+    if (f[35] && Buffer.isBuffer(f[35])) {
+      try {
+        const mci = _decodeFields(f[35]);
+        if (mci[3] && Buffer.isBuffer(mci[3])) messageSecret = mci[3];
+      } catch (_) {}
+    }
+
     // Decode the actual message payload (independent of SKDM).
     // We use a helper so we can attach skdmInfo to every result.
     let msgResult = null;
@@ -429,6 +478,13 @@ function decodeMessageContainer(buf) {
     }
 
     // Field 3: imageMessage
+    // url=1 mimetype=2 caption=3 fileSha256=4 fileLength=5 height=6 width=7
+    // mediaKey=8 fileEncSha256=9 directPath=11 jpegThumbnail=16
+    //
+    // Only a handful of these used to be kept. forwardDecodedMessage reads
+    // fileSha256, fileEncSha256, fileLength and the dimensions off this object,
+    // so a forwarded photo went out with them undefined — unverifiable for the
+    // recipient — and downloadMedia had no fileEncSha256 to check against.
     if (!msgResult && f[3] && Buffer.isBuffer(f[3])) {
       try {
         const img = _decodeFields(f[3]);
@@ -437,8 +493,14 @@ function decodeMessageContainer(buf) {
           caption: _str(img[3]),
           url: _str(img[1]),
           mimetype: _str(img[2]) || 'image/jpeg',
+          fileSha256: img[4] || null,
+          fileLength: _num(img[5]),
+          height: _num(img[6]),
+          width: _num(img[7]),
           mediaKey: img[8] || null,
+          fileEncSha256: img[9] || null,
           directPath: _str(img[11]),
+          jpegThumbnail: img[16] || null,
         };
       } catch (_) { msgResult = { type: 'image', caption: '' }; }
     }
@@ -469,14 +531,21 @@ function decodeMessageContainer(buf) {
     // Field 7: documentMessage
     if (!msgResult && f[7] && Buffer.isBuffer(f[7])) {
       try {
+        // url=1 mimetype=2 title=3 fileSha256=4 fileLength=5 mediaKey=7
+        // fileName=8 fileEncSha256=9 directPath=10 jpegThumbnail=16
         const doc = _decodeFields(f[7]);
         msgResult = {
           type: 'document',
           fileName: _str(doc[8]) || _str(doc[3]) || 'document',
+          title: _str(doc[3]),
           url: _str(doc[1]),
           mimetype: _str(doc[2]) || 'application/octet-stream',
+          fileSha256: doc[4] || null,
+          fileLength: _num(doc[5]),
           mediaKey: doc[7] || null,
+          fileEncSha256: doc[9] || null,
           directPath: _str(doc[10]),
+          jpegThumbnail: doc[16] || null,
         };
       } catch (_) { msgResult = { type: 'document', fileName: 'document' }; }
     }
@@ -484,12 +553,19 @@ function decodeMessageContainer(buf) {
     // Field 8: audioMessage
     if (!msgResult && f[8] && Buffer.isBuffer(f[8])) {
       try {
+        // url=1 mimetype=2 fileSha256=3 fileLength=4 seconds=5 ptt=6
+        // mediaKey=7 fileEncSha256=8 directPath=9
         const aud = _decodeFields(f[8]);
         msgResult = {
           type: aud[6] ? 'voice' : 'audio',
           url: _str(aud[1]),
           mimetype: _str(aud[2]) || 'audio/ogg; codecs=opus',
+          fileSha256: aud[3] || null,
+          fileLength: _num(aud[4]),
+          seconds: _num(aud[5]),
+          ptt: !!aud[6],
           mediaKey: aud[7] || null,
+          fileEncSha256: aud[8] || null,
           directPath: _str(aud[9]),
         };
       } catch (_) { msgResult = { type: 'audio' }; }
@@ -498,14 +574,25 @@ function decodeMessageContainer(buf) {
     // Field 9: videoMessage
     if (!msgResult && f[9] && Buffer.isBuffer(f[9])) {
       try {
+        // url=1 mimetype=2 fileSha256=3 fileLength=4 seconds=5 mediaKey=6
+        // caption=7 gifPlayback=8 height=9 width=10 fileEncSha256=11
+        // directPath=13 jpegThumbnail=16
         const vid = _decodeFields(f[9]);
         msgResult = {
           type: 'video',
           caption: _str(vid[7]),
           url: _str(vid[1]),
           mimetype: _str(vid[2]) || 'video/mp4',
+          fileSha256: vid[3] || null,
+          fileLength: _num(vid[4]),
+          seconds: _num(vid[5]),
           mediaKey: vid[6] || null,
+          gifPlayback: !!vid[8],
+          height: _num(vid[9]),
+          width: _num(vid[10]),
+          fileEncSha256: vid[11] || null,
           directPath: _str(vid[13]),
+          jpegThumbnail: vid[16] || null,
         };
       } catch (_) { msgResult = { type: 'video', caption: '' }; }
     }
@@ -549,13 +636,21 @@ function decodeMessageContainer(buf) {
     // Field 26: stickerMessage
     if (!msgResult && f[26] && Buffer.isBuffer(f[26])) {
       try {
+        // url=1 fileSha256=2 fileEncSha256=3 mediaKey=4 mimetype=5 height=6
+        // width=7 directPath=8 fileLength=9 isAnimated=13
         const stk = _decodeFields(f[26]);
         msgResult = {
           type: 'sticker',
           url: _str(stk[1]),
-          mimetype: _str(stk[5]) || 'image/webp',
+          fileSha256: stk[2] || null,
+          fileEncSha256: stk[3] || null,
           mediaKey: stk[4] || null,
+          mimetype: _str(stk[5]) || 'image/webp',
+          height: _num(stk[6]),
+          width: _num(stk[7]),
           directPath: _str(stk[8]),
+          fileLength: _num(stk[9]),
+          isAnimated: !!stk[13],
         };
       } catch (_) { msgResult = { type: 'sticker' }; }
     }
@@ -587,6 +682,9 @@ function decodeMessageContainer(buf) {
         }
         const selectableOptionsCount = typeof poll[4] === 'number' ? poll[4] : 0;
         msgResult = { type: 'poll', question, options, selectableOptionsCount, encKey: poll[1] || null };
+        // Real clients leave encKey unset — the secret lives in
+        // messageContextInfo, picked up above and attached below.
+        if (!msgResult.encKey && messageSecret) msgResult.encKey = messageSecret;
       } catch (_) { msgResult = { type: 'poll', question: '', options: [] }; }
     }
 
@@ -595,8 +693,9 @@ function decodeMessageContainer(buf) {
       msgResult = { type: 'pollVote' };
     }
 
-    // If we found a real message, attach skdmInfo (if any) and return
+    // If we found a real message, attach skdmInfo / messageSecret and return
     if (msgResult) {
+      if (messageSecret) msgResult = Object.assign({}, msgResult, { messageSecret });
       return skdmInfo ? Object.assign({}, msgResult, { skdm: skdmInfo }) : msgResult;
     }
 
@@ -645,6 +744,7 @@ module.exports = {
   encodeExtendedText,
   encodeContextInfo,
   encodeSenderKeyDistributionMessage,
+  encodeMessageContextInfo,
   encodeVarint,
   field,
   varint,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "whalibmob",
-  "version": "5.5.84",
+  "version": "5.5.86",
   "description": "WhatsApp library for interaction with WhatsApp Mobile API no web",
   "author": "Kunboruto50",
   "main": "index.js",
@@ -41,12 +41,15 @@
   "dependencies": {
     "@cacheable/node-cache": "^3.0.1",
     "@noble/hashes": "^1.7.2",
-"async-mutex": "^0.5.0",
+    "async-mutex": "^0.5.0",
     "axios": "^1.7.2",
     "curve25519-js": "^0.0.4",
     "dotenv": "^16.4.5",
     "pino": "^9.0.0",
     "protobufjs": "^6.11.4",
     "uuid": "^11.1.0"
+  },
+  "optionalDependencies": {
+    "jimp": "^1.6.0"
   }
 }