@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/monitor/acp-bind-here.integration.test.ts

@@ -1,211 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ChannelType } from "../internal/discord.js";
-
-const loadConfigMock = vi.hoisted(() => vi.fn());
-
-vi.mock("openclaw/plugin-sdk/runtime-config-snapshot", async () => {
-  const actual = await vi.importActual<
-    typeof import("openclaw/plugin-sdk/runtime-config-snapshot")
-  >("openclaw/plugin-sdk/runtime-config-snapshot");
-  return {
-    ...actual,
-    getRuntimeConfig: () => loadConfigMock(),
-  };
-});
-
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import {
-  getSessionBindingService,
-  registerSessionBindingAdapter,
-  type SessionBindingBindInput,
-  type SessionBindingRecord,
-} from "openclaw/plugin-sdk/conversation-runtime";
-import { __testing as sessionBindingTesting } from "openclaw/plugin-sdk/conversation-runtime";
-import { preflightDiscordMessage } from "./message-handler.preflight.js";
-import {
-  createDiscordMessage,
-  createDiscordPreflightArgs,
-  type DiscordClient,
-  type DiscordConfig,
-  type DiscordMessageEvent,
-} from "./message-handler.preflight.test-helpers.js";
-
-const baseCfg = {
-  session: {
-    mainKey: "main",
-    scope: "per-sender",
-  },
-  acp: {
-    enabled: true,
-    dispatch: {
-      enabled: true,
-    },
-    backend: "acpx",
-  },
-  channels: {
-    discord: {
-      threadBindings: {
-        enabled: true,
-      },
-    },
-  },
-} satisfies OpenClawConfig;
-
-function createDmClient(channelId: string): DiscordClient {
-  return {
-    fetchChannel: async (id: string) => {
-      if (id === channelId) {
-        return {
-          id: channelId,
-          type: ChannelType.DM,
-        };
-      }
-      return null;
-    },
-  } as unknown as DiscordClient;
-}
-
-function createInMemoryDiscordBindingAdapter() {
-  const bindings: SessionBindingRecord[] = [];
-
-  const bind = async (input: SessionBindingBindInput) => {
-    const normalizedConversation = {
-      ...input.conversation,
-      parentConversationId:
-        input.conversation.parentConversationId ??
-        (input.placement === "current" ? input.conversation.conversationId : undefined),
-    };
-    const record = {
-      bindingId: `discord:default:${normalizedConversation.conversationId}`,
-      targetSessionKey: input.targetSessionKey,
-      targetKind: input.targetKind,
-      conversation: normalizedConversation,
-      status: "active",
-      boundAt: 1,
-      ...(input.metadata ? { metadata: input.metadata } : {}),
-    } satisfies SessionBindingRecord;
-    const existingIndex = bindings.findIndex((entry) => entry.bindingId === record.bindingId);
-    if (existingIndex >= 0) {
-      bindings.splice(existingIndex, 1, record);
-    } else {
-      bindings.push(record);
-    }
-    return record;
-  };
-
-  registerSessionBindingAdapter({
-    channel: "discord",
-    accountId: "default",
-    capabilities: {
-      placements: ["current", "child"],
-      bindSupported: true,
-      unbindSupported: true,
-    },
-    bind,
-    listBySession: (targetSessionKey) =>
-      bindings.filter((entry) => entry.targetSessionKey === targetSessionKey),
-    resolveByConversation: (ref) =>
-      bindings.find(
-        (entry) =>
-          entry.conversation.channel === ref.channel &&
-          entry.conversation.accountId === ref.accountId &&
-          entry.conversation.conversationId === ref.conversationId,
-      ) ?? null,
-    unbind: async ({ bindingId, targetSessionKey }) => {
-      const removed = bindings.filter(
-        (entry) =>
-          (bindingId && entry.bindingId === bindingId) ||
-          (targetSessionKey && entry.targetSessionKey === targetSessionKey),
-      );
-      for (const entry of removed) {
-        const index = bindings.findIndex((candidate) => candidate.bindingId === entry.bindingId);
-        if (index >= 0) {
-          bindings.splice(index, 1);
-        }
-      }
-      return removed;
-    },
-  });
-
-  return { bindings };
-}
-
-describe("Discord ACP bind here end-to-end flow", () => {
-  beforeEach(() => {
-    sessionBindingTesting.resetSessionBindingAdaptersForTests();
-    loadConfigMock.mockReset().mockReturnValue(baseCfg);
-  });
-
-  it("routes the next Discord DM turn to an existing ACP session binding", async () => {
-    const adapter = createInMemoryDiscordBindingAdapter();
-    const binding = await getSessionBindingService().bind({
-      targetSessionKey: "agent:codex:acp:test-session",
-      targetKind: "session",
-      conversation: {
-        channel: "discord",
-        accountId: "default",
-        conversationId: "user:user-1",
-        parentConversationId: "user:user-1",
-      },
-      placement: "current",
-      metadata: {
-        boundBy: "user-1",
-        agentId: "codex",
-        label: "codex",
-      },
-    });
-
-    expect(adapter.bindings).toHaveLength(1);
-    expect(binding).toMatchObject({
-      targetSessionKey: "agent:codex:acp:test-session",
-      conversation: {
-        channel: "discord",
-        accountId: "default",
-        conversationId: "user:user-1",
-        parentConversationId: "user:user-1",
-      },
-    });
-    expect(
-      getSessionBindingService().resolveByConversation({
-        channel: "discord",
-        accountId: "default",
-        conversationId: "user:user-1",
-      }),
-    )?.toMatchObject({
-      targetSessionKey: binding.targetSessionKey,
-    });
-
-    const message = createDiscordMessage({
-      id: "m-followup-1",
-      channelId: "dm-1",
-      content: "follow up after bind",
-      author: {
-        id: "user-1",
-        bot: false,
-        username: "alice",
-      },
-    });
-
-    const preflight = await preflightDiscordMessage({
-      ...createDiscordPreflightArgs({
-        cfg: baseCfg,
-        discordConfig: {
-          dmPolicy: "open",
-        } as DiscordConfig,
-        data: {
-          channel_id: "dm-1",
-          author: message.author,
-          message,
-        } as DiscordMessageEvent,
-        client: createDmClient("dm-1"),
-        botUserId: "bot-1",
-      }),
-      allowFrom: ["*"],
-    });
-
-    expect(preflight).not.toBeNull();
-    expect(preflight?.boundSessionKey).toBe(binding.targetSessionKey);
-    expect(preflight?.route.sessionKey).toBe(binding.targetSessionKey);
-    expect(preflight?.route.agentId).toBe("codex");
-  });
-});

