@openclaw/whatsapp 2026.5.2 → 2026.5.3-beta.2

package/src/action-runtime.test.ts

@@ -1,330 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { handleWhatsAppAction, whatsAppActionRuntime } from "./action-runtime.js";
-
-const originalWhatsAppActionRuntime = { ...whatsAppActionRuntime };
-const sendReactionWhatsApp = vi.fn(async () => undefined);
-
-const enabledConfig = {
-  channels: { whatsapp: { actions: { reactions: true } } },
-} as OpenClawConfig;
-
-describe("handleWhatsAppAction", () => {
-  function reactionConfig(reactionLevel: "minimal" | "extensive" | "off" | "ack"): OpenClawConfig {
-    return {
-      channels: { whatsapp: { actions: { reactions: true }, reactionLevel } },
-    } as OpenClawConfig;
-  }
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    Object.assign(whatsAppActionRuntime, originalWhatsAppActionRuntime, {
-      sendReactionWhatsApp,
-    });
-  });
-
-  it("adds reactions", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "✅",
-      },
-      enabledConfig,
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "✅",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: undefined,
-        accountId: DEFAULT_ACCOUNT_ID,
-      }),
-    );
-  });
-
-  it("adds reactions when reactionLevel is minimal", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "✅",
-      },
-      reactionConfig("minimal"),
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "✅",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: undefined,
-        accountId: DEFAULT_ACCOUNT_ID,
-      }),
-    );
-  });
-
-  it("adds reactions when reactionLevel is extensive", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "✅",
-      },
-      reactionConfig("extensive"),
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "✅",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: undefined,
-        accountId: DEFAULT_ACCOUNT_ID,
-      }),
-    );
-  });
-
-  it("removes reactions on empty emoji", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "",
-      },
-      enabledConfig,
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: undefined,
-        accountId: DEFAULT_ACCOUNT_ID,
-      }),
-    );
-  });
-
-  it("removes reactions when remove flag set", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "✅",
-        remove: true,
-      },
-      enabledConfig,
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: undefined,
-        accountId: DEFAULT_ACCOUNT_ID,
-      }),
-    );
-  });
-
-  it("passes account scope and sender flags", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "🎉",
-        accountId: "work",
-        fromMe: true,
-        participant: "999@s.whatsapp.net",
-      },
-      enabledConfig,
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "🎉",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: true,
-        participant: "999@s.whatsapp.net",
-        accountId: "work",
-      }),
-    );
-  });
-
-  it("preserves LID participant ids when forwarding reactions", async () => {
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "12345@g.us",
-        messageId: "msg1",
-        emoji: "🎉",
-        participant: "123@lid",
-      },
-      enabledConfig,
-    );
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "12345@g.us",
-      "msg1",
-      "🎉",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: "123@lid",
-        accountId: DEFAULT_ACCOUNT_ID,
-      }),
-    );
-  });
-
-  it("respects reaction gating", async () => {
-    const cfg = {
-      channels: { whatsapp: { actions: { reactions: false } } },
-    } as OpenClawConfig;
-    await expect(
-      handleWhatsAppAction(
-        {
-          action: "react",
-          chatJid: "123@s.whatsapp.net",
-          messageId: "msg1",
-          emoji: "✅",
-        },
-        cfg,
-      ),
-    ).rejects.toThrow(/WhatsApp reactions are disabled/);
-  });
-
-  it("disables reactions when WhatsApp is not configured", async () => {
-    await expect(
-      handleWhatsAppAction(
-        {
-          action: "react",
-          chatJid: "123@s.whatsapp.net",
-          messageId: "msg1",
-          emoji: "✅",
-        },
-        {} as OpenClawConfig,
-      ),
-    ).rejects.toThrow(/WhatsApp reactions are disabled/);
-  });
-
-  it("prefers the action gate error when both actions.reactions and reactionLevel disable reactions", async () => {
-    const cfg = {
-      channels: { whatsapp: { actions: { reactions: false }, reactionLevel: "ack" } },
-    } as OpenClawConfig;
-
-    await expect(
-      handleWhatsAppAction(
-        {
-          action: "react",
-          chatJid: "123@s.whatsapp.net",
-          messageId: "msg1",
-          emoji: "✅",
-        },
-        cfg,
-      ),
-    ).rejects.toThrow(/WhatsApp reactions are disabled/);
-    expect(sendReactionWhatsApp).not.toHaveBeenCalled();
-  });
-
-  it.each(["off", "ack"] as const)(
-    "blocks agent reactions when reactionLevel is %s",
-    async (reactionLevel) => {
-      await expect(
-        handleWhatsAppAction(
-          {
-            action: "react",
-            chatJid: "123@s.whatsapp.net",
-            messageId: "msg1",
-            emoji: "✅",
-          },
-          reactionConfig(reactionLevel),
-        ),
-      ).rejects.toThrow(
-        new RegExp(`WhatsApp agent reactions disabled \\(reactionLevel="${reactionLevel}"\\)`),
-      );
-      expect(sendReactionWhatsApp).not.toHaveBeenCalled();
-    },
-  );
-
-  it("applies default account allowFrom when accountId is omitted", async () => {
-    const cfg = {
-      channels: {
-        whatsapp: {
-          actions: { reactions: true },
-          allowFrom: ["111@s.whatsapp.net"],
-          accounts: {
-            [DEFAULT_ACCOUNT_ID]: {
-              allowFrom: ["222@s.whatsapp.net"],
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    await expect(
-      handleWhatsAppAction(
-        {
-          action: "react",
-          chatJid: "111@s.whatsapp.net",
-          messageId: "msg1",
-          emoji: "✅",
-        },
-        cfg,
-      ),
-    ).rejects.toMatchObject({
-      name: "ToolAuthorizationError",
-      status: 403,
-    });
-  });
-
-  it("routes to resolved default account when no accountId is provided", async () => {
-    const cfg = {
-      channels: {
-        whatsapp: {
-          actions: { reactions: true },
-          accounts: {
-            work: {
-              allowFrom: ["123@s.whatsapp.net"],
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    await handleWhatsAppAction(
-      {
-        action: "react",
-        chatJid: "123@s.whatsapp.net",
-        messageId: "msg1",
-        emoji: "✅",
-      },
-      cfg,
-    );
-
-    expect(sendReactionWhatsApp).toHaveBeenLastCalledWith(
-      "+123",
-      "msg1",
-      "✅",
-      expect.objectContaining({
-        verbose: false,
-        fromMe: undefined,
-        participant: undefined,
-        accountId: "work",
-      }),
-    );
-  });
-});

package/src/action-runtime.ts

@@ -1,76 +0,0 @@
-import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import {
-  createActionGate,
-  jsonResult,
-  readReactionParams,
-  readStringParam,
-} from "openclaw/plugin-sdk/channel-actions";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveAuthorizedWhatsAppOutboundTarget } from "./action-runtime-target-auth.js";
-import { resolveWhatsAppReactionLevel } from "./reaction-level.js";
-import { sendReactionWhatsApp } from "./send.js";
-
-export const whatsAppActionRuntime = {
-  resolveAuthorizedWhatsAppOutboundTarget,
-  sendReactionWhatsApp,
-};
-
-export async function handleWhatsAppAction(
-  params: Record<string, unknown>,
-  cfg: OpenClawConfig,
-): Promise<AgentToolResult<unknown>> {
-  const action = readStringParam(params, "action", { required: true });
-  const whatsAppConfig = cfg.channels?.whatsapp;
-  const isActionEnabled = createActionGate(whatsAppConfig?.actions);
-
-  if (action === "react") {
-    const accountId = readStringParam(params, "accountId");
-    if (!whatsAppConfig) {
-      throw new Error("WhatsApp reactions are disabled.");
-    }
-    if (!isActionEnabled("reactions")) {
-      throw new Error("WhatsApp reactions are disabled.");
-    }
-    const reactionLevelInfo = resolveWhatsAppReactionLevel({
-      cfg,
-      accountId: accountId ?? undefined,
-    });
-    if (!reactionLevelInfo.agentReactionsEnabled) {
-      throw new Error(
-        `WhatsApp agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). ` +
-          `Set channels.whatsapp.reactionLevel to "minimal" or "extensive" to enable.`,
-      );
-    }
-    const chatJid = readStringParam(params, "chatJid", { required: true });
-    const messageId = readStringParam(params, "messageId", { required: true });
-    const { emoji, remove, isEmpty } = readReactionParams(params, {
-      removeErrorMessage: "Emoji is required to remove a WhatsApp reaction.",
-    });
-    const participant = readStringParam(params, "participant");
-    const fromMeRaw = params.fromMe;
-    const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : undefined;
-
-    // Resolve account + allowFrom via shared account logic so auth and routing stay aligned.
-    const resolved = whatsAppActionRuntime.resolveAuthorizedWhatsAppOutboundTarget({
-      cfg,
-      chatJid,
-      accountId,
-      actionLabel: "reaction",
-    });
-
-    const resolvedEmoji = remove ? "" : emoji;
-    await whatsAppActionRuntime.sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
-      verbose: false,
-      fromMe,
-      participant: participant ?? undefined,
-      accountId: resolved.accountId,
-      cfg,
-    });
-    if (!remove && !isEmpty) {
-      return jsonResult({ ok: true, added: emoji });
-    }
-    return jsonResult({ ok: true, removed: true });
-  }
-
-  throw new Error(`Unsupported WhatsApp action: ${action}`);
-}

package/src/active-listener.test.ts

@@ -1,65 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { getActiveWebListener, resolveWebAccountId } from "./active-listener.js";
-
-const registryMocks = vi.hoisted(() => ({
-  getRegisteredWhatsAppConnectionController: vi.fn(),
-}));
-
-vi.mock("./connection-controller-registry.js", () => ({
-  getRegisteredWhatsAppConnectionController:
-    registryMocks.getRegisteredWhatsAppConnectionController,
-}));
-
-const WHATSAPP_ACTIVE_LISTENER_TEST_CFG = {
-  channels: { whatsapp: { accounts: { work: { enabled: true } }, defaultAccount: "work" } },
-};
-
-function makeListener() {
-  return {
-    sendMessage: vi.fn(async () => ({ messageId: "msg-1" })),
-    sendPoll: vi.fn(async () => ({ messageId: "poll-1" })),
-    sendReaction: vi.fn(async () => {}),
-    sendComposingTo: vi.fn(async () => {}),
-  };
-}
-
-beforeEach(() => {
-  registryMocks.getRegisteredWhatsAppConnectionController.mockReset();
-});
-
-describe("active WhatsApp listener view", () => {
-  it("reads controller-backed state", () => {
-    const listener = makeListener();
-    registryMocks.getRegisteredWhatsAppConnectionController.mockImplementation(
-      (accountId: string) =>
-        accountId === "work"
-          ? {
-              getActiveListener: () => listener,
-            }
-          : null,
-    );
-
-    expect(getActiveWebListener("work")).toBe(listener);
-  });
-
-  it("resolves the configured default account when accountId is omitted", () => {
-    const listener = makeListener();
-    registryMocks.getRegisteredWhatsAppConnectionController.mockImplementation(
-      (accountId: string) =>
-        accountId === "work"
-          ? {
-              getActiveListener: () => listener,
-            }
-          : null,
-    );
-
-    expect(resolveWebAccountId({ cfg: WHATSAPP_ACTIVE_LISTENER_TEST_CFG })).toBe("work");
-    expect(getActiveWebListener("work")).toBe(listener);
-  });
-
-  it("returns null when the controller has no active listener for the account", () => {
-    registryMocks.getRegisteredWhatsAppConnectionController.mockReturnValue(null);
-
-    expect(getActiveWebListener("work")).toBeNull();
-  });
-});

package/src/active-listener.ts

@@ -1,17 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveDefaultWhatsAppAccountId } from "./account-ids.js";
-import { getRegisteredWhatsAppConnectionController } from "./connection-controller-registry.js";
-import type { ActiveWebListener, ActiveWebSendOptions } from "./inbound/types.js";
-
-export type { ActiveWebListener, ActiveWebSendOptions } from "./inbound/types.js";
-
-export function resolveWebAccountId(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): string {
-  return (params.accountId ?? "").trim() || resolveDefaultWhatsAppAccountId(params.cfg);
-}
-
-export function getActiveWebListener(accountId: string): ActiveWebListener | null {
-  return getRegisteredWhatsAppConnectionController(accountId)?.getActiveListener() ?? null;
-}

package/src/agent-tools-login.test.ts

@@ -1,81 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { startWebLoginWithQr, waitForWebLogin } from "../login-qr-api.js";
-import { createWhatsAppLoginTool } from "./agent-tools-login.js";
-
-vi.mock("../login-qr-api.js", () => ({
-  startWebLoginWithQr: vi.fn(),
-  waitForWebLogin: vi.fn(),
-}));
-
-const startWebLoginWithQrMock = vi.mocked(startWebLoginWithQr);
-const waitForWebLoginMock = vi.mocked(waitForWebLogin);
-
-describe("createWhatsAppLoginTool", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("passes the caller's current QR back into wait actions", async () => {
-    const accountId = "account-1";
-    waitForWebLoginMock.mockResolvedValueOnce({
-      connected: false,
-      message: "QR refreshed. Scan the latest code in WhatsApp → Linked Devices.",
-      qrDataUrl: "data:image/png;base64,next-qr",
-    });
-
-    const tool = createWhatsAppLoginTool();
-    const result = await tool.execute("tool-call-1", {
-      action: "wait",
-      timeoutMs: 5000,
-      accountId,
-      currentQrDataUrl: "data:image/png;base64,current-qr",
-    });
-
-    expect(waitForWebLoginMock).toHaveBeenCalledWith({
-      accountId,
-      timeoutMs: 5000,
-      currentQrDataUrl: "data:image/png;base64,current-qr",
-    });
-    expect(result).toEqual({
-      content: [
-        {
-          type: "text",
-          text: [
-            "QR refreshed. Scan the latest code in WhatsApp → Linked Devices.",
-            "",
-            "Open WhatsApp → Linked Devices and scan:",
-            "",
-            "![whatsapp-qr](data:image/png;base64,next-qr)",
-          ].join("\n"),
-        },
-      ],
-      details: {
-        connected: false,
-        qr: true,
-      },
-    });
-  });
-
-  it("does not retain QR state across tool actions", async () => {
-    const accountId = "account-2";
-    startWebLoginWithQrMock.mockResolvedValueOnce({
-      connected: false,
-      message: "Scan this QR in WhatsApp → Linked Devices.",
-      qrDataUrl: "data:image/png;base64,current-qr",
-    });
-    waitForWebLoginMock.mockResolvedValueOnce({
-      connected: true,
-      message: "✅ Linked! WhatsApp is ready.",
-    });
-
-    const tool = createWhatsAppLoginTool();
-    await tool.execute("tool-call-start", { action: "start", accountId });
-    await tool.execute("tool-call-wait", { action: "wait", timeoutMs: 5000, accountId });
-
-    expect(waitForWebLoginMock).toHaveBeenCalledWith({
-      accountId,
-      timeoutMs: 5000,
-      currentQrDataUrl: undefined,
-    });
-  });
-});

package/src/agent-tools-login.ts

@@ -1,113 +0,0 @@
-import type { ChannelAgentTool } from "openclaw/plugin-sdk/channel-contract";
-import { Type } from "typebox";
-import { startWebLoginWithQr, waitForWebLogin } from "../login-qr-api.js";
-
-const QR_DATA_URL_MAX_LENGTH = 16_384;
-
-function readOptionalString(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-
-export function createWhatsAppLoginTool(): ChannelAgentTool {
-  return {
-    label: "WhatsApp Login",
-    name: "whatsapp_login",
-    ownerOnly: true,
-    description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
-    // NOTE: Using Type.Unsafe for action enum instead of Type.Union([Type.Literal(...)]
-    // because Claude API on Vertex AI rejects nested anyOf schemas as invalid JSON Schema.
-    parameters: Type.Object({
-      action: Type.Unsafe<"start" | "wait">({
-        type: "string",
-        enum: ["start", "wait"],
-      }),
-      timeoutMs: Type.Optional(Type.Number()),
-      force: Type.Optional(Type.Boolean()),
-      accountId: Type.Optional(Type.String()),
-      currentQrDataUrl: Type.Optional(
-        Type.String({
-          maxLength: QR_DATA_URL_MAX_LENGTH,
-          pattern: "^data:image/png;base64,",
-        }),
-      ),
-    }),
-    execute: async (_toolCallId, args) => {
-      const renderQrReply = (params: {
-        message: string;
-        qrDataUrl: string;
-        connected?: boolean;
-      }) => {
-        const text = [
-          params.message,
-          "",
-          "Open WhatsApp → Linked Devices and scan:",
-          "",
-          `![whatsapp-qr](${params.qrDataUrl})`,
-        ].join("\n");
-        return {
-          content: [{ type: "text" as const, text }],
-          details: {
-            connected: params.connected ?? false,
-            qr: true,
-          },
-        };
-      };
-
-      const action = (args as { action?: string })?.action ?? "start";
-      const accountId = readOptionalString((args as { accountId?: unknown }).accountId);
-      if (action === "wait") {
-        const result = await waitForWebLogin({
-          accountId,
-          timeoutMs:
-            typeof (args as { timeoutMs?: unknown }).timeoutMs === "number"
-              ? (args as { timeoutMs?: number }).timeoutMs
-              : undefined,
-          currentQrDataUrl: readOptionalString(
-            (args as { currentQrDataUrl?: unknown }).currentQrDataUrl,
-          ),
-        });
-        if (result.qrDataUrl) {
-          return renderQrReply({
-            message: result.message,
-            qrDataUrl: result.qrDataUrl,
-            connected: result.connected,
-          });
-        }
-        return {
-          content: [{ type: "text", text: result.message }],
-          details: { connected: result.connected },
-        };
-      }
-
-      const result = await startWebLoginWithQr({
-        accountId,
-        timeoutMs:
-          typeof (args as { timeoutMs?: unknown }).timeoutMs === "number"
-            ? (args as { timeoutMs?: number }).timeoutMs
-            : undefined,
-        force:
-          typeof (args as { force?: unknown }).force === "boolean"
-            ? (args as { force?: boolean }).force
-            : false,
-      });
-
-      if (!result.qrDataUrl) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: result.message,
-            },
-          ],
-          details: { qr: false },
-        };
-      }
-
-      return renderQrReply({
-        message: result.message,
-        qrDataUrl: result.qrDataUrl,
-        connected: result.connected,
-      });
-    },
-  };
-}