@gakr-gakr/discord 0.1.0

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

@@ -0,0 +1,359 @@
+import { resolveHumanDelayConfig } from "autobot/plugin-sdk/agent-runtime";
+import {
+  formatInboundEnvelope,
+  resolveEnvelopeFormatOptions,
+} from "autobot/plugin-sdk/channel-inbound";
+import { isDangerousNameMatchingEnabled } from "autobot/plugin-sdk/dangerous-name-runtime";
+import { runInboundReplyTurn } from "autobot/plugin-sdk/inbound-reply-dispatch";
+import { logError } from "autobot/plugin-sdk/logging-core";
+import { resolveMarkdownTableMode } from "autobot/plugin-sdk/markdown-table-runtime";
+import { getAgentScopedMediaLocalRoots } from "autobot/plugin-sdk/media-runtime";
+import { createNonExitingRuntime, logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { resolveDiscordMaxLinesPerMessage } from "../accounts.js";
+import { createDiscordRestClient } from "../client.js";
+import { resolveDiscordConversationIdentity } from "../conversation-identity.js";
+import {
+  resolveAgentComponentRoute,
+  resolveComponentCommandAuthorized,
+  resolvePinnedMainDmOwnerFromAllowlist,
+  type AgentComponentContext,
+  type AgentComponentInteraction,
+  type ComponentInteractionContext,
+  type DiscordChannelContext,
+} from "./agent-components-helpers.js";
+import { readSessionUpdatedAt, resolveStorePath } from "./agent-components.deps.runtime.js";
+import {
+  normalizeDiscordAllowList,
+  resolveDiscordChannelConfigWithFallback,
+  resolveDiscordGuildEntry,
+} from "./allow-list.js";
+import { formatDiscordUserTag } from "./format.js";
+import {
+  buildDiscordGroupSystemPrompt,
+  buildDiscordInboundAccessContext,
+} from "./inbound-context.js";
+import { buildDirectLabel, buildGuildLabel } from "./reply-context.js";
+import { deliverDiscordReply } from "./reply-delivery.js";
+
+let conversationRuntimePromise: Promise<typeof import("./agent-components.runtime.js")> | undefined;
+let typingRuntimePromise: Promise<typeof import("./typing.js")> | undefined;
+
+async function loadConversationRuntime() {
+  conversationRuntimePromise ??= import("./agent-components.runtime.js");
+  return await conversationRuntimePromise;
+}
+
+async function loadTypingRuntime() {
+  typingRuntimePromise ??= import("./typing.js");
+  return await typingRuntimePromise;
+}
+
+function buildDiscordComponentConversationLabel(params: {
+  interactionCtx: ComponentInteractionContext;
+  interaction: AgentComponentInteraction;
+  channelCtx: DiscordChannelContext;
+}) {
+  if (params.interactionCtx.isDirectMessage) {
+    return buildDirectLabel(params.interactionCtx.user);
+  }
+  if (params.interactionCtx.isGroupDm) {
+    return `Group DM #${params.channelCtx.channelName ?? params.interactionCtx.channelId} channel id:${params.interactionCtx.channelId}`;
+  }
+  return buildGuildLabel({
+    guild: params.interaction.guild ?? undefined,
+    channelName: params.channelCtx.channelName ?? params.interactionCtx.channelId,
+    channelId: params.interactionCtx.channelId,
+  });
+}
+
+function resolveDiscordComponentChatType(interactionCtx: ComponentInteractionContext) {
+  if (interactionCtx.isDirectMessage) {
+    return "direct";
+  }
+  if (interactionCtx.isGroupDm) {
+    return "group";
+  }
+  return "channel";
+}
+
+export function resolveDiscordComponentOriginatingTo(
+  interactionCtx: Pick<ComponentInteractionContext, "isDirectMessage" | "userId" | "channelId">,
+) {
+  return resolveDiscordConversationIdentity({
+    isDirectMessage: interactionCtx.isDirectMessage,
+    userId: interactionCtx.userId,
+    channelId: interactionCtx.channelId,
+  });
+}
+
+export async function dispatchDiscordComponentEvent(params: {
+  ctx: AgentComponentContext;
+  interaction: AgentComponentInteraction;
+  interactionCtx: ComponentInteractionContext;
+  channelCtx: DiscordChannelContext;
+  guildInfo: ReturnType<typeof resolveDiscordGuildEntry>;
+  eventText: string;
+  replyToId?: string;
+  routeOverrides?: { sessionKey?: string; agentId?: string; accountId?: string };
+}): Promise<void> {
+  const { ctx, interaction, interactionCtx, channelCtx, guildInfo, eventText } = params;
+  const runtime = ctx.runtime ?? createNonExitingRuntime();
+  const route = resolveAgentComponentRoute({
+    ctx,
+    rawGuildId: interactionCtx.rawGuildId,
+    memberRoleIds: interactionCtx.memberRoleIds,
+    isDirectMessage: interactionCtx.isDirectMessage,
+    isGroupDm: interactionCtx.isGroupDm,
+    userId: interactionCtx.userId,
+    channelId: interactionCtx.channelId,
+    parentId: channelCtx.parentId,
+  });
+  const sessionKey = params.routeOverrides?.sessionKey ?? route.sessionKey;
+  const agentId = params.routeOverrides?.agentId ?? route.agentId;
+  const accountId = params.routeOverrides?.accountId ?? route.accountId;
+  const inboundLastRouteSessionKey = sessionKey;
+  const fromLabel = buildDiscordComponentConversationLabel({
+    interactionCtx,
+    interaction,
+    channelCtx,
+  });
+  const chatType = resolveDiscordComponentChatType(interactionCtx);
+  const senderName = interactionCtx.user.globalName ?? interactionCtx.user.username;
+  const senderUsername = interactionCtx.user.username;
+  const senderTag = formatDiscordUserTag(interactionCtx.user);
+  const groupChannel =
+    !interactionCtx.isDirectMessage && channelCtx.displayChannelSlug
+      ? `#${channelCtx.displayChannelSlug}`
+      : undefined;
+  const groupSubject = interactionCtx.isDirectMessage ? undefined : groupChannel;
+  const channelConfig = resolveDiscordChannelConfigWithFallback({
+    guildInfo,
+    channelId: interactionCtx.channelId,
+    channelName: channelCtx.channelName,
+    channelSlug: channelCtx.channelSlug,
+    parentId: channelCtx.parentId,
+    parentName: channelCtx.parentName,
+    parentSlug: channelCtx.parentSlug,
+    scope: channelCtx.isThread ? "thread" : "channel",
+  });
+  const allowNameMatching = isDangerousNameMatchingEnabled(ctx.discordConfig);
+  const { ownerAllowFrom } = buildDiscordInboundAccessContext({
+    channelConfig,
+    guildInfo,
+    sender: { id: interactionCtx.user.id, name: interactionCtx.user.username, tag: senderTag },
+    allowNameMatching,
+    isGuild: !interactionCtx.isDirectMessage,
+  });
+  const groupSystemPrompt = buildDiscordGroupSystemPrompt(channelConfig);
+  const pinnedMainDmOwner = interactionCtx.isDirectMessage
+    ? resolvePinnedMainDmOwnerFromAllowlist({
+        dmScope: ctx.cfg.session?.dmScope,
+        allowFrom: channelConfig?.users ?? guildInfo?.users,
+        normalizeEntry: (entry: string) => {
+          const normalized = normalizeDiscordAllowList([entry], ["discord:", "user:", "pk:"]);
+          const candidate = normalized?.ids.values().next().value;
+          return typeof candidate === "string" && /^\d+$/.test(candidate) ? candidate : undefined;
+        },
+      })
+    : null;
+  const commandAuthorized = await resolveComponentCommandAuthorized({
+    ctx,
+    interactionCtx,
+    channelConfig,
+    guildInfo,
+    allowNameMatching,
+  });
+  const storePath = resolveStorePath(ctx.cfg.session?.store, { agentId });
+  const envelopeOptions = resolveEnvelopeFormatOptions(ctx.cfg);
+  const previousTimestamp = readSessionUpdatedAt({
+    storePath,
+    sessionKey,
+  });
+  const timestamp = Date.now();
+  const combinedBody = formatInboundEnvelope({
+    channel: "Discord",
+    from: fromLabel,
+    timestamp,
+    body: eventText,
+    chatType,
+    senderLabel: senderName,
+    previousTimestamp,
+    envelope: envelopeOptions,
+  });
+
+  const {
+    createReplyReferencePlanner,
+    dispatchReplyWithBufferedBlockDispatcher,
+    finalizeInboundContext,
+    resolveChunkMode,
+    resolveTextChunkLimit,
+    recordInboundSession,
+  } = await (async () => {
+    const conversationRuntime = await loadConversationRuntime();
+    return {
+      ...conversationRuntime,
+    };
+  })();
+
+  const ctxPayload = finalizeInboundContext({
+    Body: combinedBody,
+    BodyForAgent: eventText,
+    RawBody: eventText,
+    CommandBody: eventText,
+    From: interactionCtx.isDirectMessage
+      ? `discord:${interactionCtx.userId}`
+      : interactionCtx.isGroupDm
+        ? `discord:group:${interactionCtx.channelId}`
+        : `discord:channel:${interactionCtx.channelId}`,
+    To: `channel:${interactionCtx.channelId}`,
+    SessionKey: sessionKey,
+    AccountId: accountId,
+    ChatType: chatType,
+    ConversationLabel: fromLabel,
+    SenderName: senderName,
+    SenderId: interactionCtx.userId,
+    SenderUsername: senderUsername,
+    SenderTag: senderTag,
+    GroupSubject: groupSubject,
+    GroupChannel: groupChannel,
+    MemberRoleIds: interactionCtx.memberRoleIds,
+    GroupSystemPrompt: interactionCtx.isDirectMessage ? undefined : groupSystemPrompt,
+    GroupSpace: guildInfo?.id ?? guildInfo?.slug ?? interactionCtx.rawGuildId ?? undefined,
+    OwnerAllowFrom: ownerAllowFrom,
+    Provider: "discord" as const,
+    Surface: "discord" as const,
+    WasMentioned: true,
+    CommandAuthorized: commandAuthorized,
+    CommandTurn: {
+      kind: "text-slash" as const,
+      source: "text" as const,
+      authorized: commandAuthorized,
+      body: eventText,
+    },
+    CommandSource: "text" as const,
+    MessageSid: interaction.rawData.id,
+    Timestamp: timestamp,
+    OriginatingChannel: "discord" as const,
+    OriginatingTo:
+      resolveDiscordComponentOriginatingTo(interactionCtx) ?? `channel:${interactionCtx.channelId}`,
+  });
+
+  const deliverTarget = `channel:${interactionCtx.channelId}`;
+  const typingChannelId = interactionCtx.channelId;
+  const tableMode = resolveMarkdownTableMode({
+    cfg: ctx.cfg,
+    channel: "discord",
+    accountId,
+  });
+  const textLimit = resolveTextChunkLimit(ctx.cfg, "discord", accountId, {
+    fallbackLimit: 2000,
+  });
+  const token = ctx.token ?? "";
+  const feedbackRest = createDiscordRestClient({
+    cfg: ctx.cfg,
+    token,
+    accountId,
+  }).rest;
+  const mediaLocalRoots = getAgentScopedMediaLocalRoots(ctx.cfg, agentId);
+  const replyToMode =
+    ctx.discordConfig?.replyToMode ?? ctx.cfg.channels?.discord?.replyToMode ?? "off";
+  const replyReference = createReplyReferencePlanner({
+    replyToMode,
+    startId: params.replyToId,
+  });
+
+  await runInboundReplyTurn({
+    channel: "discord",
+    accountId,
+    raw: interaction,
+    adapter: {
+      ingest: () => ({
+        id: interaction.id,
+        rawText: ctxPayload.RawBody ?? "",
+        textForAgent: ctxPayload.BodyForAgent,
+        textForCommands: ctxPayload.CommandBody,
+        raw: interaction,
+      }),
+      resolveTurn: () => ({
+        cfg: ctx.cfg,
+        channel: "discord",
+        accountId,
+        agentId,
+        routeSessionKey: sessionKey,
+        storePath,
+        ctxPayload,
+        recordInboundSession,
+        dispatchReplyWithBufferedBlockDispatcher,
+        record: {
+          updateLastRoute: interactionCtx.isDirectMessage
+            ? {
+                sessionKey: inboundLastRouteSessionKey,
+                channel: "discord",
+                to:
+                  resolveDiscordComponentOriginatingTo(interactionCtx) ??
+                  `user:${interactionCtx.userId}`,
+                accountId,
+                mainDmOwnerPin:
+                  inboundLastRouteSessionKey === route.mainSessionKey && pinnedMainDmOwner
+                    ? {
+                        ownerRecipient: pinnedMainDmOwner,
+                        senderRecipient: interactionCtx.userId,
+                        onSkip: ({ ownerRecipient, senderRecipient }) => {
+                          logVerbose(
+                            `discord: skip main-session last route for ${senderRecipient} (pinned owner ${ownerRecipient})`,
+                          );
+                        },
+                      }
+                    : undefined,
+              }
+            : undefined,
+          onRecordError: (err) => {
+            logVerbose(`discord: failed updating component session meta: ${String(err)}`);
+          },
+        },
+        delivery: {
+          deliver: async (payload, info) => {
+            const replyToId = replyReference.use();
+            await deliverDiscordReply({
+              cfg: ctx.cfg,
+              replies: [payload],
+              target: deliverTarget,
+              token,
+              accountId,
+              rest: interaction.client.rest,
+              runtime,
+              replyToId,
+              replyToMode,
+              textLimit,
+              maxLinesPerMessage: resolveDiscordMaxLinesPerMessage({
+                cfg: ctx.cfg,
+                discordConfig: ctx.discordConfig,
+                accountId,
+              }),
+              tableMode,
+              chunkMode: resolveChunkMode(ctx.cfg, "discord", accountId),
+              mediaLocalRoots,
+              kind: info.kind,
+            });
+            replyReference.markSent();
+          },
+          onError: (err) => {
+            logError(`discord component dispatch failed: ${String(err)}`);
+          },
+        },
+        replyPipeline: {},
+        dispatcherOptions: {
+          humanDelay: resolveHumanDelayConfig(ctx.cfg, agentId),
+          onReplyStart: async () => {
+            try {
+              const { sendTyping } = await loadTypingRuntime();
+              await sendTyping({ rest: feedbackRest, channelId: typingChannelId });
+            } catch (err) {
+              logVerbose(`discord: typing failed for component reply: ${String(err)}`);
+            }
+          },
+        },
+      }),
+    },
+  });
+}

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

@@ -0,0 +1,303 @@
+import { logError } from "autobot/plugin-sdk/logging-core";
+import {
+  resolveDiscordComponentEntryWithPersistence,
+  resolveDiscordModalEntryWithPersistence,
+} from "../components-registry.js";
+import type { ButtonInteraction, ComponentData } from "../internal/discord.js";
+import {
+  type AgentComponentContext,
+  type AgentComponentMessageInteraction,
+  ensureComponentUserAllowed,
+  mapSelectValues,
+  parseDiscordComponentData,
+  resolveAuthorizedComponentInteraction,
+  resolveInteractionCustomId,
+} from "./agent-components-helpers.js";
+import { dispatchDiscordComponentEvent } from "./agent-components.dispatch.js";
+import { dispatchPluginDiscordInteractiveEvent } from "./agent-components.plugin-interactive.js";
+import type { DiscordComponentControlHandlers } from "./agent-components.wildcard-controls.js";
+
+let componentsRuntimePromise: Promise<typeof import("../components.js")> | undefined;
+
+async function loadComponentsRuntime() {
+  componentsRuntimePromise ??= import("../components.js");
+  return await componentsRuntimePromise;
+}
+
+async function handleDiscordComponentEvent(params: {
+  ctx: AgentComponentContext;
+  interaction: AgentComponentMessageInteraction;
+  data: ComponentData;
+  componentLabel: string;
+  values?: string[];
+  label: string;
+}): Promise<void> {
+  const parsed = parseDiscordComponentData(
+    params.data,
+    resolveInteractionCustomId(params.interaction),
+  );
+  if (!parsed) {
+    logError(`${params.label}: failed to parse component data`);
+    try {
+      await params.interaction.reply({
+        content: "This component is no longer valid.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  const entry = await resolveDiscordComponentEntryWithPersistence({
+    id: parsed.componentId,
+    consume: false,
+  });
+  if (!entry) {
+    try {
+      await params.interaction.reply({
+        content: "This component has expired.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  const unauthorizedReply = `You are not authorized to use this ${params.componentLabel}.`;
+  const authorized = await resolveAuthorizedComponentInteraction({
+    ctx: params.ctx,
+    interaction: params.interaction,
+    label: params.label,
+    componentLabel: params.componentLabel,
+    unauthorizedReply,
+    defer: false,
+  });
+  if (!authorized) {
+    return;
+  }
+  const {
+    interactionCtx,
+    channelCtx,
+    guildInfo,
+    allowNameMatching,
+    commandAuthorized,
+    user,
+    replyOpts,
+  } = authorized;
+
+  const componentAllowed = await ensureComponentUserAllowed({
+    entry,
+    interaction: params.interaction,
+    user,
+    replyOpts,
+    componentLabel: params.componentLabel,
+    unauthorizedReply,
+    allowNameMatching,
+  });
+  if (!componentAllowed) {
+    return;
+  }
+  const consumed = await resolveDiscordComponentEntryWithPersistence({
+    id: parsed.componentId,
+    consume: !entry.reusable,
+  });
+  if (!consumed) {
+    try {
+      await params.interaction.reply({
+        content: "This component has expired.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  if (consumed.kind === "modal-trigger") {
+    try {
+      await params.interaction.reply({
+        content: "This form is no longer available.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  const values = params.values ? mapSelectValues(consumed, params.values) : undefined;
+  if (consumed.callbackData) {
+    const pluginDispatch = await dispatchPluginDiscordInteractiveEvent({
+      ctx: params.ctx,
+      interaction: params.interaction,
+      interactionCtx,
+      channelCtx,
+      isAuthorizedSender: commandAuthorized,
+      data: consumed.callbackData,
+      kind: consumed.kind === "select" ? "select" : "button",
+      values,
+      messageId: consumed.messageId ?? params.interaction.message?.id,
+    });
+    if (pluginDispatch === "handled") {
+      return;
+    }
+  }
+  // Preserve explicit callback payloads for button fallbacks so Discord
+  // behaves like Telegram when buttons carry synthetic command text. Select
+  // fallbacks still need their chosen values in the synthesized event text.
+  const eventText =
+    (consumed.kind === "button" ? consumed.callbackData?.trim() : undefined) ||
+    (await loadComponentsRuntime()).formatDiscordComponentEventText({
+      kind: consumed.kind === "select" ? "select" : "button",
+      label: consumed.label,
+      values,
+    });
+
+  try {
+    await params.interaction.reply({ content: "✓", ...replyOpts });
+  } catch (err) {
+    logError(`${params.label}: failed to acknowledge interaction: ${String(err)}`);
+  }
+
+  await dispatchDiscordComponentEvent({
+    ctx: params.ctx,
+    interaction: params.interaction,
+    interactionCtx,
+    channelCtx,
+    guildInfo,
+    eventText,
+    replyToId: consumed.messageId ?? params.interaction.message?.id,
+    routeOverrides: {
+      sessionKey: consumed.sessionKey,
+      agentId: consumed.agentId,
+      accountId: consumed.accountId,
+    },
+  });
+}
+
+async function handleDiscordModalTrigger(params: {
+  ctx: AgentComponentContext;
+  interaction: ButtonInteraction;
+  data: ComponentData;
+  label: string;
+}): Promise<void> {
+  const parsed = parseDiscordComponentData(
+    params.data,
+    resolveInteractionCustomId(params.interaction),
+  );
+  if (!parsed) {
+    logError(`${params.label}: failed to parse modal trigger data`);
+    try {
+      await params.interaction.reply({
+        content: "This button is no longer valid.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+  const entry = await resolveDiscordComponentEntryWithPersistence({
+    id: parsed.componentId,
+    consume: false,
+  });
+  if (!entry || entry.kind !== "modal-trigger") {
+    try {
+      await params.interaction.reply({
+        content: "This button has expired.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  const modalId = entry.modalId ?? parsed.modalId;
+  if (!modalId) {
+    try {
+      await params.interaction.reply({
+        content: "This form is no longer available.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  const unauthorizedReply = "You are not authorized to use this form.";
+  const authorized = await resolveAuthorizedComponentInteraction({
+    ctx: params.ctx,
+    interaction: params.interaction,
+    label: params.label,
+    componentLabel: "form",
+    unauthorizedReply,
+    defer: false,
+  });
+  if (!authorized) {
+    return;
+  }
+  const { user, replyOpts, allowNameMatching } = authorized;
+
+  const componentAllowed = await ensureComponentUserAllowed({
+    entry,
+    interaction: params.interaction,
+    user,
+    replyOpts,
+    componentLabel: "form",
+    unauthorizedReply,
+    allowNameMatching,
+  });
+  if (!componentAllowed) {
+    return;
+  }
+
+  const consumed = await resolveDiscordComponentEntryWithPersistence({
+    id: parsed.componentId,
+    consume: !entry.reusable,
+  });
+  if (!consumed) {
+    try {
+      await params.interaction.reply({
+        content: "This form has expired.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  const resolvedModalId = consumed.modalId ?? modalId;
+  const modalEntry = await resolveDiscordModalEntryWithPersistence({
+    id: resolvedModalId,
+    consume: false,
+  });
+  if (!modalEntry) {
+    try {
+      await params.interaction.reply({
+        content: "This form has expired.",
+        ephemeral: true,
+      });
+    } catch {
+      // Interaction may have expired
+    }
+    return;
+  }
+
+  try {
+    await params.interaction.showModal(
+      (await loadComponentsRuntime()).createDiscordFormModal(modalEntry),
+    );
+  } catch (err) {
+    logError(`${params.label}: failed to show modal: ${String(err)}`);
+  }
+}
+
+export const discordComponentControlHandlers: DiscordComponentControlHandlers = {
+  handleComponentEvent: handleDiscordComponentEvent,
+  handleModalTrigger: handleDiscordModalTrigger,
+};