@manybot/manybot 5.3.2 → 5.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 ![ManyBot Logo](logo.png)
 
-![Node.js 24+](https://img.shields.io/badge/Node.js-20+-339933?logo=node.js&logoColor=white)
+![Node.js 24+](https://img.shields.io/badge/Node.js-24+-339933?logo=node.js&logoColor=white)
 ![npm 9+](https://img.shields.io/badge/npm-9+-CB3837?logo=npm&logoColor=white)
 ![GPL v3](https://img.shields.io/badge/License-GPL--v3-blue.svg)
 ![Linux](https://img.shields.io/badge/Linux%20%7C%20Windows-lightgrey)
@@ -46,9 +46,9 @@ Browse available plugins at **[manybot.org/plugins](https://manybot.org/plugins/
 All kinds of contributions are welcome:
 
 - **Bug reports and feature requests**: open an issue on GitHub or Codeberg
-- **Code**: pull requests are welcome on [GitHub](https://github.com/many-bot/manybot) or [Codeberg](https://codeberg.org/many-bot/manybot); patches by email (`devel+manybot.org`) are also accepted - subscribe to the mailing list [here](https://list.stxerr.dev).
+- **Code**: pull requests are welcome on [GitHub](https://github.com/many-bot/manybot) or [Codeberg](https://codeberg.org/many-bot/manybot); patches by email (`manybot@pm.me`) are also accepted.
 - **Plugins**: submit your plugin to [manyplug-repo](https://github.com/many-bot/manyplug-repo), which has instructions on how to do it
-- **Anything else**: suggestions, translations, documentation fixes - reach out by email or open an issue
+- **Anything else**: suggestions, translations, documentation fixes, art - reach out by email or open an issue
 
 ## License
 

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

@@ -348,9 +348,8 @@ const log = {
  * @param {string}          jid
  * @param {WAStoreContact}  [info]
  */
-function mentionDisplayName(jid, info) {
-    const number = jid.split("@")[0];
-    return info?.name ?? info?.verifiedName ?? info?.notify ?? number;
+function mentionDisplayName(jid) {
+    return jid.split("@")[0];
 }
 /**
  * Build a normalized contact object from a JID and optional store metadata.
@@ -410,7 +409,23 @@ async function normalizeContact(jid, info, botJid, sock) {
         isWAAccount,
         isUser: !jid.endsWith("@g.us"),
         isGroup: jid.endsWith("@g.us"),
-        mention: { text: `@${mentionDisplayName(jid, info)}`, mentions: [jid] },
+        mention: { text: `@${mentionDisplayName(jid)}`, mentions: [toWireJid(jid)] },
+    };
+}
+// ── Chats API ─────────────────────────────────────────────────────────────────
+function buildChatsApi(store) {
+    return {
+        /**
+         * Chats currently known from the in-memory cache (populated from
+         * Baileys' chats.upsert / messaging-history.set events) — no network call.
+         * @returns {Array<{ id: string, name: string, isGroup: boolean }>}
+         */
+        all() {
+            return store.chats.all().map((c) => {
+                const id = normalizeJid(c.id);
+                return { id, name: c.name, isGroup: id.endsWith("@g.us") };
+            });
+        },
     };
 }
 // ── Contact API ───────────────────────────────────────────────────────────────
@@ -420,6 +435,7 @@ 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
@@ -588,6 +604,15 @@ function buildContactsApi(sock, store, botJid) {
         },
     };
 }
+function makeHistoryArray(entries, store) {
+    const arr = entries;
+    arr.last = (n) => makeHistoryArray(typeof n === "number" ? entries.slice(-n) : entries.slice(), store);
+    arr.from = (senderId) => {
+        const target = normalizeJid(store.resolveJid(normalizeJid(senderId)));
+        return makeHistoryArray(entries.filter((e) => e.sender === target), store);
+    };
+    return arr;
+}
 export function buildMessageContext(msg, sock, store, guardOptions = {}) {
     const body = getMsgBody(msg);
     const prefix = CONFIG.CMD_PREFIX;
@@ -613,6 +638,8 @@ export function buildMessageContext(msg, sock, store, guardOptions = {}) {
         }
         : null;
     return {
+        id: msg.key.id ?? "",
+        timestamp: Number(msg.messageTimestamp) || 0,
         body,
         type: getMsgType(msg),
         fromMe: !!(msg.key.fromMe),
@@ -765,60 +792,94 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
+                // mentions/linkPreview are part of the message CONTENT, not the send
+                // options — Baileys reads contextInfo.mentionedJid off the content
+                // object. Putting them on sendOpts (3rd arg) is silently ignored: the
+                // message sends fine, "@name" shows as plain text, and nobody actually
+                // gets tagged/notified.
+                const messageContent = { text: content };
                 if (opts.linkPreview === false) {
-                    sendOpts.linkPreview = false;
+                    messageContent.linkPreview = null;
                 }
                 if (opts.mentions?.length) {
-                    sendOpts.mentions = opts.mentions;
+                    messageContent.mentions = await resolveMentionJids(sock, store, jid, opts.mentions);
                 }
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, typingDuration(content), "typing");
-                return sock.sendMessage(jid, { text: content }, sendOpts);
+                return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
         image(filePath, 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);
+                // viewOnce/mentions are part of the message CONTENT — see note above.
+                const messageContent = { image: buffer, caption };
                 if (opts.viewOnce) {
-                    sendOpts.viewOnce = true;
+                    messageContent.viewOnce = true;
                 }
                 if (opts.mentions?.length) {
-                    sendOpts.mentions = opts.mentions;
+                    messageContent.mentions = await resolveMentionJids(sock, store, jid, opts.mentions);
                 }
-                await waitForSendSlot(normJid, { cooldown, jitter });
-                await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "typing");
-                const buffer = await readFile(filePath);
-                return sock.sendMessage(jid, { image: buffer, caption }, sendOpts);
+                return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
         video(filePath, 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);
+                // viewOnce/mentions are part of the message CONTENT — see note above.
+                const messageContent = { video: buffer, caption };
                 if (opts.viewOnce) {
-                    sendOpts.viewOnce = true;
+                    messageContent.viewOnce = true;
                 }
                 if (opts.mentions?.length) {
-                    sendOpts.mentions = opts.mentions;
+                    messageContent.mentions = await resolveMentionJids(sock, store, jid, opts.mentions);
                 }
+                return sock.sendMessage(jid, messageContent, sendOpts);
+            })(), sock, store, { cooldown, 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).
+         */
+        gif(filePath, 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);
-                return sock.sendMessage(jid, { video: buffer, caption }, sendOpts);
+                const messageContent = { video: buffer, caption, gifPlayback: true };
+                if (opts.viewOnce) {
+                    messageContent.viewOnce = true;
+                }
+                if (opts.mentions?.length) {
+                    messageContent.mentions = await resolveMentionJids(sock, store, jid, opts.mentions);
+                }
+                return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
         audio(filePath, { asVoice = true, viewOnce = false } = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
                 const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
-                if (viewOnce) {
-                    sendOpts.viewOnce = true;
-                }
                 await waitForSendSlot(normJid, { cooldown, jitter });
                 await simulateState(toPresenceCapable(sock), jid, mediaDuration(), "recording");
                 const buffer = await readFile(filePath);
-                return sock.sendMessage(jid, { audio: buffer, mimetype: "audio/mp4", ptt: asVoice }, sendOpts);
+                // viewOnce is part of the message CONTENT — see note above.
+                const messageContent = { audio: buffer, mimetype: "audio/mp4", ptt: asVoice };
+                if (viewOnce) {
+                    messageContent.viewOnce = true;
+                }
+                return sock.sendMessage(jid, messageContent, sendOpts);
             })(), sock, store, { cooldown, jitter });
         },
         sticker(source) {
@@ -953,32 +1014,76 @@ function buildEventsApi(sock, pluginName) {
  * @param {WASocket}     sock
  * @param {string|null}  chatJid — raw JID of the current group (null in setup context)
  */
-function buildAdminApi(sock, chatJid) {
-    /**
-     * Normalize a participant identifier to the wire JID format WhatsApp's
-     * servers require (`...@s.whatsapp.net`). `groupParticipantsUpdate()`
-     * doesn't fail per-participant for a malformed entry — the WHOLE IQ
-     * query gets rejected by the server as a "bad-request" Boom error
-     * before any per-participant status even exists. This silently broke
-     * for the two most common inputs a plugin author reaches for:
-     *   - `contact.id` — this framework's own normalized `@c.us` form
-     *     (see normalizeJid()/denormalizeJid()), which isn't wire-valid.
-     *   - a bare phone number (with or without "+", spaces or dashes),
-     *     which has no `@...` server segment at all.
-     * Already-correct JIDs (`@s.whatsapp.net`, `@lid`, `@g.us`) pass through
-     * unchanged.
-     * @param {string} id
-     */
-    function toParticipantJid(id) {
-        const trimmed = id.trim();
-        if (/@(s\.whatsapp\.net|lid|g\.us)$/.test(trimmed))
-            return trimmed;
-        if (trimmed.endsWith("@c.us"))
-            return denormalizeJid(trimmed);
-        const digits = trimmed.replace(/\D/g, "");
-        return `${digits}@s.whatsapp.net`;
+/**
+ * Normalize any identifier to the wire JID format WhatsApp's servers and
+ * protocol actually expect (`...@s.whatsapp.net`). Used anywhere a JID is
+ * handed straight to Baileys — `groupParticipantsUpdate()` and message
+ * `mentions` — both of which silently misbehave otherwise: a malformed
+ * group-update JID gets the whole IQ query rejected ("bad-request"), and
+ * a malformed mentions entry just doesn't tag/notify anyone (the message
+ * still sends fine, so it looks like nothing is wrong until you check).
+ * Handles this framework's own normalized `@c.us` form (`contact.id`,
+ * `getMsgSender()`'s output — see normalizeJid()/denormalizeJid()), a bare
+ * phone number (with or without "+", spaces or dashes), and already-valid
+ * wire JIDs (`@s.whatsapp.net`, `@lid`, `@g.us`), which pass through
+ * unchanged.
+ * @param {string} id
+ */
+function toWireJid(id) {
+    const trimmed = id.trim();
+    if (/@(s\.whatsapp\.net|lid|g\.us)$/.test(trimmed))
+        return trimmed;
+    if (trimmed.endsWith("@c.us"))
+        return denormalizeJid(trimmed);
+    const digits = trimmed.replace(/\D/g, "");
+    return `${digits}@s.whatsapp.net`;
+}
+/**
+ * Resolve mentions to the exact JID form the destination group uses for
+ * that participant — not whatever store.resolveJid() happens to have
+ * mapped it to. A group can address a member via @lid even when we've
+ * separately learned their phone number; WhatsApp only tags/notifies a
+ * mention when the JID matches the group's own addressing for that
+ * member. DMs have no participant list to check against, so just wire-
+ * normalize as before (mentions aren't a real thing in DMs anyway).
+ */
+async function resolveMentionJids(sock, store, jid, mentions) {
+    const result = [];
+    for (const m of mentions) {
+        const wire = toWireJid(m);
+        if (wire)
+            result.push(wire);
+        const resolved = store.resolveJid(m);
+        if (resolved && resolved !== m) {
+            const resolvedWire = toWireJid(resolved);
+            if (resolvedWire)
+                result.push(resolvedWire);
+        }
+    }
+    if (!jid.endsWith("@g.us")) {
+        return Array.from(new Set(result.filter(Boolean)));
     }
-    const norm = (v) => (Array.isArray(v) ? v : [v]).map(toParticipantJid);
+    let meta;
+    try {
+        meta = await getGroupMetadataCached(sock, jid);
+    }
+    catch {
+        return Array.from(new Set(result.filter(Boolean)));
+    }
+    for (const m of mentions) {
+        const wire = toWireJid(m);
+        const resolved = normalizeJid(store.resolveJid(m));
+        const match = meta.participants.find(p => toWireJid(p.id) === wire || normalizeJid(store.resolveJid(p.id)) === resolved);
+        if (match) {
+            const matchWire = toWireJid(match.id);
+            if (matchWire)
+                result.push(matchWire);
+        }
+    }
+    return Array.from(new Set(result.filter(Boolean)));
+}
+function buildAdminApi(sock, chatJid) {
+    const norm = (v) => (Array.isArray(v) ? v : [v]).map(toWireJid);
     function requireChat() {
         if (!chatJid)
             throw new Error("This admin operation requires a runtime group context.");
@@ -1351,6 +1456,7 @@ function buildBaseApi(sock, store, pluginRegistry, pluginName) {
         download: buildDownloadApi(),
         scheduler: buildSchedulerApi(pluginName),
         plugins: buildPluginsApi(pluginRegistry),
+        chats: buildChatsApi(store),
         contacts: buildContactsApi(sock, store, botJid),
         storage: buildStorageApi(pluginName),
         botId: botJid,
@@ -1447,6 +1553,19 @@ export function buildApi({ msg, chat, sock, store, pluginRegistry, pluginName, g
             id: normJid,
             name: chat.name,
             isGroup: chat.isGroup,
+            /**
+             * Cached message history for this chat (oldest → newest), capped at
+             * the store's per-chat limit. Supports index access (`history[10]`)
+             * and two chainable filters: `.last(n)` and `.from(senderId)`.
+             * @returns {WAHistoryArray}
+             */
+            get history() {
+                const chatMsgs = store.messages.get(rawJid);
+                const entries = chatMsgs
+                    ? [...chatMsgs.values()].map((m) => buildMessageContext(m, sock, store, { cooldown: false, jitter: false }))
+                    : [];
+                return makeHistoryArray(entries, store);
+            },
             /**
              * List of group participants.
              * Returns [] for non-group chats.

package/dist/drivers/whatsapp/index.js

@@ -31,6 +31,39 @@ let connecting = false;
 let reconnectAttempts = 0;
 let cacheHydrated = false;
 let cacheSaveTimer = null;
+// ── Per-chat message queue ──────────────────────────────────────────────────
+// Messages from the same chat are processed one at a time (in order), but
+// different chats run concurrently — a slow plugin in one chat (e.g. sticker
+// generation) no longer blocks replies in every other chat.
+const chatQueues = new Map();
+function enqueueForChat(jid, task) {
+    const prev = chatQueues.get(jid) ?? Promise.resolve();
+    const settled = prev.catch(() => { }).then(task).catch((e) => {
+        const err = e instanceof Error ? e : new Error(String(e));
+        logger.error(`${err.message}\n${err.stack}`);
+    });
+    chatQueues.set(jid, settled);
+    settled.finally(() => {
+        if (chatQueues.get(jid) === settled)
+            chatQueues.delete(jid);
+    });
+}
+// Messages older than this (WhatsApp's own delivery delay — e.g. backlog
+// dumped after the bot reconnects) are skipped. Checked at arrival time,
+// so time spent waiting in chatQueues never counts against a message.
+const MAX_MESSAGE_AGE_SECONDS = 60;
+function isMessageStale(msg) {
+    const msgTimestamp = Number(msg.messageTimestamp);
+    if (!msgTimestamp)
+        return false;
+    const nowInSeconds = Math.floor(Date.now() / 1000);
+    const age = nowInSeconds - msgTimestamp;
+    if (age > MAX_MESSAGE_AGE_SECONDS) {
+        logger.debug(`[whatsapp] Skipping stale message (age: ${age}s, id: ${msg.key.id})`);
+        return true;
+    }
+    return false;
+}
 const RECONNECT_BASE_MS = 1000;
 const RECONNECT_MAX_MS = 60000;
 const CACHE_SAVE_INTERVAL_MS = 5 * 60 * 1000; // 5min
@@ -156,13 +189,10 @@ async function startBot() {
             const body = getBodyQuick(m);
             if (!body && !msgHasMediaQuick(m))
                 continue;
-            try {
-                await handleMessage(m, sock, store);
-            }
-            catch (e) {
-                const err = e instanceof Error ? e : new Error(String(e));
-                logger.error(`${err.message}\n${err.stack}`);
-            }
+            if (isMessageStale(m))
+                continue;
+            const jid = normalizeJid(m.key.remoteJid ?? "");
+            enqueueForChat(jid, () => handleMessage(m, sock, store));
         }
     });
 }

package/dist/drivers/whatsapp/messageHandler.js

@@ -45,14 +45,6 @@ function alreadyProcessed(id) {
  * @param {WAStore}    store
  */
 export async function handleMessage(msg, sock, store) {
-    const msgTimestamp = Number(msg.messageTimestamp);
-    if (msgTimestamp) {
-        const nowInSeconds = Math.floor(Date.now() / 1000);
-        const messageAge = nowInSeconds - msgTimestamp;
-        if (messageAge > 60) {
-            return;
-        }
-    }
     const rawJid = msg.key.remoteJid ?? "";
     const jid = normalizeJid(rawJid);
     if (CHATS.length > 0 && !CHATS.includes(jid)) {

package/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.3.2",
+  "version": "5.4.0",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {