@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/monitor.ts

@@ -1,28 +0,0 @@
-export type {
-  DiscordAllowList,
-  DiscordChannelConfigResolved,
-  DiscordGuildEntryResolved,
-} from "./monitor/allow-list.js";
-export {
-  allowListMatches,
-  isDiscordGroupAllowedByPolicy,
-  normalizeDiscordAllowList,
-  normalizeDiscordSlug,
-  resolveDiscordChannelConfig,
-  resolveDiscordChannelConfigWithFallback,
-  resolveDiscordCommandAuthorized,
-  resolveDiscordGuildEntry,
-  resolveDiscordShouldRequireMention,
-  resolveGroupDmAllow,
-  shouldEmitDiscordReactionNotification,
-} from "./monitor/allow-list.js";
-export type { DiscordMessageEvent, DiscordMessageHandler } from "./monitor/listeners.js";
-export { registerDiscordListener } from "./monitor/listeners.js";
-
-export { createDiscordMessageHandler } from "./monitor/message-handler.js";
-export { buildDiscordMediaPayload } from "./monitor/message-utils.js";
-export { createDiscordNativeCommand } from "./monitor/native-command.js";
-export type { MonitorDiscordOpts } from "./monitor/provider.js";
-export { monitorDiscordProvider } from "./monitor/provider.js";
-
-export { resolveDiscordReplyTarget, sanitizeDiscordThreadName } from "./monitor/threading.js";

package/src/normalize.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  looksLikeDiscordTargetId,
-  normalizeDiscordMessagingTarget,
-  normalizeDiscordOutboundTarget,
-} from "./normalize.js";
-
-describe("discord target normalization", () => {
-  it("normalizes bare messaging target ids to channel targets", () => {
-    expect(normalizeDiscordMessagingTarget("1234567890")).toBe("channel:1234567890");
-  });
-
-  it("keeps explicit outbound targets and rejects missing recipients", () => {
-    expect(normalizeDiscordOutboundTarget("1234567890")).toEqual({
-      ok: true,
-      to: "channel:1234567890",
-    });
-    expect(normalizeDiscordOutboundTarget("user:42")).toEqual({
-      ok: true,
-      to: "user:42",
-    });
-
-    const result = normalizeDiscordOutboundTarget("   ");
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.message).toContain("Discord recipient is required");
-    }
-  });
-
-  it("treats bare outbound IDs listed in allowFrom as DM targets", () => {
-    expect(normalizeDiscordOutboundTarget("1234567890", ["1234567890"])).toEqual({
-      ok: true,
-      to: "user:1234567890",
-    });
-    expect(normalizeDiscordOutboundTarget("2345678901", ["user:2345678901"])).toEqual({
-      ok: true,
-      to: "user:2345678901",
-    });
-    expect(normalizeDiscordOutboundTarget("3456789012", ["<@3456789012>"])).toEqual({
-      ok: true,
-      to: "user:3456789012",
-    });
-    expect(normalizeDiscordOutboundTarget("4567890123", ["*"])).toEqual({
-      ok: true,
-      to: "channel:4567890123",
-    });
-  });
-
-  it("detects Discord-style target identifiers", () => {
-    expect(looksLikeDiscordTargetId("<@!123456>")).toBe(true);
-    expect(looksLikeDiscordTargetId("user:123456")).toBe(true);
-    expect(looksLikeDiscordTargetId("discord:123456")).toBe(true);
-    expect(looksLikeDiscordTargetId("123456")).toBe(true);
-    expect(looksLikeDiscordTargetId("hello world")).toBe(false);
-  });
-});

package/src/normalize.ts

@@ -1,86 +0,0 @@
-import { parseDiscordTarget } from "./target-parsing.js";
-
-export function normalizeDiscordMessagingTarget(raw: string): string | undefined {
-  // Default bare IDs to channels so routing is stable across tool actions.
-  const target = parseDiscordTarget(raw, { defaultKind: "channel" });
-  return target?.normalized;
-}
-
-/**
- * Normalize a Discord outbound target for delivery. Bare numeric IDs are
- * prefixed with "channel:" to avoid the ambiguous-target error in
- * parseDiscordTarget, unless the ID is explicitly configured as an allowed DM
- * sender. All other formats pass through unchanged.
- */
-export function normalizeDiscordOutboundTarget(
-  to?: string,
-  allowFrom?: readonly string[],
-): { ok: true; to: string } | { ok: false; error: Error } {
-  const trimmed = to?.trim();
-  if (!trimmed) {
-    return {
-      ok: false,
-      error: new Error(
-        'Discord recipient is required. Use "channel:<id>" for channels or "user:<id>" for DMs.',
-      ),
-    };
-  }
-  if (/^\d+$/.test(trimmed)) {
-    if (allowFromContainsDiscordUserId(allowFrom, trimmed)) {
-      return { ok: true, to: `user:${trimmed}` };
-    }
-    return { ok: true, to: `channel:${trimmed}` };
-  }
-  return { ok: true, to: trimmed };
-}
-
-export function allowFromContainsDiscordUserId(
-  allowFrom: readonly string[] | undefined,
-  userId: string,
-): boolean {
-  const normalizedUserId = userId.trim();
-  if (!normalizedUserId) {
-    return false;
-  }
-  return (allowFrom ?? []).some(
-    (entry) => normalizeAllowFromDiscordUserId(entry) === normalizedUserId,
-  );
-}
-
-function normalizeAllowFromDiscordUserId(entry: string): string | undefined {
-  const trimmed = entry.trim().toLowerCase();
-  if (!trimmed || trimmed === "*") {
-    return undefined;
-  }
-  const mentionMatch = /^<@!?(\d+)>$/.exec(trimmed);
-  if (mentionMatch) {
-    return mentionMatch[1];
-  }
-  // Accept both current and legacy allowFrom forms for Discord user IDs.
-  const prefixedMatch = /^(?:discord:)?user:(\d+)$/.exec(trimmed);
-  if (prefixedMatch) {
-    return prefixedMatch[1];
-  }
-  const discordMatch = /^discord:(\d+)$/.exec(trimmed);
-  if (discordMatch) {
-    return discordMatch[1];
-  }
-  return /^\d+$/.test(trimmed) ? trimmed : undefined;
-}
-
-export function looksLikeDiscordTargetId(raw: string): boolean {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return false;
-  }
-  if (/^<@!?\d+>$/.test(trimmed)) {
-    return true;
-  }
-  if (/^(user|channel|discord):/i.test(trimmed)) {
-    return true;
-  }
-  if (/^\d{6,}$/.test(trimmed)) {
-    return true;
-  }
-  return false;
-}

package/src/outbound-adapter.interactive-order.test.ts

@@ -1,64 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-  createDiscordOutboundHoisted,
-  installDiscordOutboundModuleSpies,
-  resetDiscordOutboundMocks,
-} from "./outbound-adapter.test-harness.js";
-
-const hoisted = createDiscordOutboundHoisted();
-await installDiscordOutboundModuleSpies(hoisted);
-
-const { discordOutbound } = await import("./outbound-adapter.js");
-
-describe("discordOutbound shared interactive ordering", () => {
-  beforeEach(() => {
-    resetDiscordOutboundMocks(hoisted);
-    hoisted.sendDiscordComponentMessageMock.mockResolvedValue({
-      messageId: "msg-1",
-      channelId: "123456",
-    });
-  });
-
-  it("keeps shared text blocks in authored order without hoisting fallback text", async () => {
-    const result = await discordOutbound.sendPayload!({
-      cfg: {},
-      to: "channel:123456",
-      text: "",
-      payload: {
-        interactive: {
-          blocks: [
-            { type: "text", text: "First" },
-            {
-              type: "buttons",
-              buttons: [{ label: "Approve", value: "approve" }],
-            },
-            { type: "text", text: "Last" },
-          ],
-        },
-      },
-    });
-
-    expect(hoisted.sendDiscordComponentMessageMock).toHaveBeenCalledWith(
-      "channel:123456",
-      {
-        blocks: [
-          { type: "text", text: "First" },
-          {
-            type: "actions",
-            buttons: [{ label: "Approve", style: "secondary", callbackData: "approve" }],
-          },
-          { type: "text", text: "Last" },
-        ],
-      },
-      expect.objectContaining({
-        cfg: {},
-      }),
-    );
-    expect(hoisted.sendMessageDiscordMock).not.toHaveBeenCalled();
-    expect(result).toEqual({
-      channel: "discord",
-      messageId: "msg-1",
-      channelId: "123456",
-    });
-  });
-});

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

