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

package/src/heartbeat-recipients.test.ts

@@ -1,203 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { resolveWhatsAppHeartbeatRecipients } from "./heartbeat-recipients.js";
-import type { OpenClawConfig } from "./runtime-api.js";
-
-const loadSessionStoreMock = vi.hoisted(() => vi.fn());
-const readChannelAllowFromStoreSyncMock = vi.hoisted(() => vi.fn<() => string[]>(() => []));
-
-vi.mock("./heartbeat-recipients.runtime.js", () => ({
-  DEFAULT_ACCOUNT_ID: "default",
-  loadSessionStore: loadSessionStoreMock,
-  readChannelAllowFromStoreSync: readChannelAllowFromStoreSyncMock,
-  resolveStorePath: vi.fn(() => "/tmp/test-sessions.json"),
-  normalizeChannelId: (value?: string | null) => {
-    const trimmed = value?.trim().toLowerCase();
-    return trimmed ? (trimmed as "whatsapp") : null;
-  },
-  normalizeE164: (value?: string | null) => {
-    const digits = (value ?? "").replace(/[^\d+]/g, "");
-    if (!digits) {
-      return "";
-    }
-    return digits.startsWith("+") ? digits : `+${digits}`;
-  },
-}));
-
-function makeCfg(overrides?: Partial<OpenClawConfig>): OpenClawConfig {
-  return {
-    bindings: [],
-    channels: {},
-    ...overrides,
-  } as OpenClawConfig;
-}
-
-describe("resolveWhatsAppHeartbeatRecipients", () => {
-  function setSessionStore(store: Record<string, unknown>) {
-    loadSessionStoreMock.mockReturnValue(store);
-  }
-
-  function setAllowFromStore(entries: string[]) {
-    readChannelAllowFromStoreSyncMock.mockReturnValue(entries);
-  }
-
-  function resolveWith(
-    cfgOverrides: Partial<OpenClawConfig> = {},
-    opts?: Parameters<typeof resolveWhatsAppHeartbeatRecipients>[1],
-  ) {
-    return resolveWhatsAppHeartbeatRecipients(makeCfg(cfgOverrides), opts);
-  }
-
-  function setSingleUnauthorizedSessionWithAllowFrom() {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000099", updatedAt: 2, sessionId: "a" },
-    });
-    setAllowFromStore(["+15550000001"]);
-  }
-
-  beforeEach(() => {
-    loadSessionStoreMock.mockReset();
-    readChannelAllowFromStoreSyncMock.mockReset();
-    loadSessionStoreMock.mockReturnValue({});
-    setAllowFromStore([]);
-  });
-
-  it("uses allowFrom store recipients when session recipients are ambiguous", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000001", updatedAt: 2, sessionId: "a" },
-      b: { lastChannel: "whatsapp", lastTo: "+15550000002", updatedAt: 1, sessionId: "b" },
-    });
-    setAllowFromStore(["+15550000001"]);
-
-    const result = resolveWith();
-
-    expect(result).toEqual({ recipients: ["+15550000001"], source: "session-single" });
-  });
-
-  it("falls back to allowFrom when no session recipient is authorized", () => {
-    setSingleUnauthorizedSessionWithAllowFrom();
-
-    const result = resolveWith();
-
-    expect(result).toEqual({ recipients: ["+15550000001"], source: "allowFrom" });
-  });
-
-  it("includes both session and allowFrom recipients when --all is set", () => {
-    setSingleUnauthorizedSessionWithAllowFrom();
-
-    const result = resolveWith({}, { all: true });
-
-    expect(result).toEqual({
-      recipients: ["+15550000099", "+15550000001"],
-      source: "all",
-    });
-  });
-
-  it("returns explicit --to recipient and source flag", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000099", updatedAt: 2, sessionId: "a" },
-    });
-    const result = resolveWith({}, { to: " +1 555 000 7777 " });
-    expect(result).toEqual({ recipients: ["+15550007777"], source: "flag" });
-  });
-
-  it("returns ambiguous session recipients when no allowFrom list exists", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000001", updatedAt: 2, sessionId: "a" },
-      b: { lastChannel: "whatsapp", lastTo: "+15550000002", updatedAt: 1, sessionId: "b" },
-    });
-    const result = resolveWith();
-    expect(result).toEqual({
-      recipients: ["+15550000001", "+15550000002"],
-      source: "session-ambiguous",
-    });
-  });
-
-  it("returns single session recipient when allowFrom is empty", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000001", updatedAt: 2, sessionId: "a" },
-    });
-    const result = resolveWith();
-    expect(result).toEqual({ recipients: ["+15550000001"], source: "session-single" });
-  });
-
-  it("returns all authorized session recipients when allowFrom matches multiple", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000001", updatedAt: 2, sessionId: "a" },
-      b: { lastChannel: "whatsapp", lastTo: "+15550000002", updatedAt: 1, sessionId: "b" },
-      c: { lastChannel: "whatsapp", lastTo: "+15550000003", updatedAt: 0, sessionId: "c" },
-    });
-    setAllowFromStore(["+15550000001", "+15550000002"]);
-    const result = resolveWith();
-    expect(result).toEqual({
-      recipients: ["+15550000001", "+15550000002"],
-      source: "session-ambiguous",
-    });
-  });
-
-  it("ignores session store when session scope is global", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000001", updatedAt: 2, sessionId: "a" },
-    });
-    const result = resolveWith({
-      session: { scope: "global" } as OpenClawConfig["session"],
-      channels: { whatsapp: { allowFrom: ["*", "+15550000009"] } as never },
-    });
-    expect(result).toEqual({ recipients: ["+15550000009"], source: "allowFrom" });
-  });
-
-  it("uses the requested account allowFrom config and pairing store", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000077", updatedAt: 2, sessionId: "a" },
-    });
-    setAllowFromStore(["+15550000002"]);
-
-    const result = resolveWith(
-      {
-        channels: {
-          whatsapp: {
-            allowFrom: ["+15550000001"],
-            accounts: {
-              work: {
-                allowFrom: ["+15550000003"],
-              },
-            },
-          } as never,
-        },
-      },
-      { accountId: "work" },
-    );
-
-    expect(readChannelAllowFromStoreSyncMock).toHaveBeenCalledWith("whatsapp", process.env, "work");
-    expect(result).toEqual({
-      recipients: ["+15550000003", "+15550000002"],
-      source: "allowFrom",
-    });
-  });
-
-  it("uses configured defaultAccount allowFrom config and pairing store when accountId is omitted", () => {
-    setSessionStore({
-      a: { lastChannel: "whatsapp", lastTo: "+15550000077", updatedAt: 2, sessionId: "a" },
-    });
-    setAllowFromStore(["+15550000002"]);
-
-    const result = resolveWith({
-      channels: {
-        whatsapp: {
-          defaultAccount: "work",
-          allowFrom: ["+15550000001"],
-          accounts: {
-            work: {
-              allowFrom: ["+15550000003"],
-            },
-          },
-        } as never,
-      },
-    });
-
-    expect(readChannelAllowFromStoreSyncMock).toHaveBeenCalledWith("whatsapp", process.env, "work");
-    expect(result).toEqual({
-      recipients: ["+15550000003", "+15550000002"],
-      source: "allowFrom",
-    });
-  });
-});

