@gakr-gakr/discord 0.1.0

package/src/channel-actions.ts

@@ -0,0 +1,254 @@
+import { createUnionActionGate } from "autobot/plugin-sdk/channel-actions";
+import type {
+  ChannelMessageActionAdapter,
+  ChannelMessageActionName,
+  ChannelMessageToolDiscovery,
+} from "autobot/plugin-sdk/channel-contract";
+import type { DiscordActionConfig, AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { extractToolSend } from "autobot/plugin-sdk/tool-send";
+import { inspectDiscordAccount } from "./account-inspect.js";
+import { createDiscordActionGate, listDiscordAccountIds } from "./accounts.js";
+import { readDiscordComponentSpec } from "./components.js";
+import { withDiscordInboundEventDeliveryMetadata } from "./inbound-event-delivery.js";
+
+let discordChannelActionsRuntimePromise:
+  | Promise<typeof import("./channel-actions.runtime.js")>
+  | undefined;
+
+async function loadDiscordChannelActionsRuntime() {
+  discordChannelActionsRuntimePromise ??= import("./channel-actions.runtime.js");
+  return await discordChannelActionsRuntimePromise;
+}
+
+function listDiscoverableDiscordAccounts(cfg: AutoBotConfig) {
+  return listDiscordAccountIds(cfg)
+    .map((accountId) => inspectDiscordAccount({ cfg, accountId }))
+    .filter((account) => account.enabled && account.configured);
+}
+
+function resolveDiscordActionDiscovery(cfg: AutoBotConfig) {
+  const accounts = listDiscoverableDiscordAccounts(cfg);
+  if (accounts.length === 0) {
+    return null;
+  }
+  const unionGate = createUnionActionGate(accounts, (account) =>
+    createDiscordActionGate({
+      cfg,
+      accountId: account.accountId,
+    }),
+  );
+  return {
+    isEnabled: (key: keyof DiscordActionConfig, defaultValue = true) =>
+      unionGate(key, defaultValue),
+  };
+}
+
+function resolveScopedDiscordActionDiscovery(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+}) {
+  if (!params.accountId) {
+    return resolveDiscordActionDiscovery(params.cfg);
+  }
+  const account = inspectDiscordAccount({ cfg: params.cfg, accountId: params.accountId });
+  if (!account.enabled || !account.configured) {
+    return null;
+  }
+  const gate = createDiscordActionGate({
+    cfg: params.cfg,
+    accountId: account.accountId,
+  });
+  return {
+    isEnabled: (key: keyof DiscordActionConfig, defaultValue = true) => gate(key, defaultValue),
+  };
+}
+
+function describeDiscordMessageTool({
+  cfg,
+  accountId,
+}: Parameters<
+  NonNullable<ChannelMessageActionAdapter["describeMessageTool"]>
+>[0]): ChannelMessageToolDiscovery {
+  const discovery = resolveScopedDiscordActionDiscovery({ cfg, accountId });
+  if (!discovery) {
+    return {
+      actions: [],
+      capabilities: [],
+      schema: null,
+    };
+  }
+  const actions = new Set<ChannelMessageActionName>(["send"]);
+  if (discovery.isEnabled("polls")) {
+    actions.add("poll");
+  }
+  if (discovery.isEnabled("reactions")) {
+    actions.add("react");
+    actions.add("reactions");
+    actions.add("emoji-list");
+  }
+  if (discovery.isEnabled("messages")) {
+    actions.add("upload-file");
+    actions.add("read");
+    actions.add("edit");
+    actions.add("delete");
+  }
+  if (discovery.isEnabled("pins")) {
+    actions.add("pin");
+    actions.add("unpin");
+    actions.add("list-pins");
+  }
+  if (discovery.isEnabled("permissions")) {
+    actions.add("permissions");
+  }
+  if (discovery.isEnabled("threads")) {
+    actions.add("thread-create");
+    actions.add("thread-list");
+    actions.add("thread-reply");
+  }
+  if (discovery.isEnabled("search")) {
+    actions.add("search");
+  }
+  if (discovery.isEnabled("stickers")) {
+    actions.add("sticker");
+  }
+  if (discovery.isEnabled("memberInfo")) {
+    actions.add("member-info");
+  }
+  if (discovery.isEnabled("roleInfo")) {
+    actions.add("role-info");
+  }
+  if (discovery.isEnabled("emojiUploads")) {
+    actions.add("emoji-upload");
+  }
+  if (discovery.isEnabled("stickerUploads")) {
+    actions.add("sticker-upload");
+  }
+  if (discovery.isEnabled("roles", false)) {
+    actions.add("role-add");
+    actions.add("role-remove");
+  }
+  if (discovery.isEnabled("channelInfo")) {
+    actions.add("channel-info");
+    actions.add("channel-list");
+  }
+  if (discovery.isEnabled("channels")) {
+    actions.add("channel-create");
+    actions.add("channel-edit");
+    actions.add("channel-delete");
+    actions.add("channel-move");
+    actions.add("category-create");
+    actions.add("category-edit");
+    actions.add("category-delete");
+  }
+  if (discovery.isEnabled("voiceStatus")) {
+    actions.add("voice-status");
+  }
+  if (discovery.isEnabled("events")) {
+    actions.add("event-list");
+    actions.add("event-create");
+  }
+  if (discovery.isEnabled("moderation", false)) {
+    actions.add("timeout");
+    actions.add("kick");
+    actions.add("ban");
+  }
+  if (discovery.isEnabled("presence", false)) {
+    actions.add("set-presence");
+  }
+  return {
+    actions: Array.from(actions),
+    capabilities: ["presentation"],
+  };
+}
+
+export const discordMessageActions: ChannelMessageActionAdapter = {
+  resolveExecutionMode: ({ action }) =>
+    action === "read" || action === "search" ? "gateway" : "local",
+  describeMessageTool: describeDiscordMessageTool,
+  extractToolSend: ({ args }) => {
+    const action = normalizeOptionalString(args.action) ?? "";
+    if (action === "sendMessage") {
+      return extractToolSend(args, "sendMessage");
+    }
+    if (action === "threadReply") {
+      const channelId = normalizeOptionalString(args.channelId) ?? "";
+      return channelId ? { to: `channel:${channelId}` } : null;
+    }
+    return null;
+  },
+  prepareSendPayload: ({ ctx, payload }) => {
+    if (ctx.action !== "send") {
+      return null;
+    }
+    const payloadWithDeliveryMetadata = withDiscordInboundEventDeliveryMetadata(payload, {
+      sessionKey: ctx.sessionKey,
+      inboundEventKind: ctx.inboundEventKind,
+    });
+    const rawComponents = ctx.params.components;
+    if (typeof rawComponents === "function") {
+      return null;
+    }
+    const componentSpec =
+      rawComponents && typeof rawComponents === "object" && !Array.isArray(rawComponents)
+        ? readDiscordComponentSpec(rawComponents)
+        : undefined;
+    const nativeComponents = Array.isArray(rawComponents) ? rawComponents : undefined;
+    const embeds = Array.isArray(ctx.params.embeds) ? ctx.params.embeds : undefined;
+    if ((componentSpec || nativeComponents) && embeds?.length) {
+      return null;
+    }
+    const filename = normalizeOptionalString(ctx.params.filename);
+    if (!componentSpec && !nativeComponents && !embeds?.length && !filename) {
+      return payloadWithDeliveryMetadata;
+    }
+    const discordData =
+      payloadWithDeliveryMetadata.channelData?.discord &&
+      typeof payloadWithDeliveryMetadata.channelData.discord === "object" &&
+      !Array.isArray(payloadWithDeliveryMetadata.channelData.discord)
+        ? (payloadWithDeliveryMetadata.channelData.discord as Record<string, unknown>)
+        : {};
+    return {
+      ...payloadWithDeliveryMetadata,
+      channelData: {
+        ...payloadWithDeliveryMetadata.channelData,
+        discord: {
+          ...discordData,
+          ...(componentSpec ? { components: componentSpec } : {}),
+          ...(nativeComponents ? { components: nativeComponents } : {}),
+          ...(embeds?.length ? { embeds } : {}),
+          ...(filename ? { filename } : {}),
+        },
+      },
+    };
+  },
+  handleAction: async ({
+    action,
+    params,
+    cfg,
+    accountId,
+    requesterSenderId,
+    toolContext,
+    mediaAccess,
+    mediaLocalRoots,
+    mediaReadFile,
+    sessionKey,
+    inboundEventKind,
+  }) => {
+    return await (
+      await loadDiscordChannelActionsRuntime()
+    ).handleDiscordMessageAction({
+      action,
+      params,
+      cfg,
+      accountId,
+      requesterSenderId,
+      toolContext,
+      mediaAccess,
+      mediaLocalRoots,
+      mediaReadFile,
+      ...(sessionKey ? { sessionKey } : {}),
+      ...(inboundEventKind ? { inboundEventKind } : {}),
+    });
+  },
+};

