@manybot/manybot 5.3.1 → 5.3.3

package/dist/client/store.js

@@ -73,12 +73,36 @@ export function createStore() {
                 chatMsgs.delete(oldest);
         }
     }
+    // pushName only ever arrives on a message stanza (live or synced history)
+    // — contact/history-contact sync alone won't give us a name for someone
+    // who never messaged and isn't a saved contact. Shared by both
+    // "messages.upsert" (live) and "messaging-history.set" (backfill on
+    // connect), since history-sync messages carry the same field.
+    function capturePushNames(msgs) {
+        for (const msg of msgs) {
+            const key = msg.key;
+            learnLid(key.participantAlt, key.participant);
+            learnLid(key.remoteJidAlt, key.remoteJid);
+            const pushName = msg.pushName;
+            const senderId = key.participant ?? msg.key.remoteJid;
+            if (pushName && senderId && !msg.key.fromMe && !senderId.endsWith("@g.us")) {
+                const existing = contacts[senderId];
+                if (existing?.notify !== pushName) {
+                    contacts[senderId] = { ...existing, id: senderId, notify: pushName };
+                }
+            }
+        }
+    }
     function bind(ev) {
-        ev.on("messaging-history.set", ({ chats, contacts }) => {
+        ev.on("messaging-history.set", ({ chats, contacts, messages }) => {
             for (const chat of chats)
                 upsertChat(chat);
             for (const contact of contacts)
                 upsertContact(contact);
+            // Backfilled messages carry pushName too — was previously dropped,
+            // leaving contacts unresolved until they next messaged live.
+            if (messages?.length)
+                capturePushNames(messages);
         });
         ev.on("chats.upsert", (newChats) => {
             for (const chat of newChats)
@@ -109,24 +133,9 @@ export function createStore() {
             }
         });
         ev.on("messages.upsert", ({ messages: msgs }) => {
-            for (const msg of msgs) {
+            for (const msg of msgs)
                 storeMessage(msg);
-                const key = msg.key;
-                learnLid(key.participantAlt, key.participant);
-                learnLid(key.remoteJidAlt, key.remoteJid);
-                // pushName only ever arrives on a live message — contact/history
-                // sync alone won't give us a name for someone who never messaged
-                // and isn't a saved contact. Worth capturing here, since it's the
-                // one extra source we have (feeds the on-disk cache too).
-                const pushName = msg.pushName;
-                const senderId = key.participant ?? msg.key.remoteJid;
-                if (pushName && senderId && !msg.key.fromMe && !senderId.endsWith("@g.us")) {
-                    const existing = contacts[senderId];
-                    if (existing?.notify !== pushName) {
-                        contacts[senderId] = { ...existing, id: senderId, notify: pushName };
-                    }
-                }
-            }
+            capturePushNames(msgs);
         });
         ev.on("messages.update", (updates) => {
             for (const { key, update } of updates) {

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

@@ -15,6 +15,16 @@ import { enqueue } from "#download";
 import { schedule, cancelPlugin } from "#kernel/scheduler.js";
 import { emptyFolder } from "#utils/file.js";
 import { normalizeJid, toPresenceCapable } from "../sdk/baileysSock.js";
+// store.contacts is keyed by whatever raw JID Baileys handed the store
+// (e.g. "...@s.whatsapp.net" for a normal DM) — never run through
+// normalizeJid. Every lookup here works in normalized ("...@c.us") form,
+// so a plain `store.contacts[normalizedId]` misses for any non-@lid
+// contact. @lid contacts don't hit this: normalizeJid doesn't touch
+// "@lid", so the raw store key already matches. Used as a fallback key
+// alongside the normalized one wherever we read store.contacts directly.
+function denormalizeJid(jid) {
+    return jid.replace(/@c\.us$/, "@s.whatsapp.net");
+}
 import { mkdirSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import { readFileSync } from "fs";
@@ -322,6 +332,25 @@ const log = {
     success: (...a) => logger.success(...a),
 };
 // ── Contact normalization ─────────────────────────────────────────────────────
+/**
+ * Resolve the text to show after "@" in a mention.
+ *
+ * WhatsApp's tag/notify behavior (who gets pinged, the bold highlight) is
+ * driven entirely by contextInfo.mentionedJid — the visible text after "@"
+ * is cosmetic and each client fills it in independently. Web commonly
+ * resolves it from the group's synced metadata, but mobile clients only do
+ * this when the number is saved in the phone's own contacts — otherwise
+ * they show the raw digits (e.g. "@5516999999999"), which is the "só
+ * aparece @numero no celular" behavior. Using the name Baileys already
+ * knows (contact name / business verifiedName / WhatsApp "notify" push
+ * name) instead of the number sidesteps that client-side lookup and
+ * renders consistently everywhere.
+ * @param {string}          jid
+ * @param {WAStoreContact}  [info]
+ */
+function mentionDisplayName(jid) {
+    return jid.split("@")[0];
+}
 /**
  * Build a normalized contact object from a JID and optional store metadata.
  * isBusiness is resolved via sock.getBusinessProfile(jid) — it resolves to
@@ -380,7 +409,7 @@ async function normalizeContact(jid, info, botJid, sock) {
         isWAAccount,
         isUser: !jid.endsWith("@g.us"),
         isGroup: jid.endsWith("@g.us"),
-        mention: { text: `@${number}`, mentions: [jid] },
+        mention: { text: `@${mentionDisplayName(jid)}`, mentions: [toWireJid(jid)] },
     };
 }
 // ── Contact API ───────────────────────────────────────────────────────────────
@@ -467,8 +496,10 @@ function buildContactsApi(sock, store, botJid) {
             // `undefined` silently clobber a real value already present in raw
             // (or vice versa) — which is how a contact could resolve correctly
             // by id yet still come back with a null pushname/name.
-            const raw = store.contacts[contactId];
-            const resolvedInfo = store.contacts[resolved];
+            const raw = store.contacts[contactId]
+                ?? store.contacts[denormalizeJid(contactId)];
+            const resolvedInfo = store.contacts[resolved]
+                ?? store.contacts[denormalizeJid(resolved)];
             const info = (raw || resolvedInfo) ? {
                 id: resolved,
                 name: resolvedInfo?.name ?? raw?.name,
@@ -629,7 +660,9 @@ export function buildMessageContext(msg, sock, store, guardOptions = {}) {
          */
         async getContact() {
             const info = store.contacts[sender]
-                ?? store.contacts[store.resolveJid(msg.key.participant ?? "")];
+                ?? store.contacts[denormalizeJid(sender)]
+                ?? store.contacts[store.resolveJid(msg.key.participant ?? "")]
+                ?? store.contacts[denormalizeJid(store.resolveJid(msg.key.participant ?? ""))];
             const botJid = sock.user?.id ? jidNormalizedUser(sock.user.id) : null;
             return normalizeContact(sender, info, botJid, sock);
         },
@@ -730,55 +763,73 @@ function makeSender(sock, store, jid, quoted = null, { cooldown = true, jitter =
         text(content, opts = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
-                const sendOpts = quotedMsg ? { quoted: quotedMsg } : undefined;
+                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 } : undefined;
-                if (opts.viewOnce) {
-                    sendOpts.viewOnce = true;
-                }
+                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, { image: buffer, caption }, sendOpts);
+                // viewOnce/mentions are part of the message CONTENT — see note above.
+                const messageContent = { image: buffer, caption };
+                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 });
         },
         video(filePath, caption = "", opts = {}) {
             return new MessageHandle((async () => {
                 const quotedMsg = await resolveQuoted();
-                const sendOpts = quotedMsg ? { quoted: quotedMsg } : undefined;
-                if (opts.viewOnce) {
-                    sendOpts.viewOnce = true;
-                }
+                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);
+                // viewOnce/mentions are part of the message CONTENT — see note above.
+                const messageContent = { video: buffer, caption };
+                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 } : undefined;
-                if (viewOnce) {
-                    sendOpts.viewOnce = true;
-                }
+                const sendOpts = quotedMsg ? { quoted: quotedMsg } : {};
                 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) {
@@ -837,8 +888,8 @@ function buildSendApi(sock, store, rawJid, guardOptions = {}) {
     return {
         send: {
             text: (text, opts) => current.text(text, opts),
-            image: (filePath, caption) => current.image(filePath, caption),
-            video: (filePath, caption) => current.video(filePath, caption),
+            image: (filePath, caption, opts) => current.image(filePath, caption, opts),
+            video: (filePath, caption, opts) => current.video(filePath, caption, opts),
             audio: (filePath, opts) => current.audio(filePath, opts),
             sticker: (source) => current.sticker(source),
             file: (filePath, filename) => current.file(filePath, filename),
@@ -913,8 +964,76 @@ function buildEventsApi(sock, pluginName) {
  * @param {WASocket}     sock
  * @param {string|null}  chatJid — raw JID of the current group (null in setup context)
  */
+/**
+ * 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)));
+    }
+    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];
+    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.");
@@ -947,6 +1066,23 @@ function buildAdminApi(sock, chatJid) {
             throw new Error(`groupParticipantsUpdate("${action}") rejeitado para: ${detail}`);
         }
     }
+    /**
+     * Thin wrapper around `sock.groupParticipantsUpdate()` that turns an
+     * opaque Boom rejection (e.g. the whole IQ query bounced with
+     * "bad-request") into an error that names the group/action/participants
+     * involved, then still runs the per-participant status check above.
+     */
+    async function runParticipantsUpdate(jid, users, action) {
+        let results;
+        try {
+            results = await sock.groupParticipantsUpdate(jid, users, action);
+        }
+        catch (err) {
+            throw new Error(`groupParticipantsUpdate("${action}") falhou para o grupo "${jid}" com participantes [${users.join(", ")}]: ${err.message}`);
+        }
+        assertParticipantsUpdateOk(action, results);
+        return results;
+    }
     function createTargetableAction(action, memberIds) {
         const users = norm(memberIds);
         const executeCurrent = async () => { requireChat(); return action(chatJid, users); };
@@ -964,34 +1100,24 @@ function buildAdminApi(sock, chatJid) {
         };
     }
     return {
-        /** @param {string|string[]} memberIds */
+        /** @param {string|string[]} memberIds — JID (@s.whatsapp.net/@lid), this framework's @c.us form, or a bare phone number */
         add(memberIds) {
-            return createTargetableAction(async (jid, users) => {
-                const results = await sock.groupParticipantsUpdate(jid, users, "add");
-                assertParticipantsUpdateOk("add", results);
-                return results;
-            }, memberIds);
+            return createTargetableAction((jid, users) => runParticipantsUpdate(jid, users, "add"), memberIds);
         },
-        /** @param {string|string[]} memberIds */
+        /** @param {string|string[]} memberIds — JID (@s.whatsapp.net/@lid), this framework's @c.us form, or a bare phone number */
         async kick(memberIds) {
             requireChat();
-            const results = await sock.groupParticipantsUpdate(chatJid, norm(memberIds), "remove");
-            assertParticipantsUpdateOk("remove", results);
-            return results;
+            return runParticipantsUpdate(chatJid, norm(memberIds), "remove");
         },
-        /** @param {string|string[]} memberIds */
+        /** @param {string|string[]} memberIds — JID (@s.whatsapp.net/@lid), this framework's @c.us form, or a bare phone number */
         async promote(memberIds) {
             requireChat();
-            const results = await sock.groupParticipantsUpdate(chatJid, norm(memberIds), "promote");
-            assertParticipantsUpdateOk("promote", results);
-            return results;
+            return runParticipantsUpdate(chatJid, norm(memberIds), "promote");
         },
-        /** @param {string|string[]} memberIds */
+        /** @param {string|string[]} memberIds — JID (@s.whatsapp.net/@lid), this framework's @c.us form, or a bare phone number */
         async demote(memberIds) {
             requireChat();
-            const results = await sock.groupParticipantsUpdate(chatJid, norm(memberIds), "demote");
-            assertParticipantsUpdateOk("demote", results);
-            return results;
+            return runParticipantsUpdate(chatJid, norm(memberIds), "demote");
         },
         /** @param {string} name */
         async setSubject(name) {

package/dist/drivers/whatsapp/index.js

@@ -102,6 +102,7 @@ async function startBot() {
     currentSock = sock;
     currentStore = store;
     connecting = false;
+    let pluginsReady = false;
     // ── Normal bot mode ─────────────────────────────────────────────────────────
     sock.ev.on("connection.update", async (update) => {
         const { connection, lastDisconnect } = update;
@@ -111,8 +112,11 @@ async function startBot() {
             logger.success(t("system.connected"));
             logger.info(t("system.clientId", { id: CLIENT_ID }));
             printBanner();
-            await loadPlugins(PLUGINS);
-            await setupPlugins(sock, store);
+            if (!pluginsReady) {
+                pluginsReady = true;
+                await loadPlugins(PLUGINS);
+                await setupPlugins(sock, store);
+            }
             startCacheAutosave(store);
             // buffer anti-replay / sync ghost messages
             setTimeout(() => { state = "READY"; }, 2000);

package/package.json

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