package/src/heartbeat-recipients.ts

@@ -1,104 +0,0 @@
-import { resolveDefaultWhatsAppAccountId, resolveWhatsAppAccount } from "./accounts.js";
-import {
-  DEFAULT_ACCOUNT_ID,
-  loadSessionStore,
-  normalizeChannelId,
-  normalizeE164,
-  readChannelAllowFromStoreSync,
-  resolveStorePath,
-  type OpenClawConfig,
-} from "./heartbeat-recipients.runtime.js";
-
-type HeartbeatRecipientsResult = { recipients: string[]; source: string };
-type HeartbeatRecipientsOpts = { to?: string; all?: boolean; accountId?: string };
-
-function getSessionRecipients(cfg: OpenClawConfig) {
-  const sessionCfg = cfg.session;
-  const scope = sessionCfg?.scope ?? "per-sender";
-  if (scope === "global") {
-    return [];
-  }
-  const storePath = resolveStorePath(cfg.session?.store);
-  const store = loadSessionStore(storePath);
-  const isGroupKey = (key: string) =>
-    key.includes(":group:") || key.includes(":channel:") || key.includes("@g.us");
-  const isCronKey = (key: string) => key.startsWith("cron:");
-
-  const recipients = Object.entries(store)
-    .filter(([key]) => key !== "global" && key !== "unknown")
-    .filter(([key]) => !isGroupKey(key) && !isCronKey(key))
-    .map(([_, entry]) => ({
-      to:
-        normalizeChannelId(entry?.lastChannel) === "whatsapp" && entry?.lastTo
-          ? normalizeE164(entry.lastTo)
-          : "",
-      updatedAt: entry?.updatedAt ?? 0,
-    }))
-    .filter(({ to }) => to.length > 1)
-    .toSorted((a, b) => b.updatedAt - a.updatedAt);
-
-  const seen = new Set<string>();
-  return recipients.filter((recipient) => {
-    if (seen.has(recipient.to)) {
-      return false;
-    }
-    seen.add(recipient.to);
-    return true;
-  });
-}
-
-export function resolveWhatsAppHeartbeatRecipients(
-  cfg: OpenClawConfig,
-  opts: HeartbeatRecipientsOpts = {},
-): HeartbeatRecipientsResult {
-  if (opts.to) {
-    return { recipients: [normalizeE164(opts.to)], source: "flag" };
-  }
-
-  const sessionRecipients = getSessionRecipients(cfg);
-  const resolvedAccountId =
-    opts.accountId?.trim() || resolveDefaultWhatsAppAccountId(cfg) || DEFAULT_ACCOUNT_ID;
-  const configuredAllowFrom = (
-    resolveWhatsAppAccount({ cfg, accountId: resolvedAccountId }).allowFrom ?? []
-  )
-    .filter((value) => value !== "*")
-    .map(normalizeE164);
-  const storeAllowFrom = readChannelAllowFromStoreSync(
-    "whatsapp",
-    process.env,
-    resolvedAccountId,
-  ).map(normalizeE164);
-
-  const unique = (list: string[]) => [...new Set(list.filter(Boolean))];
-  const allowFrom = unique([...configuredAllowFrom, ...storeAllowFrom]);
-
-  if (opts.all) {
-    return {
-      recipients: unique([...sessionRecipients.map((entry) => entry.to), ...allowFrom]),
-      source: "all",
-    };
-  }
-
-  if (allowFrom.length > 0) {
-    const allowSet = new Set(allowFrom);
-    const authorizedSessionRecipients = sessionRecipients
-      .map((entry) => entry.to)
-      .filter((recipient) => allowSet.has(recipient));
-    if (authorizedSessionRecipients.length === 1) {
-      return { recipients: [authorizedSessionRecipients[0]], source: "session-single" };
-    }
-    if (authorizedSessionRecipients.length > 1) {
-      return { recipients: authorizedSessionRecipients, source: "session-ambiguous" };
-    }
-    return { recipients: allowFrom, source: "allowFrom" };
-  }
-
-  if (sessionRecipients.length === 1) {
-    return { recipients: [sessionRecipients[0].to], source: "session-single" };
-  }
-  if (sessionRecipients.length > 1) {
-    return { recipients: sessionRecipients.map((entry) => entry.to), source: "session-ambiguous" };
-  }
-
-  return { recipients: allowFrom, source: "allowFrom" };
-}