@manybot/manybot 5.4.1 → 5.5.1

package/dist/drivers/whatsapp/api/index.js

@@ -26,11 +26,15 @@ function denormalizeJid(jid) {
     return jid.replace(/@c\.us$/, "@s.whatsapp.net");
 }
 import { mkdirSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
+import { readFile, writeFile, unlink, mkdtemp, rm } from "fs/promises";
 import { readFileSync } from "fs";
 import path from "path";
+import os from "os";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
 import { waitForSendSlot, simulateState, typingDuration, mediaDuration } from "#sendguard";
 import { buildSettingsApi } from "#settingsdb";
+import WebP from "node-webpmux";
 import { downloadMediaMessage, getAggregateVotesInPollMessage, decryptPollVote, jidNormalizedUser, normalizeMessageContent } from "@whiskeysockets/baileys";
 // ── Message body / type helpers ───────────────────────────────────────────────
 // WhatsApp wraps media in ephemeralMessage/viewOnceMessage/etc when sent as
@@ -206,6 +210,26 @@ const MIME_MAP = {
 function mimeFromPath(filePath) {
     return MIME_MAP[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
+// ── Media source resolution (path or Buffer) ────────────────────────────────
+/**
+ * Resolves a media source to a Buffer. Every ctx.send.* / msg.reply.*
+ * media method accepts either a filesystem path (string) or an
+ * already-loaded Buffer — this is what auto-detects which one it got.
+ */
+async function resolveMediaBuffer(source) {
+    return Buffer.isBuffer(source) ? source : await readFile(source);
+}
+const GIF_MAGIC = Buffer.from("GIF8");
+/** True if the buffer's magic bytes identify it as a raw .gif image. */
+function isGifBuffer(buffer) {
+    return buffer.length >= 4 && buffer.subarray(0, 4).equals(GIF_MAGIC);
+}
+/** True if a gif() source needs ffmpeg conversion to mp4 before sending. */
+function needsGifConversion(source) {
+    return Buffer.isBuffer(source)
+        ? isGifBuffer(source)
+        : path.extname(source).toLowerCase() === ".gif";
+}
 // ── Storage API ───────────────────────────────────────────────────────────────
 export function buildStorageApi(pluginName) {
     if (typeof pluginName !== "string" || pluginName.trim() === "") {
@@ -435,7 +459,6 @@ function buildContactsApi(sock, store, botJid) {
          * Get a normalized contact object by JID.
          * @param {string} contactId
          * @param {{groupId?: string}} [opts] — when `contactId` is a raw `@lid`, this
-    
          *   always cross-checks it against Baileys' own protocol-level
          *   `sock.signalRepository.lidMapping` first (populated from real Signal
          *   session/identity resolution — not a heuristic, and doesn't need a
@@ -652,11 +675,16 @@ export function buildMessageContext(msg, sock, store, guardOptions = {}) {
         },
         hasMedia: msgHasMedia(msg),
         isGif: msgIsGif(msg),
-        async downloadMedia() {
+        async downloadMedia(opts = {}) {
             try {
                 const buffer = await downloadMediaMessage(msg, "buffer", {});
                 if (!buffer || !Buffer.isBuffer(buffer))
                     return null;
+                const isAnimatedSticker = !!unwrap(msg)?.stickerMessage?.isAnimated;
+                if (opts.asMp4 && isAnimatedSticker) {
+                    const mp4 = await stickerToMp4(buffer);
+                    return { mimetype: "video/mp4", data: mp4.toString("base64") };
+                }
                 return { mimetype: getMsgMimetype(msg), data: buffer.toString("base64") };
             }
             catch {
@@ -678,6 +706,12 @@ export function buildMessageContext(msg, sock, store, guardOptions = {}) {
                 return sock.sendMessage(rawJid, { delete: msg.key });
             }
         },
+        async edit(text) {
+            if (!msg.key.fromMe) {
+                throw new Error("[pluginApi] edit() can only be used on the bot's own messages");
+            }
+            return sock.sendMessage(rawJid, { text, edit: msg.key });
+        },
         async pin(_duration) {
             logger.warn("[pluginApi] pin() is not supported with Baileys");
         },
@@ -764,8 +798,141 @@ class MessageHandle {
             react: { text: emoji, key: msg.key },
         });
     }
+    /** Edit the sent message's text. Only works on the bot's own messages. */
+    async edit(text) {
+        const msg = await this.rawPromise;
+        if (!msg?.key)
+            return;
+        if (!msg.key.fromMe) {
+            throw new Error("[pluginApi] edit() can only be used on the bot's own messages");
+        }
+        return this._sock.sendMessage(msg.key.remoteJid, { text, edit: msg.key });
+    }
 }
 // ── Sender factory ────────────────────────────────────────────────────────────
+function runFfmpeg(args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("ffmpeg", args, { stdio: "ignore" });
+        proc.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                reject(new Error("ffmpeg not found on PATH — required to send .gif files. Install ffmpeg, or pass an already mp4-encoded file to gif()."));
+            }
+            else {
+                reject(err);
+            }
+        });
+        proc.on("exit", (code) => (code === 0 ? resolve() : reject(new Error(`ffmpeg exited with code ${code}`))));
+    });
+}
+/**
+ * Converts a raw .gif to an mp4 WhatsApp can actually decode as a video —
+ * sending GIF89a bytes labeled as video/mp4 leaves the client unable to
+ * play it (blurred placeholder + download button, no inline loop).
+ */
+async function gifToMp4(gifSource) {
+    const outPath = path.join(os.tmpdir(), `${randomUUID()}.mp4`);
+    const isBuffer = Buffer.isBuffer(gifSource);
+    const inPath = isBuffer ? path.join(os.tmpdir(), `${randomUUID()}.gif`) : gifSource;
+    try {
+        if (isBuffer)
+            await writeFile(inPath, gifSource);
+        await runFfmpeg([
+            "-y",
+            "-i", inPath,
+            "-movflags", "faststart",
+            "-pix_fmt", "yuv420p",
+            "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+            outPath,
+        ]);
+        return await readFile(outPath);
+    }
+    finally {
+        await unlink(outPath).catch(() => { });
+        if (isBuffer)
+            await unlink(inPath).catch(() => { });
+    }
+}
+/**
+ * Converts an animated-sticker WebP buffer to mp4.
+ *
+ * ffmpeg's own "webp" decoder cannot read animated WebP at all — it
+ * silently skips the ANIM/ANMF chunks ("skipping unsupported chunk: ANIM",
+ * "image data not found") and the whole conversion fails. This is a
+ * long-standing ffmpeg limitation (still true as of ffmpeg-devel
+ * discussion in mid-2025: "we have no [animated webp] decoder"), not
+ * anything specific to this bot — passing an animated .webp straight to
+ * `ffmpeg -i` always fails this way, no matter what you ask it to output.
+ *
+ * Workaround: use node-webpmux (already a project dependency, bundles its
+ * own libwebp via WASM) to demux the animation into individual
+ * single-frame WebP files — those decode fine with ffmpeg, since only the
+ * ANIM *container* trips it up, not the WebP codec itself — then hand
+ * ffmpeg a concat list with each frame's real delay so timing survives.
+ *
+ * Caveat: this assumes each ANMF frame is a full-canvas frame, which is
+ * true for the vast majority of sticker-maker output. Stickers authored
+ * with partial-frame deltas (a blend region smaller than the canvas)
+ * won't composite correctly here — that would need full RGBA canvas
+ * compositing via getFrameData() per frame, which isn't implemented.
+ */
+async function stickerToMp4(webpBuffer) {
+    const img = new WebP.Image();
+    await img.load(webpBuffer);
+    const outPath = path.join(os.tmpdir(), `${randomUUID()}.mp4`);
+    const scaleFilter = "scale=trunc(iw/2)*2:trunc(ih/2)*2";
+    if (!img.hasAnim) {
+        // Not actually animated — a plain static webp decodes fine on its own.
+        const inPath = path.join(os.tmpdir(), `${randomUUID()}.webp`);
+        try {
+            await writeFile(inPath, webpBuffer);
+            await runFfmpeg([
+                "-y",
+                "-i", inPath,
+                "-movflags", "faststart",
+                "-pix_fmt", "yuv420p",
+                "-vf", scaleFilter,
+                outPath,
+            ]);
+            return await readFile(outPath);
+        }
+        finally {
+            await unlink(inPath).catch(() => { });
+            await unlink(outPath).catch(() => { });
+        }
+    }
+    const dir = await mkdtemp(path.join(os.tmpdir(), "sticker-"));
+    try {
+        const frameBuffers = await img.demux({ buffers: true });
+        const delays = (img.frames ?? []).map(f => (f.delay > 0 ? f.delay : 100)); // ms; WebP spec treats 0 as implementation-defined
+        const listLines = [];
+        for (let i = 0; i < frameBuffers.length; i++) {
+            const framePath = path.join(dir, `frame_${i}.webp`);
+            await writeFile(framePath, frameBuffers[i]);
+            listLines.push(`file '${framePath}'`);
+            listLines.push(`duration ${((delays[i] ?? 100) / 1000).toFixed(3)}`);
+        }
+        // The concat demuxer ignores the final `duration` line unless the last
+        // file is listed once more after it.
+        listLines.push(`file '${path.join(dir, `frame_${frameBuffers.length - 1}.webp`)}'`);
+        const listPath = path.join(dir, "list.txt");
+        await writeFile(listPath, listLines.join("\n"));
+        await runFfmpeg([
+            "-y",
+            "-f", "concat", "-safe", "0",
+            "-i", listPath,
+            "-vsync", "vfr",
+            "-pix_fmt", "yuv420p",
+            "-vf", scaleFilter,
+            "-movflags", "faststart",
+            outPath,
+        ]);
+        return await readFile(outPath);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true }).catch(() => { });
+        await unlink(outPath).catch(() => { });
+    }
+}
 /**
  * Returns send methods bound to a specific JID.
  *
@@ -809,13 +976,13 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
                 return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
-        image(filePath, caption = "", opts = {}) {
+        image(source, caption = "", opts = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "typing");
-                const buffer = await readFile(filePath);
+                const buffer = await resolveMediaBuffer(source);
                 // viewOnce/mentions are part of the message CONTENT — see note above.
                 const messageContent = { image: buffer, caption };
                 if (opts.viewOnce) {
@@ -827,13 +994,13 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
                 return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
-        video(filePath, caption = "", opts = {}) {
+        video(source, caption = "", opts = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "typing");
-                const buffer = await readFile(filePath);
+                const buffer = await resolveMediaBuffer(source);
                 // viewOnce/mentions are part of the message CONTENT — see note above.
                 const messageContent = { video: buffer, caption };
                 if (opts.viewOnce) {
@@ -848,15 +1015,20 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
         /**
          * Send a GIF. WhatsApp has no native GIF format — this sends an mp4
          * with the `gifPlayback` flag, which the client auto-loops, muted.
-         * `filePath` must already be mp4-encoded (no .gif input, no conversion).
+         * Accepts a path or a Buffer. `.gif` input (detected by extension for
+         * a path, or by magic bytes for a Buffer) is converted to mp4 via
+         * ffmpeg automatically; already mp4-encoded input is sent as-is, no
+         * conversion cost.
          */
-        gif(filePath, caption = "", opts = {}) {
+        gif(source, caption = "", opts = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "typing");
-                const buffer = await readFile(filePath);
+                const buffer = needsGifConversion(source)
+                    ? await gifToMp4(source)
+                    : await resolveMediaBuffer(source);
                 const messageContent = { video: buffer, caption, gifPlayback: true };
                 if (opts.viewOnce) {
                     messageContent.viewOnce = true;
@@ -867,13 +1039,13 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
                 return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
-        audio(filePath, { asVoice = true, viewOnce = false } = {}) {
+        audio(source, { asVoice = true, viewOnce = false } = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "recording");
-                const buffer = await readFile(filePath);
+                const buffer = await resolveMediaBuffer(source);
                 // viewOnce is part of the message CONTENT — see note above.
                 const messageContent = { audio: buffer, mimetype: "audio/mp4", ptt: asVoice };
                 if (viewOnce) {
@@ -888,22 +1060,28 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
                 const qOpts = quotedMsg ? { quoted: quotedMsg } : undefined;
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "typing");
-                const buffer = Buffer.isBuffer(source) ? source : await readFile(source);
+                const buffer = await resolveMediaBuffer(source);
                 return sock.sendMessage(jid, { sticker: buffer }, qOpts);
             })(), sock, store, { cooldown, jitter });
         },
