@manybot/manybot 5.6.1 → 5.8.0

package/dist/drivers/baileys/adapter.js

@@ -22,7 +22,7 @@
  * Returns/dispatches are pure adapters — error semantics, retries, fallbacks
  * all live elsewhere (sendFallbackGuard, sendGuard, pluginGuard).
  */
-import { normalizeMessageContent, downloadMediaMessage, jidNormalizedUser, } from "@whiskeysockets/baileys";
+import { normalizeMessageContent, downloadMediaMessage, jidNormalizedUser, decryptPollVote as baileysDecryptPollVote, getAggregateVotesInPollMessage, } from "@whiskeysockets/baileys";
 import { createHash } from "node:crypto";
 import { logger } from "#logger";
 /**
@@ -72,6 +72,22 @@ export function decodeContent(content) {
         type = "sticker";
         mimetype = m.stickerMessage.mimetype ?? undefined;
     }
+    else if (m?.templateMessage) {
+        type = "text";
+        const tpl = m.templateMessage.hydratedTemplate ?? m.templateMessage.hydratedFourRowTemplate;
+        const buttonUrls = tpl?.hydratedButtons?.map((b) => b.urlButton?.url).filter(Boolean).join(" ") ?? "";
+        body = [tpl?.hydratedContentText ?? "", buttonUrls].filter(Boolean).join(" ");
+    }
+    else if (m?.interactiveMessage) {
+        type = "text";
+        const buttonParams = m.interactiveMessage.nativeFlowMessage?.buttons
+            ?.map((b) => b.buttonParamsJson).filter(Boolean).join(" ") ?? "";
+        body = [m.interactiveMessage.body?.text ?? "", buttonParams].filter(Boolean).join(" ");
+    }
+    else if (m?.buttonsMessage) {
+        type = "text";
+        body = [m.buttonsMessage.contentText ?? "", m.buttonsMessage.footerText ?? ""].filter(Boolean).join(" ");
+    }
     return { type, body, mimetype };
 }
 export function createBaileysAdapter(initial) {
@@ -115,6 +131,29 @@ export function createBaileysAdapter(initial) {
         // which throws if `.message` is missing.
         return { quoted: { key: toFlatKey(quoted), message: inner } };
     }
+    /**
+     * Merge `quoted` reply-citation with the chat's current
+     * `ephemeralExpiration` so every outgoing send in a chat with a
+     * disappearing-message timer inherits it automatically. Returns
+     * `undefined` when there's nothing to set, so callers can pass it
+     * through as the third argument to `sock.sendMessage` without
+     * conditionally building the options object.
+     *
+     * The timer is read off the in-memory store, which is populated by
+     * `chats.upsert` / `chats.update` / `messages.upsert` (via the
+     * `ephemeralMessage` envelope) and from `groupMetadata().ephemeralDuration`
+     * in this same adapter — i.e. everything WhatsApp tells us about the
+     * chat's timer ends up there, and the send path just reads it back.
+     */
+    function buildSendOpts(jid, quoted) {
+        const quotedOpts = buildQuotedOpts(quoted);
+        const timer = store.chats.get(jid)?.ephemeralExpiration;
+        if (!timer)
+            return quotedOpts;
+        if (!quotedOpts)
+            return { ephemeralExpiration: timer };
+        return { ...quotedOpts, ephemeralExpiration: timer };
+    }
     /**
      * Translate a neutral `BotQuotedRef` into the FLAT key shape Baileys
      * expects for `react`/`delete`/`edit`/`readMessages` (proto.IMessageKey
@@ -151,6 +190,9 @@ export function createBaileysAdapter(initial) {
             m?.videoMessage?.contextInfo ??
             m?.audioMessage?.contextInfo ??
             m?.documentMessage?.contextInfo ??
+            m?.templateMessage?.contextInfo ??
+            m?.interactiveMessage?.contextInfo ??
+            m?.buttonsMessage?.contextInfo ??
             undefined;
         const ciTyped = contextInfo;
         return {
@@ -201,6 +243,44 @@ export function createBaileysAdapter(initial) {
             lid: c.lid,
         };
     }
+    /**
+     * Compute every plausible JID candidate for a side of a poll-vote
+     * decryption. WhatsApp doesn't consistently pick the same JID shape
+     * (LID vs PN) when deriving the poll-vote decryption key — it depends
+     * on addressingMode, 1:1 vs group, and which side sent last. Trying
+     * to compute "the" correct JID up front causes AES-GCM auth failures
+     * whenever WhatsApp actually used the LID; brute-forcing candidates
+     * is the only reliable approach (see
+     * https://github.com/WhiskeySockets/Baileys/issues/2342 and #1678).
+     *
+     * For the bot's own side (`self === true`), candidates are the bot's
+     * `user.id` and `user.lid`. For an external side, candidates are
+     * the participant/remoteJid, the `participantPn` if any, and any
+     * LID→PN mapping the store has learned.
+     */
+    function jidCandidatesFromKey(key, sock, store, self) {
+        const cands = [];
+        if (self) {
+            const selfLid = sock.user?.lid;
+            if (selfLid)
+                cands.push(jidNormalizedUser(selfLid));
+            if (sock.user?.id)
+                cands.push(jidNormalizedUser(sock.user.id));
+        }
+        else {
+            const rawParticipant = key.participant ?? key.remoteJid;
+            if (rawParticipant)
+                cands.push(jidNormalizedUser(rawParticipant));
+            if (key.participantPn)
+                cands.push(jidNormalizedUser(key.participantPn));
+            if (rawParticipant?.endsWith("@lid")) {
+                const resolved = store.resolveJid(rawParticipant);
+                if (resolved && resolved !== rawParticipant)
+                    cands.push(jidNormalizedUser(resolved));
+            }
+        }
+        return Array.from(new Set(cands.filter(Boolean)));
+    }
     const subscribers = new Map();
     // Tracks the handlers each socket has registered so we can remove them on a
     // fresh socket after reconnect. Declared up here because the rebind helpers
