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

package/src/monitor-inbox.test-harness.ts

@@ -1,304 +0,0 @@
-import { EventEmitter } from "node:events";
-import fsSync from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { resetLogger, setLoggerOverride } from "openclaw/plugin-sdk/runtime-env";
-import { afterEach, beforeEach, expect, vi } from "vitest";
-import {
-  loadConfigMock,
-  readAllowFromStoreMock as pairingReadAllowFromStoreMock,
-  resetPairingSecurityMocks,
-  upsertPairingRequestMock as pairingUpsertPairingRequestMock,
-} from "./pairing-security.test-harness.js";
-
-// Avoid exporting vitest mock types (TS2742 under pnpm + d.ts emit).
-type AnyMockFn = any;
-
-export const DEFAULT_ACCOUNT_ID = "default";
-
-export const DEFAULT_WEB_INBOX_CONFIG = {
-  channels: {
-    whatsapp: {
-      // Allow all in tests by default.
-      allowFrom: ["*"],
-    },
-  },
-  messages: {
-    messagePrefix: undefined,
-    responsePrefix: undefined,
-  },
-} as const;
-export const mockLoadConfig: typeof loadConfigMock = loadConfigMock;
-export const readAllowFromStoreMock = pairingReadAllowFromStoreMock;
-export const upsertPairingRequestMock = pairingUpsertPairingRequestMock;
-
-export type MockSock = {
-  ev: EventEmitter;
-  end: AnyMockFn;
-  ws: { close: AnyMockFn };
-  sendPresenceUpdate: AnyMockFn;
-  sendMessage: AnyMockFn;
-  readMessages: AnyMockFn;
-  groupMetadata: AnyMockFn;
-  groupFetchAllParticipating: AnyMockFn;
-  updateMediaMessage: AnyMockFn;
-  logger: Record<string, unknown>;
-  signalRepository: {
-    lidMapping: {
-      getPNForLID: AnyMockFn;
-    };
-  };
-  user: { id: string };
-};
-
-const sessionState = vi.hoisted(() => ({
-  sock: undefined as MockSock | undefined,
-}));
-
-const inboundRuntimeMocks = vi.hoisted(() => {
-  const wrapperKeys = [
-    "ephemeralMessage",
-    "viewOnceMessage",
-    "viewOnceMessageV2",
-    "viewOnceMessageV2Extension",
-    "documentWithCaptionMessage",
-  ] as const;
-
-  function normalizeMessageContent(message: unknown): unknown {
-    let current = message;
-    while (current && typeof current === "object") {
-      const record = current as Record<string, unknown>;
-      const wrapper = wrapperKeys
-        .map((key) => record[key])
-        .find(
-          (candidate): candidate is { message: unknown } =>
-            Boolean(candidate) &&
-            typeof candidate === "object" &&
-            "message" in (candidate as Record<string, unknown>) &&
-            Boolean((candidate as { message?: unknown }).message),
-        );
-      if (!wrapper) {
-        break;
-      }
-      current = wrapper.message;
-    }
-    return current;
-  }
-
-  return {
-    downloadMediaMessage: vi.fn().mockResolvedValue(Buffer.from("fake-media-data")),
-    isJidGroup: vi.fn((jid: string | undefined | null) =>
-      typeof jid === "string" ? jid.endsWith("@g.us") : false,
-    ),
-    normalizeMessageContent: vi.fn(normalizeMessageContent),
-    saveMediaBuffer: vi.fn().mockResolvedValue({
-      id: "mid",
-      path: "/tmp/mid",
-      size: 1,
-      contentType: "image/jpeg",
-    }),
-  };
-});
-
-function createResolvedMock() {
-  return vi.fn().mockResolvedValue(undefined);
-}
-
-function createMockSock(): MockSock {
-  const ev = new EventEmitter();
-  return {
-    ev,
-    end: vi.fn(),
-    ws: { close: vi.fn() },
-    sendPresenceUpdate: createResolvedMock(),
-    sendMessage: createResolvedMock(),
-    readMessages: createResolvedMock(),
-    groupMetadata: vi.fn().mockImplementation(async (jid: string) => ({
-      id: jid,
-      subject: "Test Group",
-      owner: undefined,
-      participants: [],
-    })),
-    groupFetchAllParticipating: vi.fn().mockResolvedValue({}),
-    updateMediaMessage: vi.fn(),
-    logger: {},
-    signalRepository: {
-      lidMapping: {
-        getPNForLID: vi.fn().mockResolvedValue(null),
-      },
-    },
-    user: { id: "123@s.whatsapp.net" },
-  };
-}
-
-vi.mock("./inbound/runtime-api.js", () => {
-  return {
-    DisconnectReason: { loggedOut: 401 },
-    ...inboundRuntimeMocks,
-  };
-});
-
-vi.mock("./session.js", async () => {
-  return {
-    createWaSocket: vi.fn().mockImplementation(async () => {
-      if (!sessionState.sock) {
-        throw new Error("mock WhatsApp socket not initialized");
-      }
-      return sessionState.sock;
-    }),
-    waitForWaConnection: vi.fn().mockResolvedValue(undefined),
-    getStatusCode: vi.fn(() => 500),
-    formatError: (err: unknown) => (err instanceof Error ? err.message : String(err)),
-  };
-});
-
-export function getSock(): MockSock {
-  if (!sessionState.sock) {
-    throw new Error("mock WhatsApp socket not initialized");
-  }
-  return sessionState.sock;
-}
-
-type MonitorWebInbox = typeof import("./inbound.js").monitorWebInbox;
-type ResetWebInboundDedupe = typeof import("./inbound.js").resetWebInboundDedupe;
-export type InboxOnMessage = NonNullable<Parameters<MonitorWebInbox>[0]["onMessage"]>;
-export type InboxMonitorOptions = Parameters<MonitorWebInbox>[0];
-let monitorWebInbox: MonitorWebInbox;
-let resetWebInboundDedupe: ResetWebInboundDedupe;
-
-function expectInboxPairingReplyText(
-  text: string,
-  params: {
-    channel: string;
-    idLine: string;
-    code?: string;
-  },
-): string {
-  const code = text.match(/Pairing code:\s*```[\r\n]+([A-Z2-9]{6,})/)?.[1];
-  expect(code).toBeDefined();
-  const resolvedCode = params.code ?? code ?? "";
-  expect(text).toContain("OpenClaw: access not configured.");
-  expect(text).toContain(params.idLine);
-  expect(text).toContain("Pairing code:");
-  expect(text).toContain(`\n\`\`\`\n${resolvedCode}\n\`\`\`\n`);
-  expect(text).toContain(`pairing approve ${params.channel} ${resolvedCode}`);
-  return resolvedCode;
-}
-
-export function getMonitorWebInbox(): MonitorWebInbox {
-  if (!monitorWebInbox) {
-    throw new Error("monitorWebInbox not initialized");
-  }
-  return monitorWebInbox;
-}
-
-export async function settleInboundWork() {
-  await new Promise((resolve) => setImmediate(resolve));
-  await new Promise((resolve) => setImmediate(resolve));
-}
-
-export async function waitForMessageCalls(onMessage: ReturnType<typeof vi.fn>, count: number) {
-  await vi.waitFor(
-    () => {
-      expect(onMessage).toHaveBeenCalledTimes(count);
-    },
-    // Channel-suite workers can be saturated under no-isolate CI runs.
-    { timeout: 5_000, interval: 5 },
-  );
-}
-
-export async function startInboxMonitor(
-  onMessage: InboxOnMessage,
-  extraOptions: Partial<InboxMonitorOptions> = {},
-) {
-  if (!monitorWebInbox) {
-    ({ monitorWebInbox } = await import("./inbound.js"));
-  }
-  const listener = await monitorWebInbox({
-    cfg: mockLoadConfig() as never,
-    verbose: false,
-    onMessage,
-    accountId: DEFAULT_ACCOUNT_ID,
-    authDir: getAuthDir(),
-    ...extraOptions,
-  });
-  return { listener, sock: getSock() };
-}
-
-export function buildNotifyMessageUpsert(params: {
-  id: string;
-  remoteJid: string;
-  text: string;
-  timestamp: number;
-  pushName?: string;
-  participant?: string;
-}) {
-  return {
-    type: "notify",
-    messages: [
-      {
-        key: {
-          id: params.id,
-          fromMe: false,
-          remoteJid: params.remoteJid,
-          participant: params.participant,
-        },
-        message: { conversation: params.text },
-        messageTimestamp: params.timestamp,
-        pushName: params.pushName,
-      },
-    ],
-  };
-}
-
-export function expectPairingPromptSent(sock: MockSock, jid: string, senderE164: string) {
-  expect(sock.sendMessage).toHaveBeenCalledTimes(1);
-  const sendCall = sock.sendMessage.mock.calls[0];
-  expect(sendCall?.[0]).toBe(jid);
-  expectInboxPairingReplyText((sendCall?.[1] as { text?: string } | undefined)?.text ?? "", {
-    channel: "whatsapp",
-    idLine: `Your WhatsApp phone number: ${senderE164}`,
-    code: "PAIRCODE",
-  });
-}
-
-let authDir: string | undefined;
-
-export function getAuthDir(): string {
-  if (!authDir) {
-    throw new Error("authDir not initialized; call installWebMonitorInboxUnitTestHooks()");
-  }
-  return authDir;
-}
-
-export function installWebMonitorInboxUnitTestHooks(opts?: { authDir?: boolean }) {
-  const createAuthDir = opts?.authDir ?? true;
-
-  beforeEach(async () => {
-    vi.useRealTimers();
-    vi.clearAllMocks();
-    sessionState.sock = createMockSock();
-    resetPairingSecurityMocks(DEFAULT_WEB_INBOX_CONFIG);
-    if (!monitorWebInbox || !resetWebInboundDedupe) {
-      const inboundModule = await import("./inbound.js");
-      monitorWebInbox = inboundModule.monitorWebInbox;
-      resetWebInboundDedupe = inboundModule.resetWebInboundDedupe;
-    }
-    resetWebInboundDedupe();
-    if (createAuthDir) {
-      authDir = fsSync.mkdtempSync(path.join(os.tmpdir(), "openclaw-auth-"));
-    } else {
-      authDir = undefined;
-    }
-  });
-
-  afterEach(() => {
-    resetLogger();
-    setLoggerOverride(null);
-    vi.useRealTimers();
-    if (authDir) {
-      fsSync.rmSync(authDir, { recursive: true, force: true });
-      authDir = undefined;
-    }
-  });
-}

