@openclaw/whatsapp 2026.5.2-beta.2 → 2026.5.3-beta.1

package/src/inbound/access-control.ts

@@ -1,237 +0,0 @@
-import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
-import { defaultRuntime } from "openclaw/plugin-sdk/runtime-env";
-import { warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
-import {
-  expandAllowFromWithAccessGroups,
-  readStoreAllowFromForDmPolicy,
-  resolveDmGroupAccessWithLists,
-} from "openclaw/plugin-sdk/security-runtime";
-import { resolveWhatsAppInboundPolicy } from "../inbound-policy.js";
-
-export type InboundAccessControlResult = {
-  allowed: boolean;
-  shouldMarkRead: boolean;
-  isSelfChat: boolean;
-  resolvedAccountId: string;
-};
-
-const PAIRING_REPLY_HISTORY_GRACE_MS = 30_000;
-
-function logWhatsAppVerbose(enabled: boolean | undefined, message: string) {
-  if (!enabled) {
-    return;
-  }
-  defaultRuntime.log(message);
-}
-
-export async function checkInboundAccessControl(params: {
-  cfg: OpenClawConfig;
-  accountId: string;
-  from: string;
-  selfE164: string | null;
-  senderE164: string | null;
-  group: boolean;
-  pushName?: string;
-  isFromMe: boolean;
-  messageTimestampMs?: number;
-  connectedAtMs?: number;
-  pairingGraceMs?: number;
-  verbose?: boolean;
-  sock: {
-    sendMessage: (jid: string, content: { text: string }) => Promise<unknown>;
-  };
-  remoteJid: string;
-}): Promise<InboundAccessControlResult> {
-  const policy = resolveWhatsAppInboundPolicy({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    selfE164: params.selfE164,
-  });
-  const storeAllowFrom = params.group
-    ? []
-    : await readStoreAllowFromForDmPolicy({
-        provider: "whatsapp",
-        accountId: policy.account.accountId,
-        dmPolicy: policy.dmPolicy,
-        shouldRead: policy.shouldReadStorePairingApprovals,
-      });
-  const pairingGraceMs =
-    typeof params.pairingGraceMs === "number" && params.pairingGraceMs > 0
-      ? params.pairingGraceMs
-      : PAIRING_REPLY_HISTORY_GRACE_MS;
-  const suppressPairingReply =
-    typeof params.connectedAtMs === "number" &&
-    typeof params.messageTimestampMs === "number" &&
-    params.messageTimestampMs < params.connectedAtMs - pairingGraceMs;
-
-  // Group policy filtering:
-  // - "open": groups bypass allowFrom, only mention-gating applies
-  // - "disabled": block all group messages entirely
-  // - "allowlist": only allow group messages from senders in groupAllowFrom/allowFrom
-  warnMissingProviderGroupPolicyFallbackOnce({
-    providerMissingFallbackApplied: policy.providerMissingFallbackApplied,
-    providerKey: "whatsapp",
-    accountId: policy.account.accountId,
-    log: (message) => logWhatsAppVerbose(params.verbose, message),
-  });
-  const accessGroupSenderId = params.group ? (params.senderE164 ?? params.from) : params.from;
-  const isAccessGroupSenderAllowed = (senderId: string, allowEntries: string[]) => {
-    return params.group
-      ? policy.isGroupSenderAllowed(allowEntries, senderId)
-      : policy.isDmSenderAllowed(allowEntries, senderId);
-  };
-  const [allowFrom, groupAllowFrom] = await Promise.all([
-    expandAllowFromWithAccessGroups({
-      cfg: params.cfg,
-      allowFrom: params.group ? policy.configuredAllowFrom : policy.dmAllowFrom,
-      channel: "whatsapp",
-      accountId: policy.account.accountId,
-      senderId: accessGroupSenderId,
-      isSenderAllowed: isAccessGroupSenderAllowed,
-    }),
-    expandAllowFromWithAccessGroups({
-      cfg: params.cfg,
-      allowFrom: policy.groupAllowFrom,
-      channel: "whatsapp",
-      accountId: policy.account.accountId,
-      senderId: accessGroupSenderId,
-      isSenderAllowed: isAccessGroupSenderAllowed,
-    }),
-  ]);
-  const dmStoreAllowFrom = params.group
-    ? []
-    : await expandAllowFromWithAccessGroups({
-        cfg: params.cfg,
-        allowFrom: storeAllowFrom,
-        channel: "whatsapp",
-        accountId: policy.account.accountId,
-        senderId: accessGroupSenderId,
-        isSenderAllowed: isAccessGroupSenderAllowed,
-      });
-  const access = resolveDmGroupAccessWithLists({
-    isGroup: params.group,
-    dmPolicy: policy.dmPolicy,
-    groupPolicy: policy.groupPolicy,
-    allowFrom,
-    groupAllowFrom,
-    storeAllowFrom: dmStoreAllowFrom,
-    isSenderAllowed: (allowEntries) => {
-      return params.group
-        ? policy.isGroupSenderAllowed(allowEntries, params.senderE164)
-        : policy.isDmSenderAllowed(allowEntries, params.from);
-    },
-  });
-  if (params.group && access.decision !== "allow") {
-    if (access.reason === "groupPolicy=disabled") {
-      logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: disabled)");
-    } else if (access.reason === "groupPolicy=allowlist (empty allowlist)") {
-      logWhatsAppVerbose(
-        params.verbose,
-        "Blocked group message (groupPolicy: allowlist, no groupAllowFrom)",
-      );
-    } else {
-      logWhatsAppVerbose(
-        params.verbose,
-        `Blocked group message from ${params.senderE164 ?? "unknown sender"} (groupPolicy: allowlist)`,
-      );
-    }
-    return {
-      allowed: false,
-      shouldMarkRead: false,
-      isSelfChat: policy.isSelfChat,
-      resolvedAccountId: policy.account.accountId,
-    };
-  }
-
-  // DM access control (secure defaults): "pairing" (default) / "allowlist" / "open" / "disabled".
-  if (!params.group) {
-    if (params.isFromMe && !policy.isSamePhone(params.from)) {
-      logWhatsAppVerbose(params.verbose, "Skipping outbound DM (fromMe); no pairing reply needed.");
-      return {
-        allowed: false,
-        shouldMarkRead: false,
-        isSelfChat: policy.isSelfChat,
-        resolvedAccountId: policy.account.accountId,
-      };
-    }
-    if (access.decision === "block" && access.reason === "dmPolicy=disabled") {
-      logWhatsAppVerbose(params.verbose, "Blocked dm (dmPolicy: disabled)");
-      return {
-        allowed: false,
-        shouldMarkRead: false,
-        isSelfChat: policy.isSelfChat,
-        resolvedAccountId: policy.account.accountId,
-      };
-    }
-    if (access.decision === "pairing" && !policy.isSamePhone(params.from)) {
-      const candidate = params.from;
-      if (suppressPairingReply) {
-        logWhatsAppVerbose(
-          params.verbose,
-          `Skipping pairing reply for historical DM from ${candidate}.`,
-        );
-      } else {
-        await createChannelPairingChallengeIssuer({
-          channel: "whatsapp",
-          upsertPairingRequest: async ({ id, meta }) =>
-            await upsertChannelPairingRequest({
-              channel: "whatsapp",
-              id,
-              accountId: policy.account.accountId,
-              meta,
-            }),
-        })({
-          senderId: candidate,
-          senderIdLine: `Your WhatsApp phone number: ${candidate}`,
-          meta: { name: (params.pushName ?? "").trim() || undefined },
-          onCreated: () => {
-            logWhatsAppVerbose(
-              params.verbose,
-              `whatsapp pairing request sender=${candidate} name=${params.pushName ?? "unknown"}`,
-            );
-          },
-          sendPairingReply: async (text) => {
-            await params.sock.sendMessage(params.remoteJid, { text });
-          },
-          onReplyError: (err) => {
-            logWhatsAppVerbose(
-              params.verbose,
-              `whatsapp pairing reply failed for ${candidate}: ${String(err)}`,
-            );
-          },
-        });
-      }
-      return {
-        allowed: false,
-        shouldMarkRead: false,
-        isSelfChat: policy.isSelfChat,
-        resolvedAccountId: policy.account.accountId,
-      };
-    }
-    if (access.decision !== "allow") {
-      logWhatsAppVerbose(
-        params.verbose,
-        `Blocked unauthorized sender ${params.from} (dmPolicy=${policy.dmPolicy})`,
-      );
-      return {
-        allowed: false,
-        shouldMarkRead: false,
-        isSelfChat: policy.isSelfChat,
-        resolvedAccountId: policy.account.accountId,
-      };
-    }
-  }
-
-  return {
-    allowed: true,
-    shouldMarkRead: true,
-    isSelfChat: policy.isSelfChat,
-    resolvedAccountId: policy.account.accountId,
-  };
-}
-
-export const __testing = {
-  resolveWhatsAppInboundPolicy,
-};

package/src/inbound/dedupe.ts

@@ -1,132 +0,0 @@
-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

@@ -1,282 +0,0 @@
-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,
-    );
-  });
-});