package/src/monitor/agent-components-auth.ts

@@ -1,7 +0,0 @@
-export { resolveInteractionContextWithDmAuth } from "./agent-components-dm-auth.js";
-export {
-  ensureAgentComponentInteractionAllowed,
-  ensureComponentUserAllowed,
-  resolveAuthorizedComponentInteraction,
-  resolveComponentCommandAuthorized,
-} from "./agent-components-guild-auth.js";

package/src/monitor/agent-components-context.ts

@@ -1,154 +0,0 @@
-import { ChannelType } from "discord-api-types/v10";
-import { resolveAgentRoute } from "openclaw/plugin-sdk/routing";
-import { logError } from "openclaw/plugin-sdk/text-runtime";
-import {
-  type AgentComponentContext,
-  type AgentComponentInteraction,
-  type AgentComponentMessageInteraction,
-  type ComponentInteractionContext,
-  type DiscordChannelContext,
-} from "./agent-components.types.js";
-import { normalizeDiscordDisplaySlug, normalizeDiscordSlug } from "./allow-list.js";
-import { resolveDiscordChannelInfoSafe } from "./channel-access.js";
-
-function formatUsername(user: { username: string; discriminator?: string | null }): string {
-  if (user.discriminator && user.discriminator !== "0") {
-    return `${user.username}#${user.discriminator}`;
-  }
-  return user.username;
-}
-
-function isThreadChannelType(channelType: number | undefined): boolean {
-  return (
-    channelType === ChannelType.PublicThread ||
-    channelType === ChannelType.PrivateThread ||
-    channelType === ChannelType.AnnouncementThread
-  );
-}
-
-export function resolveAgentComponentRoute(params: {
-  ctx: AgentComponentContext;
-  rawGuildId: string | undefined;
-  memberRoleIds: string[];
-  isDirectMessage: boolean;
-  isGroupDm: boolean;
-  userId: string;
-  channelId: string;
-  parentId: string | undefined;
-}) {
-  return resolveAgentRoute({
-    cfg: params.ctx.cfg,
-    channel: "discord",
-    accountId: params.ctx.accountId,
-    guildId: params.rawGuildId,
-    memberRoleIds: params.memberRoleIds,
-    peer: {
-      kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-      id: params.isDirectMessage ? params.userId : params.channelId,
-    },
-    parentPeer: params.parentId ? { kind: "channel", id: params.parentId } : undefined,
-  });
-}
-
-export async function ackComponentInteraction(params: {
-  interaction: AgentComponentInteraction;
-  replyOpts: { ephemeral?: boolean };
-  label: string;
-}) {
-  try {
-    await params.interaction.reply({
-      content: "✓",
-      ...params.replyOpts,
-    });
-  } catch (err) {
-    logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
-  }
-}
-
-export function resolveDiscordChannelContext(
-  interaction: AgentComponentInteraction,
-): DiscordChannelContext {
-  const channel = interaction.channel;
-  const channelInfo = resolveDiscordChannelInfoSafe(channel);
-  const channelName = channelInfo.name;
-  const channelSlug = channelName ? normalizeDiscordSlug(channelName) : "";
-  const displayChannelSlug = channelName ? normalizeDiscordDisplaySlug(channelName) : "";
-  const channelType = channelInfo.type;
-  const isThread = isThreadChannelType(channelType);
-
-  let parentId: string | undefined;
-  let parentName: string | undefined;
-  let parentSlug = "";
-  if (isThread) {
-    parentId = channelInfo.parentId;
-    parentName = channelInfo.parentName;
-    if (parentName) {
-      parentSlug = normalizeDiscordSlug(parentName);
-    }
-  }
-
-  return {
-    channelName,
-    channelSlug,
-    displayChannelSlug,
-    channelType,
-    isThread,
-    parentId,
-    parentName,
-    parentSlug,
-  };
-}
-
-export async function resolveComponentInteractionContext(params: {
-  interaction: AgentComponentInteraction;
-  label: string;
-  defer?: boolean;
-}): Promise<ComponentInteractionContext | null> {
-  const { interaction, label } = params;
-  const channelId = interaction.rawData.channel_id;
-  if (!channelId) {
-    logError(`${label}: missing channel_id in interaction`);
-    return null;
-  }
-
-  const user = interaction.user;
-  if (!user) {
-    logError(`${label}: missing user in interaction`);
-    return null;
-  }
-
-  const shouldDefer = params.defer !== false && "defer" in interaction;
-  let didDefer = false;
-  if (shouldDefer) {
-    try {
-      await (interaction as AgentComponentMessageInteraction).defer({ ephemeral: true });
-      didDefer = true;
-    } catch (err) {
-      logError(`${label}: failed to defer interaction: ${String(err)}`);
-    }
-  }
-  const replyOpts = didDefer ? {} : { ephemeral: true };
-
-  const username = formatUsername(user);
-  const userId = user.id;
-  const rawGuildId = interaction.rawData.guild_id;
-  const channelType = resolveDiscordChannelContext(interaction).channelType;
-  const isGroupDm = channelType === ChannelType.GroupDM;
-  const isDirectMessage =
-    channelType === ChannelType.DM || (!rawGuildId && !isGroupDm && channelType == null);
-  const memberRoleIds = Array.isArray(interaction.rawData.member?.roles)
-    ? interaction.rawData.member.roles.map((roleId: string) => roleId)
-    : [];
-
-  return {
-    channelId,
-    user,
-    username,
-    userId,
-    replyOpts,
-    rawGuildId,
-    isDirectMessage,
-    isGroupDm,
-    memberRoleIds,
-  };
-}