@@ -257,7 +337,7 @@ export function createBaileysAdapter(initial) {
         async sendText(jid, text, opts) {
             const content = { text };
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const sendOpts = buildQuotedOpts(opts?.quoted);
+            const sendOpts = buildSendOpts(jid, opts?.quoted);
             if (opts?.mentions?.length)
                 content.mentions = opts.mentions;
             const ref = await sock.sendMessage(jid, content, sendOpts);
@@ -271,7 +351,7 @@ export function createBaileysAdapter(initial) {
                 content.viewOnce = true;
             if (opts?.mentions?.length)
                 content.mentions = opts.mentions;
-            const ref = await sock.sendMessage(jid, content, buildQuotedOpts(opts?.quoted));
+            const ref = await sock.sendMessage(jid, content, buildSendOpts(jid, opts?.quoted));
             return toSentRef(ref, jid);
         },
         async sendVideo(jid, buffer, opts) {
@@ -284,7 +364,7 @@ export function createBaileysAdapter(initial) {
                 content.gifPlayback = true;
             if (opts?.mentions?.length)
                 content.mentions = opts.mentions;
-            const ref = await sock.sendMessage(jid, content, buildQuotedOpts(opts?.quoted));
+            const ref = await sock.sendMessage(jid, content, buildSendOpts(jid, opts?.quoted));
             return toSentRef(ref, jid);
         },
         async sendAudio(jid, buffer, opts) {
@@ -294,20 +374,20 @@ export function createBaileysAdapter(initial) {
                 content.ptt = true;
             if (opts?.viewOnce)
                 content.viewOnce = true;
-            const ref = await sock.sendMessage(jid, content, buildQuotedOpts(opts?.quoted));
+            const ref = await sock.sendMessage(jid, content, buildSendOpts(jid, opts?.quoted));
             return toSentRef(ref, jid);
         },
         async sendSticker(jid, buffer, opts) {
-            const ref = await sock.sendMessage(jid, { sticker: buffer }, buildQuotedOpts(opts?.quoted));
+            const ref = await sock.sendMessage(jid, { sticker: buffer }, buildSendOpts(jid, opts?.quoted));
             return toSentRef(ref, jid);
         },
         async sendDocument(jid, buffer, filename, mimetype, opts) {
-            const ref = await sock.sendMessage(jid, { document: buffer, mimetype, fileName: filename }, buildQuotedOpts(opts?.quoted));
+            const ref = await sock.sendMessage(jid, { document: buffer, mimetype, fileName: filename }, buildSendOpts(jid, opts?.quoted));
             return toSentRef(ref, jid);
         },
         async sendPoll(jid, opts) {
             const poll = { name: opts.name, values: opts.values, selectableCount: opts.selectableCount ?? 1 };
-            const ref = await sock.sendMessage(jid, { poll }, buildQuotedOpts(opts.quoted));
+            const ref = await sock.sendMessage(jid, { poll }, buildSendOpts(jid, opts.quoted));
             return toSentRef(ref, jid);
         },
         async react(jid, target, emoji) {
@@ -389,6 +469,15 @@ export function createBaileysAdapter(initial) {
         // ── groups ─────────────────────────────────────────────────────────────
         async groupMetadata(jid) {
             const meta = await sock.groupMetadata(jid);
+            // WhatsApp reports the group's current disappearing-message
+            // timer as `ephemeralDuration` on the metadata payload — promote
+            // it to the in-memory store so the next send to this group
+            // picks it up automatically (and so the timer survives a
+            // snapshot round-trip without us re-fetching metadata).
+            const rawDuration = meta.ephemeralDuration;
+            if (rawDuration !== undefined) {
+                store.setChatEphemeralExpiration(jid, Number(rawDuration) || 0);
+            }
             return {
                 subject: meta.subject,
                 participants: meta.participants.map(p => ({
@@ -505,6 +594,72 @@ export function createBaileysAdapter(initial) {
                 return null;
             }
         },
+        // ── poll decryption (Baileys-only) ───────────────────────────────────
+        //
+        // These are the only two methods on the contract that are explicitly
+        // Baileys-specific. whatsmeow (and any future driver) may leave them
+        // undefined; the only consumer today is `buildPollApi` in
+        // drivers/baileys/api/index.ts, which already tolerates the absence.
+        //
+        // Both live on the contract (not as a separate file-level helper)
+        // because the Baileys-side knowledge they encode — picking the
+        // correct LID-vs-PN JID on each side, knowing the bot's own
+        // `sock.user.id/lid`, knowing the WAMessage shape for the encrypted
+        // payload — would otherwise leak out of the adapter.
+        async decryptPollVote(opts) {
+            const voteRaw = store.messages.get(opts.voteKey.remoteJid ?? "")?.get(opts.voteKey.id ?? "");
+            const pum = voteRaw?.message?.pollUpdateMessage;
+            const vote = pum?.vote;
+            if (!vote)
+                return null;
+            const encKey = Buffer.isBuffer(opts.pollEncKey)
+                ? opts.pollEncKey
+                : Buffer.from(opts.pollEncKey, "base64");
+            // WhatsApp doesn't consistently use the same JID shape (LID vs PN) for
+            // pollCreatorJid/voterJid — it depends on addressingMode, 1:1 vs group,
+            // and which side sent last. Compute every plausible candidate and
+            // brute-force combinations until one decrypts successfully (see
+            // https://github.com/WhiskeySockets/Baileys/issues/2342 and #1678).
+            const creatorCandidates = jidCandidatesFromKey(opts.pollKey, sock, store, /*self*/ false);
+            const voterCandidates = jidCandidatesFromKey(opts.voteKey, sock, store, !!opts.voteKey.fromMe);
+            for (const pollCreatorJid of creatorCandidates) {
+                for (const voterJid of voterCandidates) {
+                    try {
+                        const decrypted = baileysDecryptPollVote(vote, {
+                            pollCreatorJid,
+                            pollMsgId: opts.pollKey.id ?? "",
+                            pollEncKey: encKey,
+                            voterJid,
+                        });
+                        // PollVoteMessage.selectedOptions is a list of { optionHash: Buffer | null }.
+                        // Map to plain hex strings for the contract surface.
+                        const selectedOptions = (decrypted.selectedOptions ?? [])
+                            .map((o) => {
+                            const h = o?.optionHash;
+                            if (!h)
+                                return null;
+                            return Buffer.isBuffer(h) ? h.toString("hex") : Buffer.from(h).toString("hex");
+                        })
+                            .filter((x) => !!x);
+                        return { selectedOptions, raw: decrypted };
+                    }
+                    catch {
+                        // try next JID combination
+                    }
+                }
+            }
+            return null;
+        },
+        aggregatePollVotes(opts) {
+            const pollRaw = store.messages.get(opts.pollKey.remoteJid ?? "")?.get(opts.pollKey.id ?? "");
+            if (!pollRaw?.message)
+                return [];
+            const meId = opts.selfJid ?? (sock.user?.id ? jidNormalizedUser(sock.user.id) : undefined);
+            const aggregated = getAggregateVotesInPollMessage(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            { message: pollRaw.message, pollUpdates: opts.votes }, meId);
+            return aggregated;
+        },
     };
     // ── Rebind helpers (post-reconnect in drivers/baileys/index.ts) ────────
     //
@@ -528,6 +683,26 @@ export function createBaileysAdapter(initial) {
             const updates = arg;
             emit("messages.update", { updates });
         });
+        // Baileys emits one of two shapes for `messages.delete`: a `keys`
+        // array (per-message revoke) or `{ jid, all: true }` (chat clear).
+        // Normalize to a single payload here so the contract's consumer
+        // never has to special-case the variant.
+        register("messages.delete", (arg) => {
+            const a = arg;
+            if ("all" in a) {
+                emit("messages.delete", { keys: [], all: { jid: a.jid } });
+            }
+            else {
+                emit("messages.delete", {
+                    keys: a.keys.map((k) => ({
+                        id: k.id ?? null,
+                        remoteJid: k.remoteJid ?? null,
+                        fromMe: k.fromMe ?? null,
+                        participant: k.participant ?? null,
+                    })),
+                });
+            }
+        });
         register("messaging-history.set", (arg) => {
             const { chats, contacts, messages } = arg;
             emit("messaging-history.set", {
@@ -542,6 +717,9 @@ export function createBaileysAdapter(initial) {
         register("chats.update", (arg) => {
             emit("chats.update", { updates: arg });
         });
+        register("chats.delete", (arg) => {
+            emit("chats.delete", { ids: arg });
+        });
         register("contacts.upsert", (arg) => {
             emit("contacts.upsert", { contacts: arg.map(contactSummary) });
         });
@@ -552,9 +730,30 @@ export function createBaileysAdapter(initial) {
             const { id, participants } = arg;
             emit("group-participants.update", { id, participants });
         });
+        register("groups.upsert", (arg) => {
+            const groups = arg;
+            emit("groups.upsert", { groups: groups.map((g) => ({ id: g.id, subject: g.subject })) });
+        });
         register("groups.update", (arg) => {
             emit("groups.update", { updates: arg });
         });
+        register("group.join-request", (arg) => {
+            const a = arg;
+            emit("group.join-request", {
+                id: a.id,
+                author: a.author,
+                participant: a.participant,
+                action: a.action,
+                method: a.method ?? "unknown",
+            });
+        });
+        register("blocklist.set", (arg) => {
+            emit("blocklist.set", { blocklist: arg.blocklist });
+        });
+        register("blocklist.update", (arg) => {
+            const a = arg;
+            emit("blocklist.update", { blocklist: a.blocklist, type: a.type });
+        });
         register("connection.update", (arg) => {
             const { connection, lastDisconnect } = arg;
             emit("connection.update", {