@gakr-gakr/discord 0.1.0

package/src/normalize.ts

@@ -0,0 +1,86 @@
+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.ts

@@ -0,0 +1,327 @@
+import {
+  type ChannelOutboundAdapter,
+  createAttachedChannelResultAdapter,
+} from "autobot/plugin-sdk/channel-send-result";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { OutboundIdentity } from "autobot/plugin-sdk/outbound-runtime";
+import { resolveOutboundSendDep } from "autobot/plugin-sdk/outbound-send-deps";
+import {
+  normalizeOptionalString,
+  normalizeOptionalStringifiedId,
+} from "autobot/plugin-sdk/string-coerce-runtime";
+import { chunkDiscordTextWithMode } from "./chunk.js";
+import { withDiscordDeliveryRetry } from "./delivery-retry.js";
+import { notifyDiscordInboundEventOutboundPayloadSuccess } from "./inbound-event-delivery.js";
+import { isLikelyDiscordVideoMedia } from "./media-detection.js";
+import type { ThreadBindingRecord } from "./monitor/thread-bindings.js";
+import { normalizeDiscordOutboundTarget } from "./normalize.js";
+import { normalizeDiscordApprovalPayload } from "./outbound-approval.js";
+import { buildDiscordPresentationPayload } from "./outbound-components.js";
+import { sendDiscordOutboundPayload } from "./outbound-payload.js";
+import {
+  loadDiscordSendRuntime,
+  resolveDiscordFormattingOptions,
+  resolveDiscordOutboundTarget,
+  type DiscordSendFn,
+  type DiscordVoiceSendFn,
+} from "./outbound-send-context.js";
+
+export const DISCORD_TEXT_CHUNK_LIMIT = 2000;
+const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_BLOCK_RE =
+  /<\s*(system-reminder|previous_response)\b[^>]*>[\s\S]*?<\s*\/\s*\1\s*>/gi;
+const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_SELF_CLOSING_RE =
+  /<\s*(?:system-reminder|previous_response)\b[^>]*\/\s*>/gi;
+const DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_TAG_RE =
+  /<\s*\/?\s*(?:system-reminder|previous_response)\b[^>]*>/gi;
+
+function stripDiscordInternalRuntimeScaffolding(text: string): string {
+  return text
+    .replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_BLOCK_RE, "")
+    .replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_SELF_CLOSING_RE, "")
+    .replace(DISCORD_INTERNAL_RUNTIME_SCAFFOLDING_TAG_RE, "");
+}
+
+type DiscordThreadBindingsModule = typeof import("./monitor/thread-bindings.js");
+
+let discordThreadBindingsPromise: Promise<DiscordThreadBindingsModule> | undefined;
+
+function loadDiscordThreadBindings(): Promise<DiscordThreadBindingsModule> {
+  discordThreadBindingsPromise ??= import("./monitor/thread-bindings.js");
+  return discordThreadBindingsPromise;
+}
+
+function resolveDiscordWebhookIdentity(params: {
+  identity?: OutboundIdentity;
+  binding: ThreadBindingRecord;
+}): { username?: string; avatarUrl?: string } {
+  const usernameRaw = normalizeOptionalString(params.identity?.name);
+  const fallbackUsername = normalizeOptionalString(params.binding.label) ?? params.binding.agentId;
+  const username = (usernameRaw || fallbackUsername || "").slice(0, 80) || undefined;
+  const avatarUrl = normalizeOptionalString(params.identity?.avatarUrl);
+  return { username, avatarUrl };
+}
+
+async function maybeSendDiscordWebhookText(params: {
+  cfg: AutoBotConfig;
+  text: string;
+  threadId?: string | number | null;
+  accountId?: string | null;
+  identity?: OutboundIdentity;
+  replyToId?: string | null;
+}): Promise<{ messageId: string; channelId: string } | null> {
+  if (params.threadId == null) {
+    return null;
+  }
+  const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
+  if (!threadId) {
+    return null;
+  }
+  const { getThreadBindingManager } = await loadDiscordThreadBindings();
+  const manager = getThreadBindingManager(params.accountId ?? undefined);
+  if (!manager) {
+    return null;
+  }
+  const binding = manager.getByThreadId(threadId);
+  if (!binding?.webhookId || !binding?.webhookToken) {
+    return null;
+  }
+  const persona = resolveDiscordWebhookIdentity({
+    identity: params.identity,
+    binding,
+  });
+  const { sendWebhookMessageDiscord } = await loadDiscordSendRuntime();
+  const result = await sendWebhookMessageDiscord(params.text, {
+    webhookId: binding.webhookId,
+    webhookToken: binding.webhookToken,
+    accountId: binding.accountId,
+    threadId: binding.threadId,
+    cfg: params.cfg,
+    replyTo: params.replyToId ?? undefined,
+    username: persona.username,
+    avatarUrl: persona.avatarUrl,
+  });
+  return result;
+}
+
+export const discordOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: (text, limit, ctx) =>
+    chunkDiscordTextWithMode(text, {
+      maxChars: limit,
+      maxLines: ctx?.formatting?.maxLinesPerMessage,
+    }),
+  textChunkLimit: DISCORD_TEXT_CHUNK_LIMIT,
+  sanitizeText: ({ text }) => stripDiscordInternalRuntimeScaffolding(text),
+  pollMaxOptions: 10,
+  normalizePayload: ({ payload }) => normalizeDiscordApprovalPayload(payload),
+  presentationCapabilities: {
+    supported: true,
+    buttons: true,
+    selects: true,
+    context: true,
+    divider: true,
+    limits: {
+      actions: {
+        maxActions: 25,
+        maxActionsPerRow: 5,
+        maxRows: 5,
+        maxLabelLength: 80,
+        supportsDisabled: true,
+      },
+      selects: {
+        maxOptions: 25,
+        maxLabelLength: 100,
+        maxValueBytes: 100,
+      },
+      text: {
+        maxLength: DISCORD_TEXT_CHUNK_LIMIT,
+        encoding: "characters",
+        markdownDialect: "discord-markdown",
+      },
+    },
+  },
+  deliveryCapabilities: {
+    durableFinal: {
+      text: true,
+      media: true,
+      payload: true,
+      silent: true,
+      replyTo: true,
+      thread: true,
+      messageSendingHooks: true,
+    },
+  },
+  renderPresentation: async ({ payload, presentation }) => {
+    return await buildDiscordPresentationPayload({
+      payload,
+      presentation,
+    });
+  },
+  resolveTarget: ({ to, allowFrom }) => normalizeDiscordOutboundTarget(to, allowFrom),
+  sendPayload: async (ctx) =>
+    await sendDiscordOutboundPayload({
+      ctx,
+      fallbackAdapter: discordOutbound,
+    }),
+  ...createAttachedChannelResultAdapter({
+    channel: "discord",
+    sendText: async ({
+      cfg,
+      to,
+      text,
+      accountId,
+      deps,
+      replyToId,
+      threadId,
+      identity,
+      silent,
+      formatting,
+    }) => {
+      if (!silent) {
+        const webhookResult = await maybeSendDiscordWebhookText({
+          cfg,
+          text,
+          threadId,
+          accountId,
+          identity,
+          replyToId,
+        }).catch(() => null);
+        if (webhookResult) {
+          return webhookResult;
+        }
+      }
+      const send =
+        resolveOutboundSendDep<DiscordSendFn>(deps, "discord") ??
+        (await loadDiscordSendRuntime()).sendMessageDiscord;
+      return await withDiscordDeliveryRetry({
+        cfg,
+        accountId,
+        fn: async () =>
+          await send(resolveDiscordOutboundTarget({ to, threadId }), text, {
+            verbose: false,
+            replyTo: replyToId ?? undefined,
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+            cfg,
+            ...resolveDiscordFormattingOptions({ formatting }),
+          }),
+      });
+    },
+    sendMedia: async ({
+      cfg,
+      to,
+      text,
+      mediaUrl,
+      audioAsVoice,
+      mediaAccess,
+      mediaLocalRoots,
+      mediaReadFile,
+      accountId,
+      deps,
+      replyToId,
+      threadId,
+      silent,
+      formatting,
+    }) => {
+      const send =
+        resolveOutboundSendDep<DiscordSendFn>(deps, "discord") ??
+        (await loadDiscordSendRuntime()).sendMessageDiscord;
+      const target = resolveDiscordOutboundTarget({ to, threadId });
+      const formattingOptions = resolveDiscordFormattingOptions({ formatting });
+      if (audioAsVoice && mediaUrl) {
+        const sendVoice =
+          resolveOutboundSendDep<DiscordVoiceSendFn>(deps, "discordVoice") ??
+          (await loadDiscordSendRuntime()).sendVoiceMessageDiscord;
+        return await withDiscordDeliveryRetry({
+          cfg,
+          accountId,
+          fn: async () =>
+            await sendVoice(target, mediaUrl, {
+              cfg,
+              replyTo: replyToId ?? undefined,
+              accountId: accountId ?? undefined,
+              silent: silent ?? undefined,
+            }),
+        });
+      }
+      if (text.trim() && mediaUrl && isLikelyDiscordVideoMedia(mediaUrl)) {
+        await withDiscordDeliveryRetry({
+          cfg,
+          accountId,
+          fn: async () =>
+            await send(target, text, {
+              verbose: false,
+              replyTo: replyToId ?? undefined,
+              accountId: accountId ?? undefined,
+              silent: silent ?? undefined,
+              cfg,
+              ...formattingOptions,
+            }),
+        });
+        return await withDiscordDeliveryRetry({
+          cfg,
+          accountId,
+          fn: async () =>
+            await send(target, "", {
+              verbose: false,
+              mediaUrl,
+              mediaAccess,
+              mediaLocalRoots,
+              mediaReadFile,
+              accountId: accountId ?? undefined,
+              silent: silent ?? undefined,
+              cfg,
+              ...formattingOptions,
+            }),
+        });
+      }
+      return await withDiscordDeliveryRetry({
+        cfg,
+        accountId,
+        fn: async () =>
+          await send(target, text, {
+            verbose: false,
+            mediaUrl,
+            mediaAccess,
+            mediaLocalRoots,
+            mediaReadFile,
+            replyTo: replyToId ?? undefined,
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+            cfg,
+            ...formattingOptions,
+          }),
+      });
+    },
+    sendPoll: async ({ cfg, to, poll, accountId, threadId, silent }) =>
+      await withDiscordDeliveryRetry({
+        cfg,
+        accountId,
+        fn: async () =>
+          await (
+            await loadDiscordSendRuntime()
+          ).sendPollDiscord(resolveDiscordOutboundTarget({ to, threadId }), poll, {
+            accountId: accountId ?? undefined,
+            silent: silent ?? undefined,
+            cfg,
+          }),
+      }),
+  }),
+  afterDeliverPayload: async ({ target, payload }) => {
+    notifyDiscordInboundEventOutboundPayloadSuccess({
+      payload,
+      to: resolveDiscordOutboundTarget({ to: target.to, threadId: target.threadId }),
+      accountId: target.accountId,
+    });
+    const threadId = normalizeOptionalStringifiedId(target.threadId);
+    if (!threadId) {
+      return;
+    }
+    const { getThreadBindingManager } = await loadDiscordThreadBindings();
+    const manager = getThreadBindingManager(target.accountId ?? undefined);
+    if (!manager?.getByThreadId(threadId)) {
+      return;
+    }
+    manager.touchThread({ threadId });
+  },
+};

