@openclaw/whatsapp 2026.5.1-beta.1

package/src/inbound/dedupe.ts

@@ -0,0 +1,132 @@
+import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+
+const RECENT_WEB_MESSAGE_TTL_MS = 20 * 60_000;
+const RECENT_WEB_MESSAGE_MAX = 5000;
+const RECENT_OUTBOUND_MESSAGE_TTL_MS = 20 * 60_000;
+const RECENT_OUTBOUND_MESSAGE_MAX = 5000;
+
+const claimableInboundMessages = createClaimableDedupe({
+  ttlMs: RECENT_WEB_MESSAGE_TTL_MS,
+  memoryMaxSize: RECENT_WEB_MESSAGE_MAX,
+});
+const recentOutboundMessages = createRecentMessageCache({
+  ttlMs: RECENT_OUTBOUND_MESSAGE_TTL_MS,
+  maxSize: RECENT_OUTBOUND_MESSAGE_MAX,
+});
+
+function createRecentMessageCache(options: { ttlMs: number; maxSize: number }) {
+  const ttlMs = Math.max(0, options.ttlMs);
+  const maxSize = Math.max(0, Math.floor(options.maxSize));
+  const cache = new Map<string, number>();
+
+  const prune = (now: number) => {
+    if (ttlMs > 0) {
+      const cutoff = now - ttlMs;
+      for (const [key, timestamp] of cache) {
+        if (timestamp < cutoff) {
+          cache.delete(key);
+        }
+      }
+    }
+    while (cache.size > maxSize) {
+      const oldest = cache.keys().next().value;
+      if (!oldest) {
+        break;
+      }
+      cache.delete(oldest);
+    }
+  };
+
+  const peek = (key: string | null, now = Date.now()): boolean => {
+    if (!key) {
+      return false;
+    }
+    const timestamp = cache.get(key);
+    if (timestamp === undefined) {
+      return false;
+    }
+    if (ttlMs > 0 && now - timestamp >= ttlMs) {
+      cache.delete(key);
+      return false;
+    }
+    return true;
+  };
+
+  return {
+    check: (key: string | null, now = Date.now()): boolean => {
+      if (!key) {
+        return false;
+      }
+      const existed = peek(key, now);
+      cache.delete(key);
+      cache.set(key, now);
+      prune(now);
+      return existed;
+    },
+    peek,
+    clear: () => cache.clear(),
+  };
+}
+
+export class WhatsAppRetryableInboundError extends Error {
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = "WhatsAppRetryableInboundError";
+  }
+}
+
+function buildMessageKey(params: {
+  accountId: string;
+  remoteJid: string;
+  messageId: string;
+}): string | null {
+  const accountId = params.accountId.trim();
+  const remoteJid = params.remoteJid.trim();
+  const messageId = params.messageId.trim();
+  if (!accountId || !remoteJid || !messageId || messageId === "unknown") {
+    return null;
+  }
+  return `${accountId}:${remoteJid}:${messageId}`;
+}
+
+export function resetWebInboundDedupe(): void {
+  claimableInboundMessages.clearMemory();
+  recentOutboundMessages.clear();
+}
+
+export async function claimRecentInboundMessage(key: string): Promise<boolean> {
+  const claim = await claimableInboundMessages.claim(key);
+  return claim.kind === "claimed";
+}
+
+export async function commitRecentInboundMessage(key: string): Promise<void> {
+  await claimableInboundMessages.commit(key);
+}
+
+export function releaseRecentInboundMessage(key: string, error?: unknown): void {
+  claimableInboundMessages.release(key, { error });
+}
+
+export function rememberRecentOutboundMessage(params: {
+  accountId: string;
+  remoteJid: string;
+  messageId: string;
+}): void {
+  const key = buildMessageKey(params);
+  if (!key) {
+    return;
+  }
+  recentOutboundMessages.check(key);
+}
+
+export function isRecentOutboundMessage(params: {
+  accountId: string;
+  remoteJid: string;
+  messageId: string;
+}): boolean {
+  const key = buildMessageKey(params);
+  if (!key) {
+    return false;
+  }
+  return recentOutboundMessages.peek(key);
+}