package/src/normalize-target.ts

@@ -1,112 +0,0 @@
-import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-
-const WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
-const WHATSAPP_LEGACY_USER_JID_RE = /^(\d+)@c\.us$/i;
-const WHATSAPP_LID_RE = /^(\d+)@lid$/i;
-const NON_WHATSAPP_PROVIDER_PREFIX_RE = /^[a-z][a-z0-9-]*:/i;
-
-function stripWhatsAppTargetPrefixes(value: string): string {
-  let candidate = value.trim();
-  for (;;) {
-    const before = candidate;
-    candidate = candidate.replace(/^whatsapp:/i, "").trim();
-    if (candidate === before) {
-      return candidate;
-    }
-  }
-}
-
-export function isWhatsAppGroupJid(value: string): boolean {
-  const candidate = stripWhatsAppTargetPrefixes(value);
-  const lower = normalizeLowercaseStringOrEmpty(candidate);
-  if (!lower.endsWith("@g.us")) {
-    return false;
-  }
-  const localPart = candidate.slice(0, candidate.length - "@g.us".length);
-  if (!localPart || localPart.includes("@")) {
-    return false;
-  }
-  return /^[0-9]+(-[0-9]+)*$/.test(localPart);
-}
-
-export function isWhatsAppUserTarget(value: string): boolean {
-  const candidate = stripWhatsAppTargetPrefixes(value);
-  return (
-    WHATSAPP_USER_JID_RE.test(candidate) ||
-    WHATSAPP_LEGACY_USER_JID_RE.test(candidate) ||
-    WHATSAPP_LID_RE.test(candidate)
-  );
-}
-
-function extractUserJidPhone(jid: string): string | null {
-  const userMatch = jid.match(WHATSAPP_USER_JID_RE);
-  if (userMatch) {
-    return userMatch[1];
-  }
-  const legacyUserMatch = jid.match(WHATSAPP_LEGACY_USER_JID_RE);
-  if (legacyUserMatch) {
-    return legacyUserMatch[1];
-  }
-  const lidMatch = jid.match(WHATSAPP_LID_RE);
-  if (lidMatch) {
-    return lidMatch[1];
-  }
-  return null;
-}
-
-export function normalizeWhatsAppTarget(value: string): string | null {
-  const candidate = stripWhatsAppTargetPrefixes(value);
-  if (!candidate) {
-    return null;
-  }
-  if (isWhatsAppGroupJid(candidate)) {
-    const localPart = candidate.slice(0, candidate.length - "@g.us".length);
-    return `${localPart}@g.us`;
-  }
-  if (isWhatsAppUserTarget(candidate)) {
-    const phone = extractUserJidPhone(candidate);
-    if (!phone) {
-      return null;
-    }
-    const normalized = normalizeE164(phone);
-    return normalized.length > 1 ? normalized : null;
-  }
-  if (candidate.includes("@")) {
-    return null;
-  }
-  if (NON_WHATSAPP_PROVIDER_PREFIX_RE.test(candidate)) {
-    return null;
-  }
-  const normalized = normalizeE164(candidate);
-  return normalized.length > 1 ? normalized : null;
-}
-
-export function normalizeWhatsAppMessagingTarget(raw: string): string | undefined {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return undefined;
-  }
-  return normalizeWhatsAppTarget(trimmed) ?? undefined;
-}
-
-export function normalizeWhatsAppAllowFromEntries(allowFrom: Array<string | number>): string[] {
-  return allowFrom
-    .map((entry) => String(entry).trim())
-    .filter((entry): entry is string => Boolean(entry))
-    .map((entry) => (entry === "*" ? entry : normalizeWhatsAppTarget(entry)))
-    .filter((entry): entry is string => Boolean(entry));
-}
-
-export function looksLikeWhatsAppTargetId(raw: string): boolean {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return false;
-  }
-  return (
-    /^whatsapp:/i.test(trimmed) ||
-    isWhatsAppGroupJid(trimmed) ||
-    isWhatsAppUserTarget(trimmed) ||
-    normalizeWhatsAppTarget(trimmed) !== null
-  );
-}