@@ -1,207 +0,0 @@
-import { expect, vi, type Mock } from "vitest";
-
-type UnknownMock = Mock<(...args: unknown[]) => unknown>;
-type AsyncUnknownMock = Mock<(...args: unknown[]) => Promise<unknown>>;
-
-type DiscordOutboundHoisted = {
-  sendMessageDiscordMock: AsyncUnknownMock;
-  sendDiscordComponentMessageMock: AsyncUnknownMock;
-  sendPollDiscordMock: AsyncUnknownMock;
-  sendWebhookMessageDiscordMock: AsyncUnknownMock;
-  sendVoiceMessageDiscordMock: AsyncUnknownMock;
-  getThreadBindingManagerMock: UnknownMock;
-};
-
-type DiscordSendModule = typeof import("./send.js");
-type DiscordSendComponentsModule = typeof import("./send.components.js");
-type DiscordThreadBindingsModule = typeof import("./monitor/thread-bindings.js");
-
-// oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- Test helper preserves mock call and result types.
-function invokeMock<TArgs extends unknown[], TResult>(
-  mock: (...args: unknown[]) => unknown,
-  ...args: TArgs
-): TResult {
-  return mock(...args) as TResult;
-}
-
-export function createDiscordOutboundHoisted(): DiscordOutboundHoisted {
-  const sendMessageDiscordMock = vi.fn();
-  const sendDiscordComponentMessageMock = vi.fn();
-  const sendPollDiscordMock = vi.fn();
-  const sendWebhookMessageDiscordMock = vi.fn();
-  const sendVoiceMessageDiscordMock = vi.fn();
-  const getThreadBindingManagerMock = vi.fn();
-  return {
-    sendMessageDiscordMock,
-    sendDiscordComponentMessageMock,
-    sendPollDiscordMock,
-    sendWebhookMessageDiscordMock,
-    sendVoiceMessageDiscordMock,
-    getThreadBindingManagerMock,
-  };
-}
-
-const DEFAULT_DISCORD_SEND_RESULT = {
-  channel: "discord",
-  messageId: "msg-1",
-  channelId: "ch-1",
-} as const;
-
-async function createDiscordSendModuleMock(
-  hoisted: DiscordOutboundHoisted,
-  loadActual: () => Promise<DiscordSendModule>,
-): Promise<DiscordSendModule> {
-  const actual = await loadActual();
-  return {
-    ...actual,
-    sendMessageDiscord: (...args: Parameters<DiscordSendModule["sendMessageDiscord"]>) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendMessageDiscord"]>,
-        ReturnType<DiscordSendModule["sendMessageDiscord"]>
-      >(hoisted.sendMessageDiscordMock, ...args),
-    sendPollDiscord: (...args: Parameters<DiscordSendModule["sendPollDiscord"]>) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendPollDiscord"]>,
-        ReturnType<DiscordSendModule["sendPollDiscord"]>
-      >(hoisted.sendPollDiscordMock, ...args),
-    sendWebhookMessageDiscord: (
-      ...args: Parameters<DiscordSendModule["sendWebhookMessageDiscord"]>
-    ) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendWebhookMessageDiscord"]>,
-        ReturnType<DiscordSendModule["sendWebhookMessageDiscord"]>
-      >(hoisted.sendWebhookMessageDiscordMock, ...args),
-    sendVoiceMessageDiscord: (...args: Parameters<DiscordSendModule["sendVoiceMessageDiscord"]>) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendVoiceMessageDiscord"]>,
-        ReturnType<DiscordSendModule["sendVoiceMessageDiscord"]>
-      >(hoisted.sendVoiceMessageDiscordMock, ...args),
-  };
-}
-
-async function createDiscordSendComponentsModuleMock(
-  hoisted: DiscordOutboundHoisted,
-  loadActual: () => Promise<DiscordSendComponentsModule>,
-): Promise<DiscordSendComponentsModule> {
-  const actual = await loadActual();
-  return {
-    ...actual,
-    sendDiscordComponentMessage: (
-      ...args: Parameters<DiscordSendComponentsModule["sendDiscordComponentMessage"]>
-    ) =>
-      invokeMock<
-        Parameters<DiscordSendComponentsModule["sendDiscordComponentMessage"]>,
-        ReturnType<DiscordSendComponentsModule["sendDiscordComponentMessage"]>
-      >(hoisted.sendDiscordComponentMessageMock, ...args),
-  };
-}
-
-async function createDiscordThreadBindingsModuleMock(
-  hoisted: DiscordOutboundHoisted,
-  loadActual: () => Promise<DiscordThreadBindingsModule>,
-): Promise<DiscordThreadBindingsModule> {
-  const actual = await loadActual();
-  return {
-    ...actual,
-    getThreadBindingManager: (
-      ...args: Parameters<DiscordThreadBindingsModule["getThreadBindingManager"]>
-    ) =>
-      invokeMock<
-        Parameters<DiscordThreadBindingsModule["getThreadBindingManager"]>,
-        ReturnType<DiscordThreadBindingsModule["getThreadBindingManager"]>
-      >(hoisted.getThreadBindingManagerMock, ...args),
-  };
-}
-
-export async function installDiscordOutboundModuleSpies(hoisted: DiscordOutboundHoisted) {
-  const sendModule = await import("./send.js");
-  const mockedSendModule = await createDiscordSendModuleMock(hoisted, async () => sendModule);
-  vi.spyOn(sendModule, "sendMessageDiscord").mockImplementation(
-    mockedSendModule.sendMessageDiscord,
-  );
-  vi.spyOn(sendModule, "sendPollDiscord").mockImplementation(mockedSendModule.sendPollDiscord);
-  vi.spyOn(sendModule, "sendWebhookMessageDiscord").mockImplementation(
-    mockedSendModule.sendWebhookMessageDiscord,
-  );
-  vi.spyOn(sendModule, "sendVoiceMessageDiscord").mockImplementation(
-    mockedSendModule.sendVoiceMessageDiscord,
-  );
-
-  const sendComponentsModule = await import("./send.components.js");
-  const mockedSendComponentsModule = await createDiscordSendComponentsModuleMock(
-    hoisted,
-    async () => sendComponentsModule,
-  );
-  vi.spyOn(sendComponentsModule, "sendDiscordComponentMessage").mockImplementation(
-    mockedSendComponentsModule.sendDiscordComponentMessage,
-  );
-
-  const threadBindingsModule = await import("./monitor/thread-bindings.js");
-  const mockedThreadBindingsModule = await createDiscordThreadBindingsModuleMock(
-    hoisted,
-    async () => threadBindingsModule,
-  );
-  vi.spyOn(threadBindingsModule, "getThreadBindingManager").mockImplementation(
-    mockedThreadBindingsModule.getThreadBindingManager,
-  );
-}
-
-export function resetDiscordOutboundMocks(hoisted: DiscordOutboundHoisted) {
-  hoisted.sendMessageDiscordMock.mockReset().mockResolvedValue({
-    messageId: "msg-1",
-    channelId: "ch-1",
-  });
-  hoisted.sendDiscordComponentMessageMock.mockReset().mockResolvedValue({
-    messageId: "component-1",
-    channelId: "ch-1",
-  });
-  hoisted.sendPollDiscordMock.mockReset().mockResolvedValue({
-    messageId: "poll-1",
-    channelId: "ch-1",
-  });
-  hoisted.sendWebhookMessageDiscordMock.mockReset().mockResolvedValue({
-    messageId: "msg-webhook-1",
-    channelId: "thread-1",
-  });
-  hoisted.sendVoiceMessageDiscordMock.mockReset().mockResolvedValue({
-    messageId: "voice-1",
-    channelId: "ch-1",
-  });
-  hoisted.getThreadBindingManagerMock.mockReset().mockReturnValue(null);
-}
-
-export function expectDiscordThreadBotSend(params: {
-  hoisted: DiscordOutboundHoisted;
-  text: string;
-  result: unknown;
-  options?: Record<string, unknown>;
-}) {
-  expect(params.hoisted.sendMessageDiscordMock).toHaveBeenCalledWith(
-    "channel:thread-1",
-    params.text,
-    expect.objectContaining({
-      accountId: "default",
-      ...params.options,
-    }),
-  );
-  expect(params.result).toEqual(DEFAULT_DISCORD_SEND_RESULT);
-}
-
-export function mockDiscordBoundThreadManager(hoisted: DiscordOutboundHoisted) {
-  hoisted.getThreadBindingManagerMock.mockReturnValue({
-    getByThreadId: () => ({
-      accountId: "default",
-      channelId: "parent-1",
-      threadId: "thread-1",
-      targetKind: "subagent",
-      targetSessionKey: "agent:main:subagent:child",
-      agentId: "main",
-      label: "codex-thread",
-      webhookId: "wh-1",
-      webhookToken: "tok-1",
-      boundBy: "system",
-      boundAt: Date.now(),
-    }),
-    touchThread: vi.fn(),
-  });
-}