package/src/inbound/extract.test.ts

@@ -0,0 +1,282 @@
+import type { proto } from "@whiskeysockets/baileys";
+import { describe, expect, it } from "vitest";
+import { extractMentionedJids, hasInboundUserContent } from "./extract.js";
+
+describe("extractMentionedJids", () => {
+  const botJid = "5511999999999@s.whatsapp.net";
+  const otherJid = "5511888888888@s.whatsapp.net";
+
+  it("returns direct mentions from the current message", () => {
+    const message: proto.IMessage = {
+      extendedTextMessage: {
+        text: "Hey @bot",
+        contextInfo: {
+          mentionedJid: [botJid],
+        },
+      },
+    };
+    expect(extractMentionedJids(message)).toEqual([botJid]);
+  });
+
+  it("ignores mentionedJids from quoted messages", () => {
+    const message: proto.IMessage = {
+      extendedTextMessage: {
+        text: "I agree",
+        contextInfo: {
+          // The quoted message originally @mentioned the bot, but the
+          // current message does not — this should NOT leak through.
+          quotedMessage: {
+            extendedTextMessage: {
+              text: "Hey @bot what do you think?",
+              contextInfo: {
+                mentionedJid: [botJid],
+              },
+            },
+          },
+        },
+      },
+    };
+    expect(extractMentionedJids(message)).toBeUndefined();
+  });
+
+  it("returns direct mentions even when quoted message also has mentions", () => {
+    const message: proto.IMessage = {
+      extendedTextMessage: {
+        text: "Hey @other",
+        contextInfo: {
+          mentionedJid: [otherJid],
+          quotedMessage: {
+            extendedTextMessage: {
+              text: "Hey @bot",
+              contextInfo: {
+                mentionedJid: [botJid],
+              },
+            },
+          },
+        },
+      },
+    };
+    // Should return only the direct mention, not the quoted one.
+    expect(extractMentionedJids(message)).toEqual([otherJid]);
+  });
+
+  it("returns mentions from media message types", () => {
+    const message: proto.IMessage = {
+      imageMessage: {
+        contextInfo: {
+          mentionedJid: [botJid],
+        },
+      },
+    };
+    expect(extractMentionedJids(message)).toEqual([botJid]);
+  });
+
+  it("returns undefined for messages with no mentions", () => {
+    const message: proto.IMessage = {
+      extendedTextMessage: {
+        text: "Just a regular message",
+      },
+    };
+    expect(extractMentionedJids(message)).toBeUndefined();
+  });
+
+  it("returns undefined for undefined input", () => {
+    expect(extractMentionedJids(undefined)).toBeUndefined();
+  });
+
+  it("deduplicates mentions across message types", () => {
+    const message: proto.IMessage = {
+      extendedTextMessage: {
+        text: "Hey @bot",
+        contextInfo: {
+          mentionedJid: [botJid],
+        },
+      },
+      imageMessage: {
+        contextInfo: {
+          mentionedJid: [botJid],
+        },
+      },
+    };
+    expect(extractMentionedJids(message)).toEqual([botJid]);
+  });
+});
+
+describe("hasInboundUserContent", () => {
+  it("returns true for plain text conversation", () => {
+    expect(hasInboundUserContent({ conversation: "hello" })).toBe(true);
+  });
+
+  it("returns true for extendedTextMessage", () => {
+    expect(
+      hasInboundUserContent({ extendedTextMessage: { text: "hello" } } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for image message", () => {
+    expect(
+      hasInboundUserContent({ imageMessage: { mimetype: "image/png" } } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for video message", () => {
+    expect(
+      hasInboundUserContent({ videoMessage: { mimetype: "video/mp4" } } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for audio message", () => {
+    expect(
+      hasInboundUserContent({ audioMessage: { mimetype: "audio/ogg" } } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for document message", () => {
+    expect(
+      hasInboundUserContent({
+        documentMessage: { fileName: "x.pdf" },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for sticker message", () => {
+    expect(
+      hasInboundUserContent({ stickerMessage: { mimetype: "image/webp" } } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for location message with valid coords", () => {
+    expect(
+      hasInboundUserContent({
+        locationMessage: { degreesLatitude: 1, degreesLongitude: 2 },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for live location message with valid coords", () => {
+    expect(
+      hasInboundUserContent({
+        liveLocationMessage: { degreesLatitude: 1, degreesLongitude: 2 },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for contact message", () => {
+    expect(
+      hasInboundUserContent({
+        contactMessage: { displayName: "Alice", vcard: "BEGIN:VCARD\nEND:VCARD" },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for contactsArrayMessage via contact placeholder extraction", () => {
+    expect(
+      hasInboundUserContent({
+        contactsArrayMessage: {
+          contacts: [{ displayName: "Alice", vcard: "BEGIN:VCARD\nEND:VCARD" }],
+        },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for buttons response (user button click)", () => {
+    expect(
+      hasInboundUserContent({
+        buttonsResponseMessage: {
+          selectedButtonId: "yes",
+          selectedDisplayText: "Yes",
+        },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for list response (user list selection)", () => {
+    expect(
+      hasInboundUserContent({
+        listResponseMessage: {
+          title: "Option A",
+          singleSelectReply: { selectedRowId: "a" },
+        } as unknown as proto.Message.IListResponseMessage,
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for template button reply", () => {
+    expect(
+      hasInboundUserContent({
+        templateButtonReplyMessage: {
+          selectedId: "btn-1",
+          selectedDisplayText: "Click",
+        } as unknown as proto.Message.ITemplateButtonReplyMessage,
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for interactive response", () => {
+    expect(
+      hasInboundUserContent({
+        interactiveResponseMessage: {
+          body: { text: "x" },
+          nativeFlowResponseMessage: { name: "n", paramsJson: "{}" },
+        } as unknown as proto.Message.IInteractiveResponseMessage,
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns true for buttons response wrapped in ephemeralMessage (regression for #73797 + greptile review)", () => {
+    expect(
+      hasInboundUserContent({
+        ephemeralMessage: {
+          message: {
+            buttonsResponseMessage: {
+              selectedButtonId: "ok",
+              selectedDisplayText: "OK",
+            },
+          },
+        },
+      } as proto.IMessage),
+    ).toBe(true);
+  });
+
+  it("returns false for undefined message (regression for #73797)", () => {
+    expect(hasInboundUserContent(undefined)).toBe(false);
+  });
+
+  it("returns false for empty message object (no content keys)", () => {
+    expect(hasInboundUserContent({} as proto.IMessage)).toBe(false);
+  });
+
+  it("returns false for protocol message envelope without inner content (regression for #73797)", () => {
+    expect(
+      hasInboundUserContent({
+        protocolMessage: {
+          type: 0,
+        } as unknown as proto.Message.IProtocolMessage,
+      } as proto.IMessage),
+    ).toBe(false);
+  });
+
+  it("returns false for receipt-style senderKeyDistribution-only payload (regression for #73797)", () => {
+    expect(
+      hasInboundUserContent({
+        senderKeyDistributionMessage: {
+          groupId: "g@example",
+        } as unknown as proto.Message.ISenderKeyDistributionMessage,
+      } as proto.IMessage),
+    ).toBe(false);
+  });
+
+  it("returns false when location coords are missing (incomplete event, regression for #73797)", () => {
+    expect(
+      hasInboundUserContent({
+        locationMessage: { name: "no coords" },
+      } as proto.IMessage),
+    ).toBe(false);
+  });
+
+  it("returns false when extendedTextMessage has only empty text", () => {
+    expect(hasInboundUserContent({ extendedTextMessage: { text: "  " } } as proto.IMessage)).toBe(
+      false,
+    );
+  });
+});