package/src/monitor/agent-components-data.ts

@@ -1,224 +0,0 @@
-import { logError } from "openclaw/plugin-sdk/text-runtime";
-import {
-  parseDiscordComponentCustomId,
-  parseDiscordModalCustomId,
-} from "../component-custom-id.js";
-import type { DiscordComponentEntry, DiscordModalEntry } from "../components.js";
-import type { ComponentData, ModalInteraction } from "../internal/discord.js";
-import type { AgentComponentInteraction } from "./agent-components.types.js";
-import { formatDiscordUserTag } from "./format.js";
-
-function readParsedComponentId(data: ComponentData): unknown {
-  if (!data || typeof data !== "object") {
-    return undefined;
-  }
-  return "cid" in data
-    ? (data as Record<string, unknown>).cid
-    : (data as Record<string, unknown>).componentId;
-}
-
-function normalizeComponentId(value: unknown): string | undefined {
-  if (typeof value === "string") {
-    const trimmed = value.trim();
-    return trimmed ? trimmed : undefined;
-  }
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return String(value);
-  }
-  return undefined;
-}
-
-function mapOptionLabels(
-  options: Array<{ value: string; label: string }> | undefined,
-  values: string[],
-) {
-  if (!options || options.length === 0) {
-    return values;
-  }
-  const map = new Map(options.map((option) => [option.value, option.label]));
-  return values.map((value) => map.get(value) ?? value);
-}
-
-export function parseAgentComponentData(data: ComponentData): { componentId: string } | null {
-  const raw = readParsedComponentId(data);
-  const decodeSafe = (value: string): string => {
-    if (!value.includes("%")) {
-      return value;
-    }
-    if (!/%[0-9A-Fa-f]{2}/.test(value)) {
-      return value;
-    }
-    try {
-      return decodeURIComponent(value);
-    } catch {
-      return value;
-    }
-  };
-  const componentId =
-    typeof raw === "string" ? decodeSafe(raw) : typeof raw === "number" ? String(raw) : null;
-  if (!componentId) {
-    return null;
-  }
-  return { componentId };
-}
-
-export function parseDiscordComponentData(
-  data: ComponentData,
-  customId?: string,
-): { componentId: string; modalId?: string } | null {
-  if (!data || typeof data !== "object") {
-    return null;
-  }
-  const rawComponentId = readParsedComponentId(data);
-  const rawModalId =
-    "mid" in data ? (data as { mid?: unknown }).mid : (data as { modalId?: unknown }).modalId;
-  let componentId = normalizeComponentId(rawComponentId);
-  let modalId = normalizeComponentId(rawModalId);
-  if (!componentId && customId) {
-    const parsed = parseDiscordComponentCustomId(customId);
-    if (parsed) {
-      componentId = parsed.componentId;
-      modalId = parsed.modalId;
-    }
-  }
-  if (!componentId) {
-    return null;
-  }
-  return { componentId, modalId };
-}
-
-export function parseDiscordModalId(data: ComponentData, customId?: string): string | null {
-  if (data && typeof data === "object") {
-    const rawModalId =
-      "mid" in data ? (data as { mid?: unknown }).mid : (data as { modalId?: unknown }).modalId;
-    const modalId = normalizeComponentId(rawModalId);
-    if (modalId) {
-      return modalId;
-    }
-  }
-  if (customId) {
-    return parseDiscordModalCustomId(customId);
-  }
-  return null;
-}
-
-export function resolveInteractionCustomId(
-  interaction: AgentComponentInteraction,
-): string | undefined {
-  if (!interaction?.rawData || typeof interaction.rawData !== "object") {
-    return undefined;
-  }
-  if (!("data" in interaction.rawData)) {
-    return undefined;
-  }
-  const data = (interaction.rawData as { data?: { custom_id?: unknown } }).data;
-  const customId = data?.custom_id;
-  if (typeof customId !== "string") {
-    return undefined;
-  }
-  const trimmed = customId.trim();
-  return trimmed ? trimmed : undefined;
-}
-
-export function mapSelectValues(entry: DiscordComponentEntry, values: string[]): string[] {
-  if (entry.selectType === "string") {
-    return mapOptionLabels(entry.options, values);
-  }
-  if (entry.selectType === "user") {
-    return values.map((value) => `user:${value}`);
-  }
-  if (entry.selectType === "role") {
-    return values.map((value) => `role:${value}`);
-  }
-  if (entry.selectType === "mentionable") {
-    return values.map((value) => `mentionable:${value}`);
-  }
-  if (entry.selectType === "channel") {
-    return values.map((value) => `channel:${value}`);
-  }
-  return values;
-}
-
-export function resolveModalFieldValues(
-  field: DiscordModalEntry["fields"][number],
-  interaction: ModalInteraction,
-): string[] {
-  const fields = interaction.fields;
-  const optionLabels = field.options?.map((option) => ({
-    value: option.value,
-    label: option.label,
-  }));
-  const required = field.required === true;
-  try {
-    switch (field.type) {
-      case "text": {
-        const value = required ? fields.getText(field.id, true) : fields.getText(field.id);
-        return value ? [value] : [];
-      }
-      case "select":
-      case "checkbox":
-      case "radio": {
-        const values = required
-          ? fields.getStringSelect(field.id, true)
-          : (fields.getStringSelect(field.id) ?? []);
-        return mapOptionLabels(optionLabels, values);
-      }
-      case "role-select": {
-        try {
-          const roles = required
-            ? fields.getRoleSelect(field.id, true)
-            : (fields.getRoleSelect(field.id) ?? []);
-          return roles.map((role) => role.name ?? role.id);
-        } catch {
-          const values = required
-            ? fields.getStringSelect(field.id, true)
-            : (fields.getStringSelect(field.id) ?? []);
-          return values;
-        }
-      }
-      case "user-select": {
-        const users = required
-          ? fields.getUserSelect(field.id, true)
-          : (fields.getUserSelect(field.id) ?? []);
-        return users.map((user) => formatDiscordUserTag(user));
-      }
-      default:
-        return [];
-    }
-  } catch (err) {
-    logError(`agent modal: failed to read field ${field.id}: ${String(err)}`);
-    return [];
-  }
-}
-
-export function formatModalSubmissionText(
-  entry: DiscordModalEntry,
-  interaction: ModalInteraction,
-): string {
-  const lines: string[] = [`Form "${entry.title}" submitted.`];
-  for (const field of entry.fields) {
-    const values = resolveModalFieldValues(field, interaction);
-    if (values.length === 0) {
-      continue;
-    }
-    lines.push(`- ${field.label}: ${values.join(", ")}`);
-  }
-  if (lines.length === 1) {
-    lines.push("- (no values)");
-  }
-  return lines.join("\n");
-}
-
-export function resolveDiscordInteractionId(interaction: AgentComponentInteraction): string {
-  const rawId =
-    interaction.rawData && typeof interaction.rawData === "object" && "id" in interaction.rawData
-      ? (interaction.rawData as { id?: unknown }).id
-      : undefined;
-  if (typeof rawId === "string" && rawId.trim()) {
-    return rawId.trim();
-  }
-  if (typeof rawId === "number" && Number.isFinite(rawId)) {
-    return String(rawId);
-  }
-  return `discord-interaction:${Date.now()}`;
-}