package/src/channel-api.ts

@@ -0,0 +1,29 @@
+export { DEFAULT_ACCOUNT_ID } from "autobot/plugin-sdk/account-id";
+export {
+  buildTokenChannelStatusSummary,
+  PAIRING_APPROVED_MESSAGE,
+  projectCredentialSnapshotFields,
+  resolveConfiguredFromCredentialStatuses,
+} from "autobot/plugin-sdk/channel-status";
+export type { ChannelPlugin } from "autobot/plugin-sdk/channel-core";
+export type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+const DISCORD_CHANNEL_META = {
+  id: "discord",
+  label: "Discord",
+  selectionLabel: "Discord (Bot API)",
+  detailLabel: "Discord Bot",
+  docsPath: "/channels/discord",
+  docsLabel: "discord",
+  blurb: "very well supported right now.",
+  systemImage: "bubble.left.and.bubble.right",
+  markdownCapable: true,
+  preferSessionLookupForAnnounceTarget: true,
+} as const;
+
+export function getChatChannelMeta(id: string) {
+  if (id !== DISCORD_CHANNEL_META.id) {
+    throw new Error(`Unsupported Discord channel meta lookup: ${id}`);
+  }
+  return DISCORD_CHANNEL_META;
+}

package/src/channel.conversation.ts

