@manybot/manybot 5.6.0 → 5.7.0

package/dist/drivers/baileys/adapter.js

@@ -22,15 +22,114 @@
  * 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";
+/**
+ * Classify a Baileys message-content payload (`WAMessageContent`) into
+ * the neutral `(type, body, mimetype)` triple used by `BotMessage`. Pure
+ * function — no side effects, no closures — so it's safe to call for
+ * both real incoming messages and the embedded `quotedMessage` content
+ * carried in `contextInfo` (which can be an `ephemeralMessage`/
+ * `viewOnceMessage` wrapper, hence the `normalizeMessageContent` call).
+ *
+ * Exported so `api/index.ts` can decode the quoted payload when
+ * synthesizing the `BotMessage` returned by `getReply()`.
+ */
+export function decodeContent(content) {
+    const m = normalizeMessageContent(content) ?? undefined;
+    let type = "other";
+    let body = "";
+    let mimetype;
+    if (m?.conversation) {
+        type = "text";
+        body = m.conversation;
+    }
+    else if (m?.extendedTextMessage?.text) {
+        type = "text";
+        body = m.extendedTextMessage.text ?? "";
+    }
+    else if (m?.imageMessage) {
+        type = "image";
+        body = m.imageMessage.caption ?? "";
+        mimetype = m.imageMessage.mimetype ?? undefined;
+    }
+    else if (m?.videoMessage) {
+        type = "video";
+        body = m.videoMessage.caption ?? "";
+        mimetype = m.videoMessage.mimetype ?? undefined;
+    }
+    else if (m?.audioMessage) {
+        type = "audio";
+        mimetype = m.audioMessage.mimetype ?? undefined;
+    }
+    else if (m?.documentMessage) {
+        type = "document";
+        body = m.documentMessage.caption ?? "";
+        mimetype = m.documentMessage.mimetype ?? undefined;
+    }
+    else if (m?.stickerMessage) {
+        type = "sticker";
+        mimetype = m.stickerMessage.mimetype ?? undefined;
+    }
+    return { type, body, mimetype };
+}
 export function createBaileysAdapter(initial) {
     // mutable so rebind() can swap it; closure-scoped so the contract below
     // always sees the latest sock.
     let sock = initial.sock;
     const store = initial.store;
     // ── Adapter-local helpers ────────────────────────────────────────────────
+    /**
+     * Build the `quoted` option for `sock.sendMessage(jid, content, opts)`.
+     *
+     * Baileys expects the `quoted` field to be a full message-shaped object —
+     * `{ key: {...}, message: {...} }` — so it can extract both the attribution
+     * (stanzaId/participant/fromMe from `key`) and the preview content (from
+     * `message`) when generating contextInfo. Passing only `key` makes
+     * `generateWAMessageFromContent` call `normalizeMessageContent(undefined)`
+     * → `getContentType(undefined)` → `undefined`, then index it with `[]`
+     * and throw `Cannot read properties of undefined (reading 'undefined')`.
+     *
+     * We resolve the full envelope from the in-memory store, indexed by the
+     * (remoteJid, id) pair carried in the neutral `BotQuotedRef`. If the
+     * envelope is no longer present (evicted past MAX_MSGS_PER_CHAT, lost on
+     * restart, etc.) we return `undefined` rather than emit a half-formed
+     * `quoted` — degrading to a plain unquoted reply is safer than crashing
+     * the calling plugin.
+     */
+    function buildQuotedOpts(quoted) {
+        if (!quoted?.id || !quoted?.remoteJid)
+            return undefined;
+        const raw = store.messages.get(quoted.remoteJid)?.get(quoted.id);
+        const inner = raw?.message;
+        if (!inner)
+            return undefined; // safe fallback: no quoted at all
+        // `quoted` (used by sendMessage for reply-citation) is a
+        // message-shaped object: `{ key: {...}, message: {...} }`. Baileys
+        // reads `quoted.key.*` to populate contextInfo (stanzaId, participant,
+        // fromMe) — passing the fields flat used to misattribute the reply to
+        // the bot itself. `quoted.message` is also required: Baileys' internal
+        // `generateWAMessageFromContent` calls `normalizeMessageContent(
+        // quoted.message)` and indexes the result with `getContentType(...)`,
+        // which throws if `.message` is missing.
+        return { quoted: { key: toFlatKey(quoted), message: inner } };
+    }
+    /**
+     * Translate a neutral `BotQuotedRef` into the FLAT key shape Baileys
+     * expects for `react`/`delete`/`edit`/`readMessages` (proto.IMessageKey
+     * — `{ id, remoteJid, fromMe, participant }` directly, NOT nested under
+     * a `.key` field). The nested `{key, message}` form is reserved for the
+     * `quoted` field on sendMessage — see `buildQuotedOpts` above.
+     */
+    function toFlatKey(ref) {
+        return {
+            id: ref.id ?? null,
+            remoteJid: ref.remoteJid ?? "",
+            fromMe: !!ref.fromMe,
+            participant: ref.participant ?? undefined,
+        };
+    }
     /** Compute sha1-hex of a normalized buffer or string. */
     function sha1(input) {
         const hash = createHash("sha1");
@@ -45,40 +144,7 @@ export function createBaileysAdapter(initial) {
     /** Translate a Baileys WAMessage into the neutral BotMessage envelope. */
     function toBotMessage(msg) {
         const m = normalizeMessageContent(msg.message) ?? undefined;
-        let type = "other";
-        let body = "";
-        let mimetype;
-        if (m?.conversation) {
-            type = "text";
-            body = m.conversation;
-        }
-        else if (m?.extendedTextMessage?.text) {
-            type = "text";
-            body = m.extendedTextMessage.text ?? "";
-        }
-        else if (m?.imageMessage) {
-            type = "image";
-            body = m.imageMessage.caption ?? "";
-            mimetype = m.imageMessage.mimetype ?? undefined;
-        }
-        else if (m?.videoMessage) {
-            type = "video";
-            body = m.videoMessage.caption ?? "";
-            mimetype = m.videoMessage.mimetype ?? undefined;
-        }
-        else if (m?.audioMessage) {
-            type = "audio";
-            mimetype = m.audioMessage.mimetype ?? undefined;
-        }
-        else if (m?.documentMessage) {
-            type = "document";
-            body = m.documentMessage.caption ?? "";
-            mimetype = m.documentMessage.mimetype ?? undefined;
-        }
-        else if (m?.stickerMessage) {
-            type = "sticker";
-            mimetype = m.stickerMessage.mimetype ?? undefined;
-        }
+        const { type, body, mimetype } = decodeContent(msg.message);
         const key = msg.key;
         const contextInfo = m?.extendedTextMessage?.contextInfo ??
             m?.imageMessage?.contextInfo ??
@@ -86,6 +152,7 @@ export function createBaileysAdapter(initial) {
             m?.audioMessage?.contextInfo ??
             m?.documentMessage?.contextInfo ??
             undefined;
+        const ciTyped = contextInfo;
         return {
             id: msg.key.id ?? "",
             chatId: msg.key.remoteJid ?? "",
@@ -96,20 +163,27 @@ export function createBaileysAdapter(initial) {
             body,
             mimetype: mimetype ?? undefined,
             pushName: msg.pushName,
-            mentionedJid: contextInfo?.mentionedJid ?? undefined,
-            quotedKey: contextInfo?.stanzaId ? {
-                id: contextInfo.stanzaId,
+            mentionedJid: ciTyped?.mentionedJid ?? undefined,
+            quotedKey: ciTyped?.stanzaId ? {
+                id: ciTyped.stanzaId,
                 remoteJid: msg.key.remoteJid ?? undefined,
                 fromMe: false,
-                participant: contextInfo.participant ?? undefined,
+                participant: ciTyped.participant ?? undefined,
             } : undefined,
             fromLid: key.participantAlt,
             fromPn: key.participant,
             participantAlt: key.participantAlt,
             remoteJidAlt: key.remoteJidAlt,
-            // Poll-decryption key lives here for poll vote decryption downstream.
+            // Driver-specific escape hatches:
+            //   - pollEncKeyRaw: poll-decryption key for vote decryption
+            //   - contextInfo:   full IContextInfo (incl. embedded quotedMessage)
+            //                    so quoted-message consumers (api/index.ts
+            //                    buildMessageContext / downloadMedia fallback)
+            //                    can decode the quoted payload without going
+            //                    back through the store.
             _raw: {
                 pollEncKeyRaw: m?.messageContextInfo?.messageSecret ?? undefined,
+                contextInfo: ciTyped ?? undefined,
             },
         };
     }
@@ -127,6 +201,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
@@ -237,17 +349,17 @@ export function createBaileysAdapter(initial) {
             return toSentRef(ref, jid);
         },
         async react(jid, target, emoji) {
-            const key = toBaileysKey(target);
+            const key = toFlatKey(target);
             await sock.sendMessage(jid, { react: { text: emoji, key } });
         },
         async deleteMessage(jid, target, forEveryone) {
             if (!forEveryone)
                 return;
-            const key = toBaileysKey(target);
+            const key = toFlatKey(target);
             await sock.sendMessage(jid, { delete: key });
         },
         async editMessage(jid, target, text) {
-            const key = toBaileysKey(target);
+            const key = toFlatKey(target);
             await sock.sendMessage(jid, { text, edit: key });
         },
         // ── presence + read ───────────────────────────────────────────────────
@@ -258,7 +370,7 @@ export function createBaileysAdapter(initial) {
             await sock.sendPresenceUpdate(baileyState, jid);
         },
         async readMessages(keys) {
-            const baileyKeys = keys.map(toBaileysKey);
+            const baileyKeys = keys.map((k) => toFlatKey(k));
             await sock.readMessages(baileyKeys);
         },
         // ── contacts ──────────────────────────────────────────────────────────
@@ -385,10 +497,30 @@ export function createBaileysAdapter(initial) {
         },
         // ── media (download) ───────────────────────────────────────────────────
         async downloadMedia(msg, opts) {
-            // The poll-decryption raw envelope left only what's needed for that,
-            // so to downloadMediaMessage we still need the original WAMessage.
-            // Get it back from the store by id.
-            const raw = store.messages.get(msg.chatId)?.get(msg.id);
+            // Resolve the Baileys message envelope needed by `downloadMediaMessage`.
+            // Preferred path: if the caller already carries the embedded message
+            // payload (synthetic `BotMessage` for a quoted message, whose
+            // `_raw.contextInfo.quotedMessage` is the full WAMessageContent),
+            // build the envelope directly from that. This avoids the silent
+            // failure mode where the quoted message's original envelope has
+            // aged out of the store's per-chat ring buffer.
+            //
+            // Fallback: the regular case (downloading media for the incoming
+            // message itself, or any other BotMessage that has a real envelope
+            // in the store) — look it up by (chatId, id).
+            const embedded = msg._raw;
+            const embeddedContent = embedded?.contextInfo?.quotedMessage;
+            const raw = embeddedContent
+                ? {
+                    key: {
+                        id: embedded.contextInfo?.stanzaId ?? msg.id,
+                        remoteJid: msg.chatId,
+                        fromMe: false,
+                        participant: embedded.contextInfo?.participant ?? undefined,
+                    },
+                    message: embeddedContent,
+                }
+                : store.messages.get(msg.chatId)?.get(msg.id);
             if (!raw)
                 return null;
             try {
@@ -411,6 +543,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) ────────
     //
@@ -434,6 +632,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", {
@@ -448,6 +666,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) });
         });
@@ -458,9 +679,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", {
@@ -508,31 +750,10 @@ export function createBaileysAdapter(initial) {
     };
 }
 // ── Helpers used inside the adapter above ────────────────────────────────────
-function buildQuotedOpts(quoted) {
-    if (!quoted)
-        return undefined;
-    return { quoted: toBaileysKey(quoted) };
-}
-function toBaileysKey(ref) {
-    // Baileys expects `quoted` to be a message-shaped object with these
-    // fields nested under `.key` (quoted.key.id / .remoteJid / .fromMe /
-    // .participant) — it reads quoted.key.* to build contextInfo
-    // (stanzaId, participant, fromMe). Passing them flat (as this used to)
-    // means quoted.key is undefined inside Baileys, so participant/fromMe
-    // resolve to undefined and the quoted reply gets misattributed to the
-    // bot itself instead of the original sender. The quoted text still
-    // rendered before this fix because WhatsApp's client resolves the
-    // preview content locally via stanzaId — only the author attribution
-    // was broken.
-    return {
-        key: {
-            id: ref.id ?? null,
-            remoteJid: ref.remoteJid ?? "",
-            fromMe: !!ref.fromMe,
-            participant: ref.participant ?? undefined,
-        },
-    };
-}
+//
+// `buildQuotedOpts` and `toFlatKey` are defined inside the
+// `createBaileysAdapter` closure (so they can see the `store`) — only
+// `toSentRef` and `silentBaileysLogger` remain module-scoped helpers.
 function toSentRef(raw, fallbackChatId) {
     const r = raw;
     return {