package/src/outbound-approval.ts

@@ -0,0 +1,29 @@
+function hasApprovalChannelData(payload: { channelData?: unknown }): boolean {
+  const channelData = payload.channelData;
+  if (!channelData || typeof channelData !== "object" || Array.isArray(channelData)) {
+    return false;
+  }
+  return Boolean((channelData as { execApproval?: unknown }).execApproval);
+}
+
+function neutralizeDiscordApprovalMentions(value: string): string {
+  return value
+    .replace(/@everyone/gi, "@\u200beveryone")
+    .replace(/@here/gi, "@\u200bhere")
+    .replace(/<@/g, "<@\u200b")
+    .replace(/<#/g, "<#\u200b");
+}
+
+export function normalizeDiscordApprovalPayload<
+  T extends {
+    text?: string;
+    channelData?: unknown;
+  },
+>(payload: T): T {
+  return hasApprovalChannelData(payload) && payload.text
+    ? {
+        ...payload,
+        text: neutralizeDiscordApprovalMentions(payload.text),
+      }
+    : payload;
+}

package/src/outbound-components.ts

@@ -0,0 +1,86 @@
+import type { ChannelOutboundAdapter } from "autobot/plugin-sdk/channel-send-result";
+import { readDiscordComponentSpec, type DiscordComponentMessageSpec } from "./components.js";
+
+type DiscordComponentSendFn = typeof import("./send.components.js").sendDiscordComponentMessage;
+type DiscordSharedInteractiveModule = typeof import("./shared-interactive.js");
+type OutboundPayload = Parameters<NonNullable<ChannelOutboundAdapter["sendPayload"]>>[0]["payload"];
+
+let discordComponentSendPromise: Promise<DiscordComponentSendFn> | undefined;
+let discordSharedInteractivePromise: Promise<DiscordSharedInteractiveModule> | undefined;
+
+export async function sendDiscordComponentMessageLazy(
+  ...args: Parameters<DiscordComponentSendFn>
+): ReturnType<DiscordComponentSendFn> {
+  discordComponentSendPromise ??= import("./send.components.js").then(
+    (module) => module.sendDiscordComponentMessage,
+  );
+  return await (
+    await discordComponentSendPromise
+  )(...args);
+}
+
+function loadDiscordSharedInteractive(): Promise<DiscordSharedInteractiveModule> {
+  discordSharedInteractivePromise ??= import("./shared-interactive.js");
+  return discordSharedInteractivePromise;
+}
+
+function addPayloadTextFallback(
+  spec: DiscordComponentMessageSpec,
+  payload: Pick<OutboundPayload, "text">,
+): DiscordComponentMessageSpec {
+  return spec.text
+    ? spec
+    : {
+        ...spec,
+        text: payload.text?.trim() ? payload.text : undefined,
+      };
+}
+
+export async function buildDiscordPresentationPayload(params: {
+  payload: Parameters<NonNullable<ChannelOutboundAdapter["renderPresentation"]>>[0]["payload"];
+  presentation: Parameters<
+    NonNullable<ChannelOutboundAdapter["renderPresentation"]>
+  >[0]["presentation"];
+}): Promise<typeof params.payload | null> {
+  const componentSpec = (await loadDiscordSharedInteractive()).buildDiscordPresentationComponents(
+    params.presentation,
+  );
+  if (!componentSpec) {
+    return null;
+  }
+  return {
+    ...params.payload,
+    channelData: {
+      ...params.payload.channelData,
+      discord: {
+        ...(params.payload.channelData?.discord as Record<string, unknown> | undefined),
+        presentationComponents: componentSpec,
+      },
+    },
+  };
+}
+
+export async function resolveDiscordComponentSpec(
+  payload: OutboundPayload,
+): Promise<DiscordComponentMessageSpec | undefined> {
+  const discordData = payload.channelData?.discord as
+    | { components?: unknown; presentationComponents?: DiscordComponentMessageSpec }
+    | undefined;
+  const rawComponentSpec =
+    discordData?.presentationComponents ??
+    (discordData?.components &&
+    typeof discordData.components === "object" &&
+    !Array.isArray(discordData.components)
+      ? readDiscordComponentSpec(discordData.components)
+      : null);
+  if (rawComponentSpec) {
+    return addPayloadTextFallback(rawComponentSpec, payload);
+  }
+  if (!payload.interactive) {
+    return undefined;
+  }
+  const interactiveSpec = (await loadDiscordSharedInteractive()).buildDiscordInteractiveComponents(
+    payload.interactive,
+  );
+  return interactiveSpec ? addPayloadTextFallback(interactiveSpec, payload) : undefined;
+}