@openclaw/whatsapp 2026.5.2 → 2026.5.3-beta.1

package/src/setup-surface.test.ts

@@ -1,367 +0,0 @@
-import {
-  createPluginSetupWizardStatus,
-  createQueuedWizardPrompter,
-  runSetupWizardFinalize,
-} from "openclaw/plugin-sdk/plugin-test-runtime";
-import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
-import { DEFAULT_ACCOUNT_ID, type OpenClawConfig } from "openclaw/plugin-sdk/setup";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { whatsappSetupWizard } from "./setup-surface.js";
-import {
-  createWhatsAppAllowlistModeInput,
-  createWhatsAppLinkingHarness,
-  createWhatsAppOwnerAllowlistHarness,
-  createWhatsAppPersonalPhoneHarness,
-  createWhatsAppRootAllowFromConfig,
-  createWhatsAppWorkAccountConfig,
-  expectNoWhatsAppLoginFollowup,
-  expectWhatsAppAllowlistModeSetup,
-  expectWhatsAppLoginFollowup,
-  expectWhatsAppOpenPolicySetup,
-  expectWhatsAppOwnerAllowlistSetup,
-  expectWhatsAppPersonalPhoneSetup,
-  expectWhatsAppSeparatePhoneDisabledSetup,
-  expectWhatsAppWorkAccountAccessNote,
-  expectWhatsAppWorkAccountOpenAccess,
-} from "./setup-test-helpers.js";
-
-const hoisted = vi.hoisted(() => ({
-  detectWhatsAppLinked: vi.fn<(cfg: OpenClawConfig, accountId: string) => Promise<boolean>>(
-    async () => false,
-  ),
-  loginWeb: vi.fn(async () => {}),
-  pathExists: vi.fn(async () => false),
-  readWebAuthState: vi.fn<(authDir: string) => Promise<"linked" | "not-linked" | "unstable">>(
-    async () => "not-linked",
-  ),
-  resolveWhatsAppAuthDir: vi.fn<
-    (params: { cfg: OpenClawConfig; accountId: string }) => { authDir: string }
-  >(() => ({
-    authDir: "/tmp/openclaw-whatsapp-test",
-  })),
-}));
-
-vi.mock("./login.js", () => ({
-  loginWeb: hoisted.loginWeb,
-}));
-
-vi.mock("./setup-finalize.js", async () => {
-  const actual = await vi.importActual<typeof import("./setup-finalize.js")>("./setup-finalize.js");
-  return {
-    ...actual,
-    detectWhatsAppLinked: hoisted.detectWhatsAppLinked,
-  };
-});
-
-vi.mock("openclaw/plugin-sdk/setup", async () => {
-  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/setup")>(
-    "openclaw/plugin-sdk/setup",
-  );
-  return {
-    ...actual,
-    pathExists: hoisted.pathExists,
-  };
-});
-
-vi.mock("./accounts.js", async () => {
-  const actual = await vi.importActual<typeof import("./accounts.js")>("./accounts.js");
-  return Object.assign({}, actual, {
-    resolveWhatsAppAuthDir: hoisted.resolveWhatsAppAuthDir,
-  });
-});
-
-vi.mock("./auth-store.js", async () => {
-  const actual = await vi.importActual<typeof import("./auth-store.js")>("./auth-store.js");
-  return Object.assign({}, actual, {
-    readWebAuthState: hoisted.readWebAuthState,
-  });
-});
-
-const createRuntime = (): RuntimeEnv =>
-  ({
-    error: vi.fn(),
-  }) as unknown as RuntimeEnv;
-
-const whatsappGetStatus = createPluginSetupWizardStatus({
-  id: "whatsapp",
-  meta: {
-    label: "WhatsApp",
-  },
-  setupWizard: whatsappSetupWizard,
-} as never);
-
-async function runFinalizeWithHarness(params: {
-  harness: ReturnType<typeof createQueuedWizardPrompter>;
-  cfg?: Parameters<NonNullable<typeof whatsappSetupWizard.finalize>>[0]["cfg"];
-  runtime?: RuntimeEnv;
-  forceAllowFrom?: boolean;
-  accountId?: string;
-}) {
-  return await runSetupWizardFinalize({
-    finalize: whatsappSetupWizard.finalize,
-    cfg: params.cfg ?? {},
-    accountId: params.accountId ?? DEFAULT_ACCOUNT_ID,
-    runtime: params.runtime ?? createRuntime(),
-    prompter: params.harness.prompter,
-    forceAllowFrom: params.forceAllowFrom ?? false,
-  });
-}
-
-function createSeparatePhoneHarness(params: { selectValues: string[]; textValues?: string[] }) {
-  return createQueuedWizardPrompter({
-    confirmValues: [false],
-    selectValues: params.selectValues,
-    textValues: params.textValues,
-  });
-}
-
-function expectFinalizeResult(result: Awaited<ReturnType<typeof runFinalizeWithHarness>>): {
-  cfg: OpenClawConfig;
-} {
-  expect(result).toBeDefined();
-  if (!result || typeof result !== "object" || !("cfg" in result) || !result.cfg) {
-    throw new Error("Expected WhatsApp finalize result with cfg");
-  }
-  return result as { cfg: OpenClawConfig };
-}
-
-async function runSeparatePhoneFlow(params: { selectValues: string[]; textValues?: string[] }) {
-  hoisted.pathExists.mockResolvedValue(true);
-  const harness = createSeparatePhoneHarness({
-    selectValues: params.selectValues,
-    textValues: params.textValues,
-  });
-  const result = expectFinalizeResult(
-    await runFinalizeWithHarness({
-      harness,
-    }),
-  );
-  return { harness, result };
-}
-
-describe("whatsapp setup wizard", () => {
-  beforeEach(() => {
-    hoisted.detectWhatsAppLinked.mockReset();
-    hoisted.detectWhatsAppLinked.mockResolvedValue(false);
-    hoisted.loginWeb.mockReset();
-    hoisted.pathExists.mockReset();
-    hoisted.pathExists.mockResolvedValue(false);
-    hoisted.readWebAuthState.mockReset();
-    hoisted.readWebAuthState.mockResolvedValue("not-linked");
-    hoisted.resolveWhatsAppAuthDir.mockReset();
-    hoisted.resolveWhatsAppAuthDir.mockReturnValue({ authDir: "/tmp/openclaw-whatsapp-test" });
-  });
-
-  it("applies owner allowlist when forceAllowFrom is enabled", async () => {
-    const harness = createWhatsAppOwnerAllowlistHarness(createQueuedWizardPrompter);
-
-    const result = expectFinalizeResult(
-      await runFinalizeWithHarness({
-        harness,
-        forceAllowFrom: true,
-      }),
-    );
-
-    expect(hoisted.loginWeb).not.toHaveBeenCalled();
-    expectWhatsAppOwnerAllowlistSetup(result.cfg, harness);
-  });
-
-  it("supports disabled DM policy for separate-phone setup", async () => {
-    const { harness, result } = await runSeparatePhoneFlow({
-      selectValues: ["separate", "disabled"],
-    });
-
-    expectWhatsAppSeparatePhoneDisabledSetup(result.cfg, harness);
-  });
-
-  it("writes named-account DM policy and allowFrom instead of the channel root", async () => {
-    hoisted.pathExists.mockResolvedValue(true);
-    const harness = createSeparatePhoneHarness({
-      selectValues: ["separate", "open"],
-    });
-
-    const named = expectFinalizeResult(
-      await runFinalizeWithHarness({
-        harness,
-        accountId: "work",
-        cfg: createWhatsAppWorkAccountConfig() as OpenClawConfig,
-      }),
-    );
-
-    expectWhatsAppWorkAccountOpenAccess(named.cfg);
-    expectWhatsAppWorkAccountAccessNote(harness);
-  });
-
-  it("labels the selected named account in setup status even when not linked", async () => {
-    const status = await whatsappGetStatus({
-      cfg: {
-        channels: {
-          whatsapp: {
-            accounts: {
-              work: {
-                authDir: "/tmp/work",
-              },
-            },
-          },
-        },
-      } as OpenClawConfig,
-      accountOverrides: {
-        whatsapp: "work",
-      },
-    });
-
-    expect(status.configured).toBe(false);
-    expect(status.statusLines).toEqual(["WhatsApp (work): not linked"]);
-  });
-
-  it("uses configured defaultAccount for omitted-account setup status", async () => {
-    hoisted.resolveWhatsAppAuthDir.mockImplementation(({ accountId }: { accountId: string }) => ({
-      authDir: accountId === "work" ? "/tmp/work" : "/tmp/default",
-    }));
-    hoisted.readWebAuthState.mockImplementation(async (authDir: string) =>
-      authDir === "/tmp/work" ? "linked" : "not-linked",
-    );
-
-    const status = await whatsappGetStatus({
-      cfg: {
-        channels: {
-          whatsapp: {
-            defaultAccount: "work",
-            accounts: {
-              default: {
-                authDir: "/tmp/default",
-              },
-              work: {
-                authDir: "/tmp/work",
-              },
-            },
-          },
-        },
-      } as OpenClawConfig,
-      accountOverrides: {},
-    });
-
-    expect(status.configured).toBe(true);
-    expect(status.statusLines).toEqual(["WhatsApp (work): linked"]);
-    expect(hoisted.readWebAuthState).toHaveBeenCalledWith("/tmp/default");
-    expect(hoisted.readWebAuthState).toHaveBeenCalledWith("/tmp/work");
-  });
-
-  it("shows auth stabilizing when auth reads time out", async () => {
-    hoisted.resolveWhatsAppAuthDir.mockReturnValue({ authDir: "/tmp/work" });
-    hoisted.readWebAuthState.mockResolvedValue("unstable");
-
-    const status = await whatsappGetStatus({
-      cfg: {
-        channels: {
-          whatsapp: {
-            accounts: {
-              work: {
-                authDir: "/tmp/work",
-              },
-            },
-          },
-        },
-      } as OpenClawConfig,
-      accountOverrides: {
-        whatsapp: "work",
-      },
-    });
-
-    expect(status.configured).toBe(false);
-    expect(status.statusLines).toEqual(["WhatsApp (work): auth stabilizing"]);
-  });
-
-  it("uses configured defaultAccount for omitted-account finalize writes", async () => {
-    hoisted.pathExists.mockResolvedValue(true);
-    const harness = createSeparatePhoneHarness({
-      selectValues: ["separate", "open"],
-    });
-
-    const result = expectFinalizeResult(
-      await runFinalizeWithHarness({
-        harness,
-        accountId: "",
-        cfg: createWhatsAppWorkAccountConfig({ defaultAccount: "work" }) as OpenClawConfig,
-      }),
-    );
-
-    expectWhatsAppWorkAccountOpenAccess(result.cfg);
-    expectWhatsAppWorkAccountAccessNote(harness);
-  });
-
-  it("normalizes allowFrom entries when list mode is selected", async () => {
-    const { result } = await runSeparatePhoneFlow(createWhatsAppAllowlistModeInput());
-
-    expectWhatsAppAllowlistModeSetup(result.cfg);
-  });
-
-  it("enables allowlist self-chat mode for personal-phone setup", async () => {
-    hoisted.pathExists.mockResolvedValue(true);
-    const harness = createWhatsAppPersonalPhoneHarness(createQueuedWizardPrompter);
-
-    const result = expectFinalizeResult(
-      await runFinalizeWithHarness({
-        harness,
-      }),
-    );
-
-    expectWhatsAppPersonalPhoneSetup(result.cfg);
-  });
-
-  it("forces wildcard allowFrom for open policy without allowFrom follow-up prompts", async () => {
-    hoisted.pathExists.mockResolvedValue(true);
-    const harness = createSeparatePhoneHarness({
-      selectValues: ["separate", "open"],
-    });
-
-    const result = expectFinalizeResult(
-      await runFinalizeWithHarness({
-        harness,
-        cfg: createWhatsAppRootAllowFromConfig() as OpenClawConfig,
-      }),
-    );
-
-    expectWhatsAppOpenPolicySetup(result.cfg, harness);
-  });
-
-  it("runs WhatsApp login when not linked and user confirms linking", async () => {
-    hoisted.pathExists.mockResolvedValue(false);
-    const harness = createWhatsAppLinkingHarness(createQueuedWizardPrompter);
-    const runtime = createRuntime();
-
-    await runFinalizeWithHarness({
-      harness,
-      runtime,
-    });
-
-    expect(hoisted.loginWeb).toHaveBeenCalledWith(false, undefined, runtime, DEFAULT_ACCOUNT_ID);
-  });
-
-  it("skips relink note when already linked and relink is declined", async () => {
-    hoisted.pathExists.mockResolvedValue(true);
-    const harness = createSeparatePhoneHarness({
-      selectValues: ["separate", "disabled"],
-    });
-
-    await runFinalizeWithHarness({
-      harness,
-    });
-
-    expect(hoisted.loginWeb).not.toHaveBeenCalled();
-    expectNoWhatsAppLoginFollowup(harness);
-  });
-
-  it("shows follow-up login command note when not linked and linking is skipped", async () => {
-    hoisted.pathExists.mockResolvedValue(false);
-    const harness = createSeparatePhoneHarness({
-      selectValues: ["separate", "disabled"],
-    });
-
-    await runFinalizeWithHarness({
-      harness,
-    });
-
-    expectWhatsAppLoginFollowup(harness);
-  });
-});

