@manybot/manybot 5.9.0 → 5.9.2

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

@@ -178,6 +178,37 @@ function getMsgSenderPn(msg) {
         return normalizeJid(msg.chatId);
     return null;
 }
+/**
+ * Split a quoted message's `contextInfo.participant` into `fromLid`/`fromPn`
+ * the same way the adapter's `toBotMessage()` splits `key.participant` /
+ * `key.participantAlt` via `splitLidPn()` — see the comment there. Unlike
+ * the key, `contextInfo` carries only a single `participant` field (no
+ * companion "Alt"), and it holds whichever form matches the chat's current
+ * addressing mode: under the modern default "lid" mode that's the @lid
+ * form, under legacy "pn" mode it's the phone-number form. Blindly
+ * assigning it to `fromPn` (as the quoted-message synthetic used to)
+ * leaves `fromLid` unset — so `getMsgSender()` (which only reads
+ * `participantAlt`/`fromLid`) falls through to `null` — while
+ * `getMsgSenderPn()` happily normalizes and returns the @lid value
+ * verbatim, since it never checks the suffix. Route by suffix here, and
+ * fill in the other side from the store's learned LID<->PN mapping when
+ * one is known.
+ */
+function splitQuotedParticipant(store, participant) {
+    if (!participant)
+        return {};
+    if (participant.endsWith("@lid")) {
+        const resolved = store.resolveJid(participant);
+        return {
+            fromLid: participant,
+            fromPn: resolved !== participant ? resolved : undefined,
+        };
+    }
+    return {
+        fromLid: store.resolvePn(participant) ?? undefined,
+        fromPn: participant,
+    };
+}
 /** Quoted-message metadata as the rest of the api uses it. */
 function getQuotedContext(msg) {
     if (!msg.quotedKey)
@@ -935,16 +966,33 @@ export function buildMessageContext(msg, contract, store, guardOptions = {}) {
     const quotedRaw = contextInfo?.quotedMessage
         ? (() => {
             const decoded = decodeContent(contextInfo.quotedMessage);
+            const { fromLid: quotedFromLid, fromPn: quotedFromPn } = splitQuotedParticipant(store, contextInfo.participant);
+            // contextInfo itself never carries the quoted message's original
+            // send time (WhatsApp's ContextInfo proto has no timestamp field —
+            // only stanzaId/participant/quotedMessage). Best-effort recover it
+            // from the message store, keyed by the same chatId+stanzaId, when
+            // the original is still cached (it usually is, since a reply
+            // almost always quotes a recent message in the same chat). Stays
+            // 0 — same as before — only when the original has aged out of the
+            // store's per-chat cap or the chat history hasn't been seen yet.
+            const quotedOriginal = contextInfo.stanzaId
+                ? store.messages.get(msg.chatId)?.get(contextInfo.stanzaId)
+                : undefined;
+            const quotedTimestamp = quotedOriginal
+                ? Number(quotedOriginal.messageTimestamp ?? 0) * 1000
+                : 0;
             return {
                 id: contextInfo.stanzaId ?? "",
                 chatId: msg.chatId,
                 fromMe: false,
                 type: decoded.type,
                 contentHash: "",
-                timestamp: 0,
+                timestamp: quotedTimestamp,
                 body: decoded.body,
                 mimetype: decoded.mimetype,
-                fromPn: contextInfo.participant ?? undefined,
+                fromLid: quotedFromLid,
+                fromPn: quotedFromPn,
+                participantAlt: quotedFromLid,
                 pushName: lookupPushName(contextInfo.participant),
                 _raw: {
                     contextInfo: {
@@ -962,16 +1010,27 @@ export function buildMessageContext(msg, contract, store, guardOptions = {}) {
             // key-only synthetic so hasReply()/getReply() still work, but
             // hasMedia/downloadMedia on the result will degrade gracefully
             // (type=other, mimetype=undefined).
-            ? {
-                id: msg.quotedKey.id ?? "",
-                chatId: msg.chatId,
-                fromMe: false,
-                type: "other",
-                contentHash: "",
-                timestamp: 0,
-                fromPn: msg.quotedKey.participant ?? undefined,
-                pushName: lookupPushName(msg.quotedKey.participant),
-            }
+            ? (() => {
+                const { fromLid: quotedFromLid, fromPn: quotedFromPn } = splitQuotedParticipant(store, msg.quotedKey.participant);
+                const quotedOriginal = msg.quotedKey.id
+                    ? store.messages.get(msg.chatId)?.get(msg.quotedKey.id)
+                    : undefined;
+                const quotedTimestamp = quotedOriginal
+                    ? Number(quotedOriginal.messageTimestamp ?? 0) * 1000
+                    : 0;
+                return {
+                    id: msg.quotedKey.id ?? "",
+                    chatId: msg.chatId,
+                    fromMe: false,
+                    type: "other",
+                    contentHash: "",
+                    timestamp: quotedTimestamp,
+                    fromLid: quotedFromLid,
+                    fromPn: quotedFromPn,
+                    participantAlt: quotedFromLid,
+                    pushName: lookupPushName(msg.quotedKey.participant),
+                };
+            })()
             : null;
     return {
         id: msg.id,
@@ -1680,15 +1739,26 @@ function buildAdminApi(contract, store, chatJid) {
     const botJid = me.id ? normalizeJid(jidNormalizedUser(me.id)) : null;
     const botLid = me.lid ? normalizeJid(me.lid) : null;
     /**
-     * Resolve admin-supplied identifiers (bare phone number, @c.us,
-     * @s.whatsapp.net, or @lid) to the exact jid WhatsApp has on file for
-     * that participant *in this group*. A naive toWireJid() guess is only
-     * correct for pn-addressed groups — lid-addressed groups (increasingly
-     * common, e.g. when a member hides their phone number) only recognize
-     * that member by @lid, which a phone number typed by the admin can't
-     * produce on its own. Baileys' raw groupMetadata() participants carry
-     * `id` (whatever WA addresses them as here), `jid` (its best
-     * phone-number guess) and `lid` — check all three.
+     * Resolve admin-supplied identifiers (bare phone number, bare LID,
+     * @c.us, @s.whatsapp.net, or @lid) to the exact jid WhatsApp has on
+     * file for that participant *in this group*. A naive toWireJid() guess
+     * is only correct for pn-addressed groups — lid-addressed groups
+     * (increasingly common, e.g. when a member hides their phone number)
+     * only recognize that member by @lid, which a phone number typed by
+     * the admin can't produce on its own. Baileys' raw groupMetadata()
+     * participants carry `id` (whatever WA addresses them as here), `jid`
+     * (its best phone-number guess) and `lid` — check all three.
+     *
+     * When the identifier has no explicit domain (the admin typed a bare
+     * number), we don't know if it's a PN or a LID — toWireJid() would
+     * silently guess PN, which never matches a participant that's only
+     * addressable by @lid even when the digits are identical (e.g. typed
+     * "118077710708981", the actual member is "118077710708981@lid"). In
+     * that case, compare by digits alone against id/jid/lid instead of
+     * forcing a domain. When the identifier *does* carry an explicit
+     * domain (@c.us, @s.whatsapp.net, @lid), the domain is meaningful
+     * (disambiguates a PN from a same-digit LID) and the original
+     * wire/resolved comparison is used as before.
      *
      * Throws per-identifier if it doesn't match a current member, instead
      * of silently sending a guessed jid that WhatsApp rejects deep inside
@@ -1698,14 +1768,23 @@ function buildAdminApi(contract, store, chatJid) {
         const meta = await getGroupMetadataCached(contract, groupJid);
         const out = [];
         for (const id of identifiers) {
+            const hasExplicitDomain = /@(s\.whatsapp\.net|lid|g\.us|c\.us)$/.test(id.trim());
             const wire = toWireJid(id);
             const resolved = normalizeJid(store.resolveJid(id));
+            const idDigits = id.replace(/\D/g, "");
             const match = meta.participants.find((p) => {
                 const pAny = p;
-                return (toWireJid(pAny.id) === wire ||
-                    normalizeJid(store.resolveJid(pAny.id)) === resolved ||
-                    (pAny.jid ? toWireJid(pAny.jid) === wire : false) ||
-                    (pAny.lid ? toWireJid(pAny.lid) === wire : false));
+                if (hasExplicitDomain) {
+                    return (toWireJid(pAny.id) === wire ||
+                        normalizeJid(store.resolveJid(pAny.id)) === resolved ||
+                        (pAny.jid ? toWireJid(pAny.jid) === wire : false) ||
+                        (pAny.lid ? toWireJid(pAny.lid) === wire : false));
+                }
+                // Bare number, no domain hint: match by digits against id/jid/lid,
+                // instead of assuming a PN domain that may not be the one WhatsApp
+                // actually uses for this participant (see PN-vs-LID note above).
+                const cands = [pAny.id, pAny.jid, pAny.lid].filter((v) => !!v);
+                return idDigits.length > 0 && cands.some((c) => c.replace(/\D/g, "") === idDigits);
             });
             if (!match) {
                 throw new Error(t("driver.groupParticipantNotFound", { id, group: groupJid }));

package/package.json

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