package/src/normalize.ts

@@ -1,6 +0,0 @@
-export {
-  looksLikeWhatsAppTargetId,
-  normalizeWhatsAppMessagingTarget,
-  isWhatsAppGroupJid,
-  normalizeWhatsAppTarget,
-} from "./normalize-target.js";

package/src/outbound-adapter.poll.test.ts

@@ -1,62 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-
-const hoisted = vi.hoisted(() => ({
-  sendPollWhatsApp: vi.fn(async () => ({ messageId: "poll-1", toJid: "1555@s.whatsapp.net" })),
-  sendReactionWhatsApp: vi.fn(async () => undefined),
-}));
-
-vi.mock("openclaw/plugin-sdk/runtime-env", async () => {
-  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/runtime-env")>(
-    "openclaw/plugin-sdk/runtime-env",
-  );
-  return {
-    ...actual,
-    shouldLogVerbose: () => false,
-  };
-});
-
-vi.mock("./send.js", () => ({
-  sendPollWhatsApp: hoisted.sendPollWhatsApp,
-  sendReactionWhatsApp: hoisted.sendReactionWhatsApp,
-}));
-
-let whatsappOutbound: typeof import("./outbound-adapter.js").whatsappOutbound;
-
-describe("whatsappOutbound sendPoll", () => {
-  beforeAll(async () => {
-    ({ whatsappOutbound } = await import("./outbound-adapter.js"));
-  });
-
-  beforeEach(() => {
-    hoisted.sendPollWhatsApp.mockClear();
-    hoisted.sendReactionWhatsApp.mockClear();
-  });
-
-  it("threads cfg through poll send options", async () => {
-    const cfg = { marker: "resolved-cfg" } as OpenClawConfig;
-    const poll = {
-      question: "Lunch?",
-      options: ["Pizza", "Sushi"],
-      maxSelections: 1,
-    };
-
-    const result = await whatsappOutbound.sendPoll!({
-      cfg,
-      to: "+1555",
-      poll,
-      accountId: "work",
-    });
-
-    expect(hoisted.sendPollWhatsApp).toHaveBeenCalledWith("+1555", poll, {
-      verbose: false,
-      accountId: "work",
-      cfg,
-    });
-    expect(result).toEqual({
-      channel: "whatsapp",
-      messageId: "poll-1",
-      toJid: "1555@s.whatsapp.net",
-    });
-  });
-});