@@ -0,0 +1,159 @@
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+  normalizeOptionalStringifiedId,
+} from "autobot/plugin-sdk/string-coerce-runtime";
+import { resolveDiscordCurrentConversationIdentity } from "./conversation-identity.js";
+import { normalizeDiscordMessagingTarget } from "./normalize.js";
+import { parseDiscordTarget } from "./target-parsing.js";
+
+export function resolveDiscordAttachedOutboundTarget(params: {
+  to: string;
+  threadId?: string | number | null;
+}): string {
+  if (params.threadId == null) {
+    return params.to;
+  }
+  const threadId = normalizeOptionalStringifiedId(params.threadId) ?? "";
+  return threadId ? `channel:${threadId}` : params.to;
+}
+
+export function buildDiscordCrossContextPresentation(params: {
+  originLabel: string;
+  message: string;
+}) {
+  const trimmed = params.message.trim();
+  return {
+    tone: "neutral" as const,
+    blocks: [
+      ...(trimmed
+        ? ([{ type: "text" as const, text: params.message }, { type: "divider" as const }] as const)
+        : []),
+      { type: "context" as const, text: `From ${params.originLabel}` },
+    ],
+  };
+}
+
+export function normalizeDiscordAcpConversationId(conversationId: string) {
+  const normalized = conversationId.trim();
+  return normalized ? { conversationId: normalized } : null;
+}
+
+export function matchDiscordAcpConversation(params: {
+  bindingConversationId: string;
+  conversationId: string;
+  parentConversationId?: string;
+}) {
+  if (params.bindingConversationId === params.conversationId) {
+    return { conversationId: params.conversationId, matchPriority: 2 };
+  }
+  if (
+    params.parentConversationId &&
+    params.parentConversationId !== params.conversationId &&
+    params.bindingConversationId === params.parentConversationId
+  ) {
+    return {
+      conversationId: params.parentConversationId,
+      matchPriority: 1,
+    };
+  }
+  return null;
+}
+
+function resolveDiscordConversationIdFromTargets(
+  targets: Array<string | undefined>,
+): string | undefined {
+  for (const raw of targets) {
+    const trimmed = raw?.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const target = parseDiscordTarget(trimmed, { defaultKind: "channel" });
+      if (target?.normalized) {
+        return target.normalized;
+      }
+    } catch {
+      const mentionMatch = trimmed.match(/^<#(\d+)>$/);
+      if (mentionMatch?.[1]) {
+        return `channel:${mentionMatch[1]}`;
+      }
+      if (/^\d{6,}$/.test(trimmed)) {
+        return normalizeDiscordMessagingTarget(trimmed);
+      }
+    }
+  }
+  return undefined;
+}
+
+function parseDiscordParentChannelFromSessionKey(raw: unknown): string | undefined {
+  const sessionKey = normalizeLowercaseStringOrEmpty(raw);
+  if (!sessionKey) {
+    return undefined;
+  }
+  const match = sessionKey.match(/(?:^|:)channel:([^:]+)$/);
+  return match?.[1] ? `channel:${match[1]}` : undefined;
+}
+
+export function resolveDiscordCommandConversation(params: {
+  threadId?: string;
+  threadParentId?: string;
+  parentSessionKey?: string;
+  from?: string;
+  chatType?: string;
+  originatingTo?: string;
+  commandTo?: string;
+  fallbackTo?: string;
+}) {
+  const targets = [params.originatingTo, params.commandTo, params.fallbackTo];
+  if (params.threadId) {
+    const parentConversationId =
+      normalizeDiscordMessagingTarget(normalizeOptionalString(params.threadParentId) ?? "") ||
+      parseDiscordParentChannelFromSessionKey(params.parentSessionKey) ||
+      resolveDiscordConversationIdFromTargets(targets);
+    return {
+      conversationId: params.threadId,
+      ...(parentConversationId && parentConversationId !== params.threadId
+        ? { parentConversationId }
+        : {}),
+    };
+  }
+  const conversationId = resolveDiscordCurrentConversationIdentity({
+    from: params.from,
+    chatType: params.chatType,
+    originatingTo: params.originatingTo,
+    commandTo: params.commandTo,
+    fallbackTo: params.fallbackTo,
+  });
+  return conversationId ? { conversationId } : null;
+}
+
+export function resolveDiscordInboundConversation(params: {
+  from?: string;
+  to?: string;
+  conversationId?: string;
+  isGroup: boolean;
+}) {
+  const conversationId = resolveDiscordCurrentConversationIdentity({
+    from: params.from,
+    chatType: params.isGroup ? "group" : "direct",
+    originatingTo: params.to,
+    fallbackTo: params.conversationId,
+  });
+  return conversationId ? { conversationId } : null;
+}
+
+export function parseDiscordExplicitTarget(raw: string) {
+  try {
+    const target = parseDiscordTarget(raw, { defaultKind: "channel" });
+    if (!target) {
+      return null;
+    }
+    return {
+      to: target.normalized,
+      chatType: target.kind === "user" ? ("direct" as const) : ("channel" as const),
+    };
+  } catch {
+    return null;
+  }
+}