package/src/setup-surface.ts

@@ -1,69 +0,0 @@
-import type { ChannelSetupWizard } from "openclaw/plugin-sdk/setup";
-import {
-  DEFAULT_ACCOUNT_ID,
-  setSetupChannelEnabled,
-  type OpenClawConfig,
-} from "openclaw/plugin-sdk/setup";
-import { listWhatsAppAccountIds, resolveWhatsAppAuthDir } from "./accounts.js";
-import { formatWhatsAppWebAuthStatusState, readWebAuthState } from "./auth-store.js";
-import { finalizeWhatsAppSetup } from "./setup-finalize.js";
-
-const channel = "whatsapp" as const;
-
-type WhatsAppSetupLinkState = "linked" | "not-linked" | "unstable";
-
-async function readWhatsAppSetupLinkState(
-  cfg: OpenClawConfig,
-  accountId: string,
-): Promise<WhatsAppSetupLinkState> {
-  const { authDir } = resolveWhatsAppAuthDir({ cfg, accountId });
-  return await readWebAuthState(authDir);
-}
-
-export const whatsappSetupWizard: ChannelSetupWizard = {
-  channel,
-  status: {
-    configuredLabel: "linked",
-    unconfiguredLabel: "not linked",
-    configuredHint: "linked",
-    unconfiguredHint: "not linked",
-    configuredScore: 5,
-    unconfiguredScore: 4,
-    resolveConfigured: async ({ cfg, accountId }) => {
-      for (const resolvedAccountId of accountId ? [accountId] : listWhatsAppAccountIds(cfg)) {
-        if ((await readWhatsAppSetupLinkState(cfg, resolvedAccountId)) === "linked") {
-          return true;
-        }
-      }
-      return false;
-    },
-    resolveStatusLines: async ({ cfg, accountId, configured }) => {
-      const linkedAccountId = (
-        await Promise.all(
-          (accountId ? [accountId] : listWhatsAppAccountIds(cfg)).map(
-            async (resolvedAccountId) => ({
-              accountId: resolvedAccountId,
-              state: await readWhatsAppSetupLinkState(cfg, resolvedAccountId),
-            }),
-          ),
-        )
-      ).find((entry) => entry.state === "linked" || entry.state === "unstable");
-      const labelAccountId = accountId ?? linkedAccountId?.accountId;
-      const label = labelAccountId
-        ? `WhatsApp (${labelAccountId === DEFAULT_ACCOUNT_ID ? "default" : labelAccountId})`
-        : "WhatsApp";
-      const stateLabel = configured
-        ? formatWhatsAppWebAuthStatusState("linked")
-        : formatWhatsAppWebAuthStatusState(linkedAccountId?.state ?? "not-linked");
-      return [`${label}: ${stateLabel}`];
-    },
-  },
-  resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
-  credentials: [],
-  finalize: async ({ cfg, accountId, forceAllowFrom, prompter, runtime }) =>
-    await finalizeWhatsAppSetup({ cfg, accountId, forceAllowFrom, prompter, runtime }),
-  disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
-  onAccountRecorded: (accountId, options) => {
-    options?.onAccountId?.(channel, accountId);
-  },
-};