-        file(filePath, filename) {
+        file(source, filename) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const qOpts = quotedMsg ? { quoted: quotedMsg } : undefined;
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "typing");
-                const buffer = await readFile(filePath);
-                const mimetype = mimeFromPath(filePath);
+                const isBuffer = Buffer.isBuffer(source);
+                const buffer = await resolveMediaBuffer(source);
+                // With a path we can always infer the mimetype/name from it. With a
+                // raw Buffer there's no extension to read, so an explicit `filename`
+                // is what lets us infer the mimetype too — otherwise we fall back to
+                // a generic octet-stream document named "file".
+                const mimetype = filename ? mimeFromPath(filename) : (isBuffer ? "application/octet-stream" : mimeFromPath(source));
+                const resolvedFilename = filename ?? (isBuffer ? "file" : path.basename(source));
                 return sock.sendMessage(jid, {
                     document: buffer,
                     mimetype,
-                    fileName: filename ?? path.basename(filePath),
+                    fileName: resolvedFilename,
                 }, qOpts);
             })(), sock, store, { cooldown, jitter });
         },
@@ -938,12 +1116,12 @@ function buildSendApi(sock, store, rawJid, guardOptions = {}) {
     return {
         send: {
             text: (text, opts) => current.text(text, opts),
-            image: (filePath, caption, opts) => current.image(filePath, caption, opts),
-            video: (filePath, caption, opts) => current.video(filePath, caption, opts),
-            gif: (filePath, caption, opts) => current.gif(filePath, caption, opts),
-            audio: (filePath, opts) => current.audio(filePath, opts),
+            image: (source, caption, opts) => current.image(source, caption, opts),
+            video: (source, caption, opts) => current.video(source, caption, opts),
+            gif: (source, caption, opts) => current.gif(source, caption, opts),
+            audio: (source, opts) => current.audio(source, opts),
             sticker: (source) => current.sticker(source),
-            file: (filePath, filename) => current.file(filePath, filename),
+            file: (source, filename) => current.file(source, filename),
             poll: (q, opts, cfg) => current.poll(q, opts, cfg),
             /**
              * Returns a sender bound to another chat.
@@ -1656,11 +1834,16 @@ export function buildApi({ msg, chat, sock, store, pluginRegistry, pluginName, g
             sock,
             store,
             msg,
-            downloadMedia: async () => {
+            downloadMedia: async (opts = {}) => {
                 try {
                     const buffer = await downloadMediaMessage(msg, "buffer", {});
                     if (!buffer || !Buffer.isBuffer(buffer))
                         return null;
+                    const isAnimatedSticker = !!unwrap(msg)?.stickerMessage?.isAnimated;
+                    if (opts.asMp4 && isAnimatedSticker) {
+                        const mp4 = await stickerToMp4(buffer);
+                        return { mimetype: "video/mp4", data: mp4.toString("base64") };
+                    }
                     return { mimetype: getMsgMimetype(msg), data: buffer.toString("base64") };
                 }
                 catch {

package/dist/drivers/whatsapp/sdk/baileysSock.js

@@ -4,7 +4,7 @@
  * Creates and returns a Baileys WASocket.
  * Handles auth state persistence, QR/pairing-code display, and reconnection.
  */
-import makeWASocket, { useMultiFileAuthState, fetchLatestBaileysVersion, Browsers, proto, } from "@whiskeysockets/baileys";
+import { makeWASocket, useMultiFileAuthState, fetchLatestBaileysVersion, Browsers, WAProto, } from "@whiskeysockets/baileys";
 import path from "path";
 import qrcode from "qrcode-terminal";
 import { CONFIG_DIR, CLIENT_ID } from "#config";
@@ -57,7 +57,7 @@ export async function createSocket(authDirName = CLIENT_ID) {
         // https://github.com/WhiskeySockets/Baileys — SocketConfig docs).
         // This keeps the initial/recent sync (needed for store.chats and
         // LID→phone resolution) while still skipping the full download.
-        shouldSyncHistoryMessage: ({ syncType }) => syncType !== proto.HistorySync.HistorySyncType.FULL,
+        shouldSyncHistoryMessage: ({ syncType }) => syncType !== WAProto.HistorySync.HistorySyncType.FULL,
         // Required for Baileys to decrypt incoming poll votes (and to retry
         // sends) — it looks up the original message by key internally.
         // Without this, pollUpdates never resolve even though the vote event

package/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.4.1",
+  "version": "5.5.1",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
@@ -37,7 +37,7 @@
   "dependencies": {
     "@clack/prompts": "^0.10.1",
     "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "^6.7.23",
+    "@whiskeysockets/baileys": "^6.17.16",
     "node-cron": "^4.6.0",
     "node-webpmux": "^3.2.1",
     "pino": "^10.3.1",