@manybot/manybot 5.6.1 → 5.7.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";
 /**
@@ -201,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
@@ -505,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) ────────
     //
@@ -528,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", {
@@ -542,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) });
         });
@@ -552,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", {

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

@@ -28,7 +28,7 @@ import { waitForSendSlot, simulateState, typingDuration, mediaDuration, waitForE
 import { sendWithFallback } from "#kernel/sendFallbackGuard.js";
 import { buildSettingsApi } from "#settingsdb";
 import WebP from "node-webpmux";
-import { getAggregateVotesInPollMessage, decryptPollVote, jidNormalizedUser, } from "@whiskeysockets/baileys";
+import { jidNormalizedUser, } from "@whiskeysockets/baileys";
 // ── Raw-Baileys escape hatch ─────────────────────────────────────────────────
 //
 // This whole file is the Baileys driver's plugin-context builder, so the
@@ -223,11 +223,11 @@ function bindGroupMetaInvalidation(contract) {
     if (groupMetaInvalidationBound)
         return;
     groupMetaInvalidationBound = true;
-    const sock = rawSocketOf(contract);
-    const ev = sock.ev;
-    ev.on("group-participants.update", (u) => groupMetaCache.delete(u.id));
-    ev.on("groups.update", (updates) => {
-        for (const u of updates)
+    contract.on("group-participants.update", (u) => {
+        groupMetaCache.delete(u.id);
+    });
+    contract.on("groups.update", (p) => {
+        for (const u of p.updates)
             if (u.id)
                 groupMetaCache.delete(u.id);
     });
@@ -1321,20 +1321,58 @@ function buildSetupSendApi(contract, store) {
         },
     };
 }
-// ── Events API ────────────────────────────────────────────────────────────────
+const WA_EVENT_NAMES = new Set([
+    "messages.upsert",
+    "messages.update",
+    "messages.delete",
+    "messaging-history.set",
+    "chats.upsert",
+    "chats.update",
+    "chats.delete",
+    "contacts.upsert",
+    "contacts.update",
+    "group-participants.update",
+    "groups.upsert",
+    "groups.update",
+    "group.join-request",
+    "blocklist.set",
+    "blocklist.update",
+    "connection.update",
+]);
+function assertSupportedEvent(event) {
+    if (!WA_EVENT_NAMES.has(event)) {
+        throw new Error(`[events] unsupported event "${event}". Supported: ${[...WA_EVENT_NAMES].join(", ")}. ` +
+            `If you need this event, file an issue — adding events to WaEventName is a contract change.`);
+    }
+}
 const listenerRegistry = new Map();
-export function cleanupPluginEvents(pluginName, contract) {
-    const sock = rawSocketOf(contract);
+export function cleanupPluginEvents(pluginName, _contract) {
     const list = listenerRegistry.get(pluginName);
     if (list) {
-        for (const { event, handler } of list) {
+        for (const ref of list) {
             try {
-                sock.ev.off(event, handler);
+                ref.detach();
             }
             catch { }
         }
         listenerRegistry.delete(pluginName);
     }
+    // The poll-vote subscription is created in `buildPollApi` by calling
+    // `contract.on(...)` directly, so it lives outside `listenerRegistry`.
+    // Detach it here so the listener doesn't outlive the plugin (and a
+    // reloaded plugin can re-subscribe — `buildPollApi` gates on the
+    // `boundPollPlugins` map).
+    const pollDetach = boundPollPlugins.get(pluginName);
+    if (pollDetach) {
+        try {
+            pollDetach();
+        }
+        catch { }
+        boundPollPlugins.delete(pluginName);
+    }
+    // Drop the per-plugin poll registry so reloading a plugin doesn't see
+    // stale PollHandles from a prior instance.
+    pollRegistry.delete(pluginName);
     cancelPlugin(pluginName);
 }
 /**
@@ -1342,21 +1380,26 @@ export function cleanupPluginEvents(pluginName, contract) {
  * @param {string}     pluginName
  */
 function buildEventsApi(contract, pluginName) {
-    const sock = rawSocketOf(contract);
     return {
         on(event, handler) {
-            sock.ev.on(event, handler);
+            assertSupportedEvent(event);
+            const wrapped = (payload) => handler(payload);
+            const detach = contract.on(event, wrapped);
             if (!listenerRegistry.has(pluginName))
                 listenerRegistry.set(pluginName, new Set());
-            const ref = { event, handler };
+            const ref = { event, handler: wrapped, detach };
             listenerRegistry.get(pluginName).add(ref);
             return () => {
-                sock.ev.off(event, handler);
+                try {
+                    detach();
+                }
+                catch { }
                 listenerRegistry.get(pluginName)?.delete(ref);
             };
         },
         once(event) {
-            return new Promise(resolve => {
+            assertSupportedEvent(event);
+            return new Promise((resolve) => {
                 const off = this.on(event, (data) => { off(); resolve(data); });
             });
         },
@@ -1364,8 +1407,12 @@ function buildEventsApi(contract, pluginName) {
             const list = listenerRegistry.get(pluginName);
             if (!list)
                 return;
-            for (const { event, handler } of list)
-                sock.ev.off(event, handler);
+            for (const ref of list) {
+                try {
+                    ref.detach();
+                }
+                catch { }
+            }
             listenerRegistry.delete(pluginName);
         },
     };
@@ -1563,11 +1610,15 @@ function buildMeApi(contract) {
 }
 // ── Poll API ──────────────────────────────────────────────────────────────────
 const pollRegistry = new Map();
-// Rebinding must happen per socket instance — a plugin name alone doesn't
-// tell us whether the listener is bound to the CURRENT (post-reconnect)
-// sock.ev or a dead one from before. WeakMap keyed by sock lets old
-// entries fall off automatically once that socket is garbage collected.
-const pollListenersBySocket = new WeakMap();
+// Per-process map of plugin names whose poll-vote subscription is bound,
+// to its unsubscribe handle. The contract handles rebinding to a fresh
+// socket on reconnect (its `on()` returns an unsubscribe that drops
+// cleanly on the dead socket's fan-out once it's torn down), so a simple
+// per-process map is enough — no per-sock WeakMap needed anymore.
+// `cleanupPluginEvents` MUST call the stored detach handle on unload so
+// the listener doesn't outlive the plugin and so a reloaded plugin can
+// re-subscribe.
+const boundPollPlugins = new Map();
 /**
  * Tracks votes for an active poll.
  * Obtained via ctx.poll.create().
@@ -1638,59 +1689,29 @@ function buildPollApi(contract, store, rawJid, guardOptions, pluginName) {
         pollRegistry.set(pluginName, new Map());
     const registry = pollRegistry.get(pluginName);
     // Keyed by creationId -> (voterKey -> latest vote entry). WhatsApp resends
-    // the *entire current selection* on every tap (not a diff), and Baileys'
-    // getAggregateVotesInPollMessage() replays whatever pollUpdates you give it
-    // with no dedup — so we must keep only the latest entry per voter ourselves,
-    // or retracted/changed votes keep counting alongside the new one.
+    // the *entire current selection* on every tap (not a diff), and the
+    // aggregatePollVotes() contract method replays whatever pollUpdates you
+    // give it with no dedup — so we must keep only the latest entry per
+    // voter ourselves, or retracted/changed votes keep counting alongside
+    // the new one.
     const pollVotesByCreationId = new Map();
-    // Poll decryption needs the raw Baileys socket (sock.ev for
-    // messages.upsert, sock.user for self-JID shape), so we lift it off the
-    // contract here. The WeakMap key is the socket itself so old listeners
-    // fall off automatically when the socket is replaced (reconnect).
-    const sock = rawSocketOf(contract);
-    let boundPlugins = pollListenersBySocket.get(sock);
-    if (!boundPlugins) {
-        boundPlugins = new Set();
-        pollListenersBySocket.set(sock, boundPlugins);
-    }
-    if (!boundPlugins.has(pluginName)) {
-        boundPlugins.add(pluginName);
-        const meId = sock.user?.id ? jidNormalizedUser(sock.user.id) : "me";
-        // WhatsApp doesn't consistently use the same JID shape (LID vs PN) for
-        // pollCreatorJid/voterJid 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 (as the old resolveAuthor
-        // did, always preferring participantPn) causes AES-GCM auth failures
-        // whenever WhatsApp actually used the LID for that message. Instead,
-        // gather every plausible JID for each side and brute-force combinations
-        // until one decrypts successfully — see
-        // https://github.com/WhiskeySockets/Baileys/issues/2342 and #1678.
-        function jidCandidates(key) {
-            const cands = [];
-            if (key.fromMe) {
-                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)));
-        }
-        sock.ev.on("messages.upsert", async ({ messages: msgs }) => {
+    // Poll decryption is Baileys-specific. Both the subscription
+    // (`messages.upsert`) and the decryption/aggregation go through the
+    // contract — `buildPollApi` doesn't touch the raw socket anymore. The
+    // contract's optional methods are only implemented by the Baileys
+    // adapter; drivers that don't have poll decryption leave them off the
+    // contract and we silently no-op here (a bot on a non-Baileys driver
+    // simply can't track poll votes).
+    if (!boundPollPlugins.has(pluginName) &&
+        typeof contract.decryptPollVote === "function" &&
+        typeof contract.aggregatePollVotes === "function") {
+        const detach = contract.on("messages.upsert", async ({ messages: msgs }) => {
             for (const msg of msgs) {
-                const pum = msg.message?.pollUpdateMessage;
+                // Filter poll-update messages by reading the raw envelope from
+                // the store (the neutral `BotMessage` doesn't carry the
+                // `pollUpdateMessage` field — it's a Baileys-proto detail).
+                const raw = store.messages.get(msg.chatId)?.get(msg.id);
+                const pum = raw?.message?.pollUpdateMessage;
                 if (!pum)
                     continue;
                 const creationKey = pum.pollCreationMessageKey;
@@ -1703,44 +1724,44 @@ function buildPollApi(contract, store, rawJid, guardOptions, pluginName) {
                 if (!storeMsg || !pollEncKeyRaw || !pum.vote)
                     continue;
                 try {
-                    const pollEncKey = Buffer.isBuffer(pollEncKeyRaw)
-                        ? pollEncKeyRaw
-                        : Buffer.from(pollEncKeyRaw, "base64");
-                    const creatorCandidates = jidCandidates((creationKey ?? {}));
-                    const voterCandidates = jidCandidates(msg.key);
-                    let decryptedVote;
-                    for (const pollCreatorJid of creatorCandidates) {
-                        for (const voterJid of voterCandidates) {
-                            try {
-                                decryptedVote = decryptPollVote(pum.vote, {
-                                    pollEncKey,
-                                    pollCreatorJid,
-                                    pollMsgId: creationId,
-                                    voterJid,
-                                });
-                                break;
-                            }
-                            catch {
-                                // try next JID combination
-                            }
-                        }
-                        if (decryptedVote)
-                            break;
-                    }
-                    if (!decryptedVote) {
-                        throw new Error(`all JID combinations failed (creator=${JSON.stringify(creatorCandidates)}, voter=${JSON.stringify(voterCandidates)})`);
+                    const decrypted = await contract.decryptPollVote({
+                        voteKey: {
+                            id: msg.id,
+                            remoteJid: msg.chatId,
+                            fromMe: msg.fromMe,
+                            participant: msg.participantAlt ?? msg.fromLid ?? msg.fromPn ?? null,
+                        },
+                        pollKey: {
+                            id: creationId,
+                            remoteJid: creationKey?.remoteJid ?? null,
+                            fromMe: null,
+                            participant: creationKey?.participant ?? null,
+                        },
+                        pollEncKey: pollEncKeyRaw,
+                    });
+                    if (!decrypted) {
+                        throw new Error("decryptPollVote returned null — JID candidate exhaustion or stale enc key");
                     }
-                    const voterKey = msg.key.fromMe
-                        ? meId
-                        : jidNormalizedUser(msg.key.participant ?? msg.key.remoteJid ?? "");
+                    const voterKey = msg.fromMe
+                        ? (contract.me().id ?? "me")
+                        : jidNormalizedUser(msg.participantAlt ?? msg.fromLid ?? msg.chatId);
                     const votesByVoter = pollVotesByCreationId.get(creationId) ?? new Map();
                     votesByVoter.set(voterKey, {
-                        pollUpdateMessageKey: msg.key,
-                        vote: decryptedVote,
+                        pollUpdateMessageKey: { id: msg.id, remoteJid: msg.chatId, fromMe: msg.fromMe },
+                        vote: decrypted,
                         senderTimestampMs: pum.senderTimestampMs,
                     });
                     pollVotesByCreationId.set(creationId, votesByVoter);
-                    const aggregated = getAggregateVotesInPollMessage({ message: storeMsg.message, pollUpdates: Array.from(votesByVoter.values()) }, meId);
+                    const pollAggregateOpts = contract.aggregatePollVotes;
+                    const aggregated = pollAggregateOpts({
+                        pollKey: {
+                            id: creationId,
+                            remoteJid: creationKey?.remoteJid ?? null,
+                            fromMe: null,
+                        },
+                        votes: Array.from(votesByVoter.values()).map((v) => v.vote),
+                        selfJid: contract.me().id ?? undefined,
+                    });
                     handle._updateFromAggregated(aggregated);
                 }
                 catch (err) {
@@ -1748,6 +1769,7 @@ function buildPollApi(contract, store, rawJid, guardOptions, pluginName) {
                 }
             }
         });
+        boundPollPlugins.set(pluginName, detach);
     }
     const cooldown = (guardOptions.cooldown ?? true);
     const jitter = (guardOptions.jitter ?? true);

package/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.6.1",
+  "version": "5.7.0",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
@@ -40,7 +40,7 @@
     "@grpc/grpc-js": "^1.14.4",
     "@grpc/proto-loader": "^0.7.15",
     "@hapi/boom": "^10.0.1",
-    "@whiskeysockets/baileys": "6.7.23",
+    "@whiskeysockets/baileys": "6.7.24",
     "node-cron": "^4.6.0",
     "node-webpmux": "^3.2.1",
     "nodemailer": "^9.0.3",