package/src/channel.loaders.ts

@@ -0,0 +1,50 @@
+import { createLazyRuntimeModule } from "autobot/plugin-sdk/lazy-runtime";
+
+let discordProviderRuntimePromise:
+  | Promise<typeof import("./monitor/provider.runtime.js")>
+  | undefined;
+let discordProbeRuntimePromise: Promise<typeof import("./probe.runtime.js")> | undefined;
+let discordAuditModulePromise: Promise<typeof import("./audit.js")> | undefined;
+let discordSendModulePromise: Promise<typeof import("./send.js")> | undefined;
+let discordDirectoryLiveModulePromise: Promise<typeof import("./directory-live.js")> | undefined;
+
+export const loadDiscordDirectoryConfigModule = createLazyRuntimeModule(
+  () => import("./directory-config.js"),
+);
+export const loadDiscordResolveChannelsModule = createLazyRuntimeModule(
+  () => import("./resolve-channels.js"),
+);
+export const loadDiscordResolveUsersModule = createLazyRuntimeModule(
+  () => import("./resolve-users.js"),
+);
+export const loadDiscordThreadBindingsManagerModule = createLazyRuntimeModule(
+  () => import("./monitor/thread-bindings.manager.js"),
+);
+export const loadDiscordTargetResolverModule = createLazyRuntimeModule(
+  () => import("./target-resolver.js"),
+);
+
+export async function loadDiscordProviderRuntime() {
+  discordProviderRuntimePromise ??= import("./monitor/provider.runtime.js");
+  return await discordProviderRuntimePromise;
+}
+
+export async function loadDiscordProbeRuntime() {
+  discordProbeRuntimePromise ??= import("./probe.runtime.js");
+  return await discordProbeRuntimePromise;
+}
+
+export async function loadDiscordAuditModule() {
+  discordAuditModulePromise ??= import("./audit.js");
+  return await discordAuditModulePromise;
+}
+
+export async function loadDiscordSendModule() {
+  discordSendModulePromise ??= import("./send.js");
+  return await discordSendModulePromise;
+}
+
+export async function loadDiscordDirectoryLiveModule() {
+  discordDirectoryLiveModulePromise ??= import("./directory-live.js");
+  return await discordDirectoryLiveModulePromise;
+}

package/src/channel.runtime.ts

@@ -0,0 +1 @@
+export { discordSetupWizard } from "./setup-surface.js";

package/src/channel.setup.ts

@@ -0,0 +1,12 @@
+import { type ResolvedDiscordAccount } from "./accounts.js";
+import { type ChannelPlugin } from "./channel-api.js";
+import { discordSetupWizard } from "./channel.runtime.js";
+import { discordSetupAdapter } from "./setup-adapter.js";
+import { createDiscordPluginBase } from "./shared.js";
+
+export const discordSetupPlugin: ChannelPlugin<ResolvedDiscordAccount> = {
+  ...createDiscordPluginBase({
+    setupWizard: discordSetupWizard,
+    setup: discordSetupAdapter,
+  }),
+};