package/src/outbound-adapter.sendpayload.test.ts

@@ -1,195 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { whatsappOutbound } from "./outbound-adapter.js";
-
-describe("whatsappOutbound sendPayload", () => {
-  it("trims leading whitespace for direct text sends", async () => {
-    const sendWhatsApp = vi.fn(async () => ({ messageId: "wa-1", toJid: "jid" }));
-
-    await whatsappOutbound.sendText!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "\n \thello",
-      deps: { sendWhatsApp },
-    });
-
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "hello", {
-      verbose: false,
-      cfg: {},
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-  });
-
-  it("uses the same final sanitizer stack for direct text sends", async () => {
-    const sendWhatsApp = vi.fn(async () => ({ messageId: "wa-1", toJid: "jid" }));
-
-    await whatsappOutbound.sendText!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: [
-        "Before",
-        "<function_calls>",
-        '  <invoke name="send_message">',
-        '    <parameter name="text"><b>hidden</b></parameter>',
-        "  </invoke>",
-        "</function_calls>",
-        "<div>After</div>",
-      ].join("\n"),
-      deps: { sendWhatsApp },
-    });
-
-    expect(sendWhatsApp).toHaveBeenCalledWith(
-      "5511999999999@c.us",
-      "Before\n\nAfter\n",
-      expect.objectContaining({
-        verbose: false,
-        cfg: {},
-        accountId: undefined,
-        gifPlayback: undefined,
-      }),
-    );
-  });
-
-  it("trims leading whitespace for direct media captions", async () => {
-    const sendWhatsApp = vi.fn(async () => ({ messageId: "wa-1", toJid: "jid" }));
-
-    await whatsappOutbound.sendMedia!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "\n \tcaption",
-      mediaUrl: "/tmp/test.png",
-      deps: { sendWhatsApp },
-    });
-
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/test.png",
-      mediaLocalRoots: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-  });
-
-  it("trims leading whitespace for sendPayload text and caption delivery", async () => {
-    const sendWhatsApp = vi.fn(async () => ({ messageId: "wa-1", toJid: "jid" }));
-
-    await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: { text: "\n\nhello" },
-      deps: { sendWhatsApp },
-    });
-    await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: { text: "\n\ncaption", mediaUrl: "/tmp/test.png" },
-      deps: { sendWhatsApp },
-    });
-
-    expect(sendWhatsApp).toHaveBeenNthCalledWith(1, "5511999999999@c.us", "hello", {
-      verbose: false,
-      cfg: {},
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-    expect(sendWhatsApp).toHaveBeenNthCalledWith(2, "5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/test.png",
-      mediaLocalRoots: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-  });
-
-  it("preserves audioAsVoice from payload media sends", async () => {
-    const sendWhatsApp = vi.fn(async () => ({ messageId: "wa-1", toJid: "jid" }));
-
-    await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: { text: "voice", mediaUrl: "/tmp/voice.ogg", audioAsVoice: true },
-      deps: { sendWhatsApp },
-    });
-
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "voice", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/voice.ogg",
-      mediaLocalRoots: undefined,
-      audioAsVoice: true,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-  });
-
-  it("drops blank mediaUrls before sending payload media", async () => {
-    const sendWhatsApp = vi.fn(async () => ({ messageId: "wa-1", toJid: "jid" }));
-
-    await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: {
-        text: "\n\ncaption",
-        mediaUrls: ["   ", " /tmp/voice.ogg "],
-      },
-      deps: { sendWhatsApp },
-    });
-
-    expect(sendWhatsApp).toHaveBeenCalledTimes(1);
-    expect(sendWhatsApp).toHaveBeenCalledWith("5511999999999@c.us", "caption", {
-      verbose: false,
-      cfg: {},
-      mediaUrl: "/tmp/voice.ogg",
-      mediaLocalRoots: undefined,
-      accountId: undefined,
-      gifPlayback: undefined,
-    });
-  });
-
-  it("skips whitespace-only text payloads", async () => {
-    const sendWhatsApp = vi.fn();
-
-    const result = await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: { text: "\n \t" },
-      deps: { sendWhatsApp },
-    });
-
-    expect(result).toEqual({ channel: "whatsapp", messageId: "" });
-    expect(sendWhatsApp).not.toHaveBeenCalled();
-  });
-
-  it("suppresses routed error payloads", async () => {
-    const sendWhatsApp = vi.fn();
-
-    const result = await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: { text: "provider exploded", isError: true },
-      deps: { sendWhatsApp },
-    });
-
-    expect(result).toEqual({ channel: "whatsapp", messageId: "" });
-    expect(sendWhatsApp).not.toHaveBeenCalled();
-  });
-
-  it("sanitizes HTML-only text to whitespace-only payload", () => {
-    expect(
-      whatsappOutbound
-        .sanitizeText?.({
-          text: "<br><br>",
-          payload: { text: "<br><br>" },
-        })
-        ?.trim(),
-    ).toBe("");
-  });
-});