package/src/setup-test-helpers.ts

@@ -1,216 +0,0 @@
-import { expect } from "vitest";
-
-type WhatsAppSetupConfig = {
-  channels?: {
-    whatsapp?: {
-      selfChatMode?: boolean;
-      dmPolicy?: string;
-      allowFrom?: string[];
-      accounts?: Record<string, { dmPolicy?: string; allowFrom?: string[]; authDir?: string }>;
-    };
-  };
-};
-
-type WizardPromptHarness = {
-  text: (...args: unknown[]) => unknown;
-  select: (...args: unknown[]) => unknown;
-  note: (...args: unknown[]) => unknown;
-};
-
-type QueuedWizardPrompterFactory<T extends WizardPromptHarness> = (params: {
-  confirmValues?: boolean[];
-  selectValues?: string[];
-  textValues?: string[];
-}) => T;
-
-const WHATSAPP_OWNER_NUMBER_INPUT = "+1 (555) 555-0123";
-const WHATSAPP_OWNER_NUMBER = "+15555550123";
-const WHATSAPP_PERSONAL_NUMBER_INPUT = "+1 (555) 111-2222";
-const WHATSAPP_PERSONAL_NUMBER = "+15551112222";
-const WHATSAPP_ACCESS_NOTE_TITLE = "WhatsApp DM access";
-const WHATSAPP_LOGIN_NOTE_TITLE = "WhatsApp";
-
-export function createWhatsAppRootAllowFromConfig(): WhatsAppSetupConfig {
-  return {
-    channels: {
-      whatsapp: {
-        allowFrom: [WHATSAPP_OWNER_NUMBER],
-      },
-    },
-  };
-}
-
-export function createWhatsAppOwnerAllowlistHarness<T extends WizardPromptHarness>(
-  createPrompter: QueuedWizardPrompterFactory<T>,
-): T {
-  return createPrompter({
-    confirmValues: [false],
-    textValues: [WHATSAPP_OWNER_NUMBER_INPUT],
-  });
-}
-
-export function createWhatsAppPersonalPhoneHarness<T extends WizardPromptHarness>(
-  createPrompter: QueuedWizardPrompterFactory<T>,
-): T {
-  return createPrompter({
-    confirmValues: [false],
-    selectValues: ["personal"],
-    textValues: [WHATSAPP_PERSONAL_NUMBER_INPUT],
-  });
-}
-
-export function createWhatsAppLinkingHarness<T extends WizardPromptHarness>(
-  createPrompter: QueuedWizardPrompterFactory<T>,
-): T {
-  return createPrompter({
-    confirmValues: [true],
-    selectValues: ["separate", "disabled"],
-  });
-}
-
-export function createWhatsAppWorkAccountConfig(
-  params: {
-    defaultAccount?: string;
-  } = {},
-): WhatsAppSetupConfig {
-  return {
-    channels: {
-      whatsapp: {
-        ...(params.defaultAccount ? { defaultAccount: params.defaultAccount } : {}),
-        dmPolicy: "disabled",
-        allowFrom: [WHATSAPP_OWNER_NUMBER],
-        accounts: {
-          work: {
-            authDir: "/tmp/work",
-          },
-        },
-      },
-    },
-  };
-}
-
-export function createWhatsAppAllowlistModeInput(): {
-  selectValues: string[];
-  textValues: string[];
-} {
-  return {
-    selectValues: ["separate", "allowlist", "list"],
-    textValues: [`${WHATSAPP_OWNER_NUMBER_INPUT}, ${WHATSAPP_OWNER_NUMBER}, *`],
-  };
-}
-
-function expectWhatsAppDmAccess(
-  cfg: WhatsAppSetupConfig,
-  expected: {
-    selfChatMode: boolean;
-    dmPolicy: string;
-    allowFrom?: string[];
-  },
-): void {
-  expect(cfg.channels?.whatsapp?.selfChatMode).toBe(expected.selfChatMode);
-  expect(cfg.channels?.whatsapp?.dmPolicy).toBe(expected.dmPolicy);
-  if ("allowFrom" in expected) {
-    expect(cfg.channels?.whatsapp?.allowFrom).toEqual(expected.allowFrom);
-  } else {
-    expect(cfg.channels?.whatsapp?.allowFrom).toBeUndefined();
-  }
-}
-
-export function expectWhatsAppWorkAccountOpenAccess(cfg: WhatsAppSetupConfig): void {
-  expect(cfg.channels?.whatsapp?.dmPolicy).toBe("disabled");
-  expect(cfg.channels?.whatsapp?.allowFrom).toEqual([WHATSAPP_OWNER_NUMBER]);
-  expect(cfg.channels?.whatsapp?.accounts?.work?.dmPolicy).toBe("open");
-  expect(cfg.channels?.whatsapp?.accounts?.work?.allowFrom).toEqual(["*", WHATSAPP_OWNER_NUMBER]);
-}
-
-function expectWhatsAppOwnerNumberPrompt(harness: WizardPromptHarness): void {
-  expect(harness.text).toHaveBeenCalledWith(
-    expect.objectContaining({
-      message: "Your personal WhatsApp number (the phone you will message from)",
-    }),
-  );
-}
-
-export function expectWhatsAppOwnerAllowlistSetup(
-  cfg: WhatsAppSetupConfig,
-  harness: WizardPromptHarness,
-): void {
-  expectWhatsAppDmAccess(cfg, {
-    selfChatMode: true,
-    dmPolicy: "allowlist",
-    allowFrom: [WHATSAPP_OWNER_NUMBER],
-  });
-  expectWhatsAppOwnerNumberPrompt(harness);
-}
-
-export function expectWhatsAppSeparatePhoneDisabledSetup(
-  cfg: WhatsAppSetupConfig,
-  harness: WizardPromptHarness,
-): void {
-  expectWhatsAppDmAccess(cfg, {
-    selfChatMode: false,
-    dmPolicy: "disabled",
-  });
-  expect(harness.text).not.toHaveBeenCalled();
-}
-
-export function expectWhatsAppAllowlistModeSetup(cfg: WhatsAppSetupConfig): void {
-  expectWhatsAppDmAccess(cfg, {
-    selfChatMode: false,
-    dmPolicy: "allowlist",
-    allowFrom: [WHATSAPP_OWNER_NUMBER, "*"],
-  });
-}
-
-export function expectWhatsAppPersonalPhoneSetup(cfg: WhatsAppSetupConfig): void {
-  expectWhatsAppDmAccess(cfg, {
-    selfChatMode: true,
-    dmPolicy: "allowlist",
-    allowFrom: [WHATSAPP_PERSONAL_NUMBER],
-  });
-}
-
-export function expectWhatsAppOpenPolicySetup(
-  cfg: WhatsAppSetupConfig,
-  harness: WizardPromptHarness,
-): void {
-  expectWhatsAppDmAccess(cfg, {
-    selfChatMode: false,
-    dmPolicy: "open",
-    allowFrom: ["*", WHATSAPP_OWNER_NUMBER],
-  });
-  expect(harness.select).toHaveBeenCalledTimes(2);
-  expect(harness.text).not.toHaveBeenCalled();
-}
-
-export function expectNoWhatsAppLoginFollowup(harness: WizardPromptHarness): void {
-  expect(harness.note).not.toHaveBeenCalledWith(
-    expect.stringContaining("openclaw channels login"),
-    WHATSAPP_LOGIN_NOTE_TITLE,
-  );
-}
-
-export function expectWhatsAppLoginFollowup(harness: WizardPromptHarness): void {
-  expect(harness.note).toHaveBeenCalledWith(
-    expect.stringContaining("openclaw channels login"),
-    WHATSAPP_LOGIN_NOTE_TITLE,
-  );
-}
-
-export function expectWhatsAppWorkAccountAccessNote(harness: WizardPromptHarness): void {
-  expect(harness.note).toHaveBeenCalledWith(
-    expect.stringContaining(
-      "`channels.whatsapp.accounts.work.dmPolicy` + `channels.whatsapp.accounts.work.allowFrom`",
-    ),
-    WHATSAPP_ACCESS_NOTE_TITLE,
-  );
-}
-
-export function expectWhatsAppDefaultAccountAccessNote(harness: WizardPromptHarness): void {
-  expect(harness.note).toHaveBeenCalledWith(
-    expect.stringContaining(
-      "`channels.whatsapp.accounts.default.dmPolicy` + `channels.whatsapp.accounts.default.allowFrom`",
-    ),
-    WHATSAPP_ACCESS_NOTE_TITLE,
-  );
-}