@gakr-gakr/discord 0.1.0

package/src/setup-core.ts

@@ -0,0 +1,215 @@
+import { DEFAULT_ACCOUNT_ID } from "autobot/plugin-sdk/account-id";
+import type { DiscordGuildEntry, AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { ChannelSetupDmPolicy, ChannelSetupWizard } from "autobot/plugin-sdk/setup-runtime";
+import {
+  createSetupTranslator,
+  createStandardChannelSetupStatus,
+} from "autobot/plugin-sdk/setup-runtime";
+import { formatDocsLink } from "autobot/plugin-sdk/setup-tools";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import {
+  inspectDiscordSetupAccount,
+  resolveDiscordSetupAccountConfig,
+} from "./setup-account-state.js";
+import {
+  createAccountScopedAllowFromSection,
+  createAccountScopedGroupAccessSection,
+  createLegacyCompatChannelDmPolicy,
+  parseMentionOrPrefixedId,
+  patchChannelConfigForAccount,
+  setSetupChannelEnabled,
+} from "./setup-runtime-helpers.js";
+
+const t = createSetupTranslator();
+
+const channel = "discord" as const;
+const DISCORD_TOKEN_HELP_LINES = [
+  t("wizard.discord.tokenHelpCreateApplication"),
+  t("wizard.discord.tokenHelpCopyToken"),
+  t("wizard.discord.tokenHelpInviteBot"),
+  t("wizard.discord.tokenHelpMessageContentIntent"),
+  t("wizard.channels.docs", { link: formatDocsLink("/discord", "discord") }),
+];
+
+type DiscordGuildChannelAllowlistEntry = {
+  guildKey: string;
+  channelKey?: string;
+};
+
+type DiscordSetupAllowlistResolution = {
+  resolved?: boolean;
+  guildId?: string;
+  channelId?: string;
+  guildKey?: string;
+  channelKey?: string;
+};
+
+function mapDiscordSetupAllowlistEntries(resolved: unknown): DiscordGuildChannelAllowlistEntry[] {
+  if (!Array.isArray(resolved)) {
+    return [];
+  }
+  return resolved.flatMap((entry): DiscordGuildChannelAllowlistEntry[] => {
+    if (!entry || typeof entry !== "object") {
+      return [];
+    }
+    const row = entry as DiscordSetupAllowlistResolution;
+    if (row.resolved === false) {
+      return [];
+    }
+    const guildKey = normalizeOptionalString(row.guildId ?? row.guildKey);
+    if (!guildKey) {
+      return [];
+    }
+    const channelKey = normalizeOptionalString(row.channelId ?? row.channelKey);
+    return channelKey ? [{ guildKey, channelKey }] : [{ guildKey }];
+  });
+}
+
+function setDiscordGuildChannelAllowlist(
+  cfg: AutoBotConfig,
+  accountId: string,
+  entries: DiscordGuildChannelAllowlistEntry[],
+): AutoBotConfig {
+  const baseGuilds =
+    accountId === DEFAULT_ACCOUNT_ID
+      ? (cfg.channels?.discord?.guilds ?? {})
+      : (cfg.channels?.discord?.accounts?.[accountId]?.guilds ?? {});
+  const guilds: Record<string, DiscordGuildEntry> = { ...baseGuilds };
+  for (const entry of entries) {
+    const guildKey = entry.guildKey || "*";
+    const existing = guilds[guildKey] ?? {};
+    if (entry.channelKey) {
+      const channels = { ...existing.channels };
+      channels[entry.channelKey] = { enabled: true };
+      guilds[guildKey] = { ...existing, channels };
+    } else {
+      guilds[guildKey] = existing;
+    }
+  }
+  return patchChannelConfigForAccount({
+    cfg,
+    channel,
+    accountId,
+    patch: { guilds },
+  });
+}
+
+export function parseDiscordAllowFromId(value: string): string | null {
+  return parseMentionOrPrefixedId({
+    value,
+    mentionPattern: /^<@!?(\d+)>$/,
+    prefixPattern: /^(user:|discord:)/i,
+    idPattern: /^\d+$/,
+  });
+}
+
+export function createDiscordSetupWizardBase(handlers: {
+  promptAllowFrom: NonNullable<ChannelSetupDmPolicy["promptAllowFrom"]>;
+  resolveAllowFromEntries: NonNullable<
+    NonNullable<ChannelSetupWizard["allowFrom"]>["resolveEntries"]
+  >;
+  resolveGroupAllowlist: NonNullable<
+    NonNullable<NonNullable<ChannelSetupWizard["groupAccess"]>["resolveAllowlist"]>
+  >;
+}) {
+  const discordDmPolicy: ChannelSetupDmPolicy = createLegacyCompatChannelDmPolicy({
+    label: "Discord",
+    channel,
+    promptAllowFrom: handlers.promptAllowFrom,
+  });
+
+  return {
+    channel,
+    status: createStandardChannelSetupStatus({
+      channelLabel: "Discord",
+      configuredLabel: t("wizard.channels.statusConfigured"),
+      unconfiguredLabel: t("wizard.channels.statusNeedsToken"),
+      configuredHint: t("wizard.channels.statusConfigured"),
+      unconfiguredHint: t("wizard.channels.statusNeedsToken"),
+      configuredScore: 2,
+      unconfiguredScore: 1,
+      resolveConfigured: ({ cfg, accountId }) =>
+        inspectDiscordSetupAccount({ cfg, accountId }).configured,
+    }),
+    credentials: [
+      {
+        inputKey: "token",
+        providerHint: channel,
+        credentialLabel: t("wizard.discord.botToken"),
+        preferredEnvVar: "DISCORD_BOT_TOKEN",
+        helpTitle: t("wizard.discord.botToken"),
+        helpLines: DISCORD_TOKEN_HELP_LINES,
+        envPrompt: t("wizard.discord.tokenEnvPrompt"),
+        keepPrompt: t("wizard.discord.tokenKeepPrompt"),
+        inputPrompt: t("wizard.discord.tokenInputPrompt"),
+        allowEnv: ({ accountId }: { accountId: string }) => accountId === DEFAULT_ACCOUNT_ID,
+        inspect: ({ cfg, accountId }: { cfg: AutoBotConfig; accountId: string }) => {
+          const account = inspectDiscordSetupAccount({ cfg, accountId });
+          return {
+            accountConfigured: account.configured,
+            hasConfiguredValue: account.tokenStatus !== "missing",
+            resolvedValue: normalizeOptionalString(account.token),
+            envValue:
+              accountId === DEFAULT_ACCOUNT_ID
+                ? normalizeOptionalString(process.env.DISCORD_BOT_TOKEN)
+                : undefined,
+          };
+        },
+      },
+    ],
+    groupAccess: createAccountScopedGroupAccessSection({
+      channel,
+      label: t("wizard.discord.channelsLabel"),
+      placeholder: "My Server/#general, guildId/channelId, #support",
+      currentPolicy: ({ cfg, accountId }: { cfg: AutoBotConfig; accountId: string }) =>
+        resolveDiscordSetupAccountConfig({ cfg, accountId }).config.groupPolicy ?? "allowlist",
+      currentEntries: ({ cfg, accountId }: { cfg: AutoBotConfig; accountId: string }) =>
+        Object.entries(
+          resolveDiscordSetupAccountConfig({ cfg, accountId }).config.guilds ?? {},
+        ).flatMap(([guildKey, value]) => {
+          const channels = value?.channels ?? {};
+          const channelKeys = Object.keys(channels);
+          if (channelKeys.length === 0) {
+            const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
+            return [input];
+          }
+          return channelKeys.map((channelKey) => `${guildKey}/${channelKey}`);
+        }),
+      updatePrompt: ({ cfg, accountId }: { cfg: AutoBotConfig; accountId: string }) =>
+        Boolean(resolveDiscordSetupAccountConfig({ cfg, accountId }).config.guilds),
+      resolveAllowlist: handlers.resolveGroupAllowlist,
+      fallbackResolved: (entries) => entries.map((input) => ({ input, resolved: false })),
+      applyAllowlist: ({
+        cfg,
+        accountId,
+        resolved,
+      }: {
+        cfg: AutoBotConfig;
+        accountId: string;
+        resolved: unknown;
+      }) =>
+        setDiscordGuildChannelAllowlist(cfg, accountId, mapDiscordSetupAllowlistEntries(resolved)),
+    }),
+    allowFrom: createAccountScopedAllowFromSection({
+      channel,
+      credentialInputKey: "token",
+      helpTitle: "Discord allowlist",
+      helpLines: [
+        t("wizard.discord.allowlistIntro"),
+        t("wizard.discord.examples"),
+        "- 123456789012345678",
+        "- @alice",
+        "- alice#1234",
+        t("wizard.discord.multipleEntries"),
+        t("wizard.channels.docs", { link: formatDocsLink("/discord", "discord") }),
+      ],
+      message: t("wizard.discord.allowFromPrompt"),
+      placeholder: "@alice, 123456789012345678",
+      invalidWithoutCredentialNote: t("wizard.discord.allowFromInvalidWithoutToken"),
+      parseId: parseDiscordAllowFromId,
+      resolveEntries: handlers.resolveAllowFromEntries,
+    }),
+    dmPolicy: discordDmPolicy,
+    disable: (cfg: AutoBotConfig) => setSetupChannelEnabled(cfg, channel, false),
+  } satisfies ChannelSetupWizard;
+}

package/src/setup-runtime-helpers.ts

@@ -0,0 +1,10 @@
+export {
+  createAccountScopedAllowFromSection,
+  createAccountScopedGroupAccessSection,
+  createLegacyCompatChannelDmPolicy,
+  parseMentionOrPrefixedId,
+  patchChannelConfigForAccount,
+  promptLegacyChannelAllowFromForAccount,
+  resolveEntriesWithOptionalToken,
+  setSetupChannelEnabled,
+} from "autobot/plugin-sdk/setup-runtime";

package/src/setup-surface.ts

@@ -0,0 +1,132 @@
+import {
+  createSetupTranslator,
+  type ChannelSetupWizard,
+  type AutoBotConfig,
+  type WizardPrompter,
+} from "autobot/plugin-sdk/setup-runtime";
+import { formatDocsLink } from "autobot/plugin-sdk/setup-tools";
+import { resolveDiscordAccountAllowFrom } from "./accounts.js";
+import { resolveDiscordChannelAllowlist } from "./resolve-channels.js";
+import { resolveDiscordUserAllowlist } from "./resolve-users.js";
+import {
+  resolveDefaultDiscordSetupAccountId,
+  resolveDiscordSetupAccountConfig,
+} from "./setup-account-state.js";
+import { createDiscordSetupWizardBase, parseDiscordAllowFromId } from "./setup-core.js";
+import {
+  promptLegacyChannelAllowFromForAccount,
+  resolveEntriesWithOptionalToken,
+} from "./setup-runtime-helpers.js";
+import { resolveDiscordToken } from "./token.js";
+
+const t = createSetupTranslator();
+
+const channel = "discord" as const;
+
+async function resolveDiscordAllowFromEntries(params: { token?: string; entries: string[] }) {
+  return await resolveEntriesWithOptionalToken({
+    token: params.token,
+    entries: params.entries,
+    buildWithoutToken: (input) => ({
+      input,
+      resolved: false,
+      id: null,
+    }),
+    resolveEntries: async ({ token, entries }) =>
+      (
+        await resolveDiscordUserAllowlist({
+          token,
+          entries,
+        })
+      ).map((entry) => ({
+        input: entry.input,
+        resolved: entry.resolved,
+        id: entry.id ?? null,
+      })),
+  });
+}
+
+async function promptDiscordAllowFrom(params: {
+  cfg: AutoBotConfig;
+  prompter: WizardPrompter;
+  accountId?: string;
+}): Promise<AutoBotConfig> {
+  return await promptLegacyChannelAllowFromForAccount({
+    cfg: params.cfg,
+    channel,
+    prompter: params.prompter,
+    accountId: params.accountId,
+    defaultAccountId: resolveDefaultDiscordSetupAccountId(params.cfg),
+    resolveAccount: (cfg, accountId) => resolveDiscordSetupAccountConfig({ cfg, accountId }),
+    noteTitle: t("wizard.discord.allowlistTitle"),
+    noteLines: [
+      t("wizard.discord.allowlistIntro"),
+      t("wizard.discord.examples"),
+      "- 123456789012345678",
+      "- @alice",
+      "- alice#1234",
+      t("wizard.discord.multipleEntries"),
+      t("wizard.channels.docs", { link: formatDocsLink("/discord", "discord") }),
+    ],
+    message: t("wizard.discord.allowFromPrompt"),
+    placeholder: "@alice, 123456789012345678",
+    parseId: parseDiscordAllowFromId,
+    invalidWithoutTokenNote: t("wizard.discord.allowFromInvalidWithoutToken"),
+    resolveExisting: (account, cfg) =>
+      resolveDiscordAccountAllowFrom({ cfg, accountId: account.accountId }) ?? [],
+    resolveToken: (account) =>
+      resolveDiscordToken(params.cfg, { accountId: account.accountId }).token,
+    resolveEntries: async ({ token, entries }) =>
+      (
+        await resolveDiscordUserAllowlist({
+          token,
+          entries,
+        })
+      ).map((entry) => ({
+        input: entry.input,
+        resolved: entry.resolved,
+        id: entry.id ?? null,
+      })),
+  });
+}
+
+async function resolveDiscordGroupAllowlist(params: {
+  cfg: AutoBotConfig;
+  accountId: string;
+  credentialValues: { token?: string };
+  entries: string[];
+}) {
+  return await resolveEntriesWithOptionalToken({
+    token:
+      resolveDiscordToken(params.cfg, { accountId: params.accountId }).token ||
+      (typeof params.credentialValues.token === "string" ? params.credentialValues.token : ""),
+    entries: params.entries,
+    buildWithoutToken: (input) => ({
+      input,
+      resolved: false,
+    }),
+    resolveEntries: async ({ token, entries }) =>
+      await resolveDiscordChannelAllowlist({
+        token,
+        entries,
+      }),
+  });
+}
+
+export const discordSetupWizard: ChannelSetupWizard = createDiscordSetupWizardBase({
+  promptAllowFrom: promptDiscordAllowFrom,
+  resolveAllowFromEntries: async ({ cfg, accountId, credentialValues, entries }) =>
+    await resolveDiscordAllowFromEntries({
+      token:
+        resolveDiscordToken(cfg, { accountId }).token ||
+        (typeof credentialValues.token === "string" ? credentialValues.token : ""),
+      entries,
+    }),
+  resolveGroupAllowlist: async ({ cfg, accountId, credentialValues, entries }) =>
+    await resolveDiscordGroupAllowlist({
+      cfg,
+      accountId,
+      credentialValues,
+      entries,
+    }),
+});

package/src/shared-interactive.ts

@@ -0,0 +1,167 @@
+import { reduceInteractiveReply } from "autobot/plugin-sdk/interactive-runtime";
+import type {
+  InteractiveButtonStyle,
+  InteractiveReply,
+  MessagePresentation,
+  MessagePresentationButton,
+} from "autobot/plugin-sdk/interactive-runtime";
+import type {
+  DiscordComponentButtonSpec,
+  DiscordComponentButtonStyle,
+  DiscordComponentMessageSpec,
+} from "./components.types.js";
+
+function resolveDiscordInteractiveButtonStyle(
+  style?: InteractiveButtonStyle,
+): DiscordComponentButtonStyle | undefined {
+  return style ?? "secondary";
+}
+
+const DISCORD_INTERACTIVE_BUTTON_ROW_SIZE = 5;
+
+/**
+ * @deprecated Use buildDiscordPresentationComponents with MessagePresentation.
+ */
+export function buildDiscordInteractiveComponents(
+  interactive?: InteractiveReply,
+): DiscordComponentMessageSpec | undefined {
+  const blocks = reduceInteractiveReply(
+    interactive,
+    [] as NonNullable<DiscordComponentMessageSpec["blocks"]>,
+    (state, block) => {
+      if (block.type === "text") {
+        const text = block.text.trim();
+        if (text) {
+          state.push({ type: "text", text });
+        }
+        return state;
+      }
+      if (block.type === "buttons") {
+        if (block.buttons.length === 0) {
+          return state;
+        }
+        for (
+          let index = 0;
+          index < block.buttons.length;
+          index += DISCORD_INTERACTIVE_BUTTON_ROW_SIZE
+        ) {
+          state.push({
+            type: "actions",
+            buttons: block.buttons
+              .slice(index, index + DISCORD_INTERACTIVE_BUTTON_ROW_SIZE)
+              .map((button) => {
+                const spec: DiscordComponentButtonSpec = {
+                  label: button.label,
+                  style: button.url ? "link" : resolveDiscordInteractiveButtonStyle(button.style),
+                };
+                if (button.value) {
+                  spec.callbackData = button.value;
+                }
+                if (button.url) {
+                  spec.url = button.url;
+                }
+                if (button.disabled === true) {
+                  spec.disabled = true;
+                }
+                return spec;
+              }),
+          });
+        }
+        return state;
+      }
+      if (block.type === "select" && block.options.length > 0) {
+        state.push({
+          type: "actions",
+          select: {
+            type: "string",
+            placeholder: block.placeholder,
+            options: block.options.map((option) => ({
+              label: option.label,
+              value: option.value,
+            })),
+          },
+        });
+      }
+      return state;
+    },
+  );
+  return blocks.length > 0 ? { blocks } : undefined;
+}
+
+export function buildDiscordPresentationComponents(
+  presentation?: MessagePresentation,
+): DiscordComponentMessageSpec | undefined {
+  if (!presentation) {
+    return undefined;
+  }
+  const spec: DiscordComponentMessageSpec = { blocks: [] };
+  if (presentation.title) {
+    spec.blocks?.push({ type: "text", text: presentation.title });
+  }
+  for (const block of presentation.blocks) {
+    if (block.type === "text" || block.type === "context") {
+      const text = block.text.trim();
+      if (text) {
+        spec.blocks?.push({
+          type: "text",
+          text: block.type === "context" ? `-# ${text}` : text,
+        });
+      }
+      continue;
+    }
+    if (block.type === "divider") {
+      spec.blocks?.push({ type: "separator" });
+      continue;
+    }
+  }
+  for (const block of presentation.blocks) {
+    if (block.type === "buttons") {
+      appendDiscordPresentationButtonBlocks(spec, block.buttons);
+      continue;
+    }
+    if (block.type === "select" && block.options.length > 0) {
+      spec.blocks?.push({
+        type: "actions",
+        select: {
+          type: "string",
+          placeholder: block.placeholder,
+          options: block.options.map((option) => ({
+            label: option.label,
+            value: option.value,
+          })),
+        },
+      });
+    }
+  }
+  return spec.blocks?.length ? spec : undefined;
+}
+
+function appendDiscordPresentationButtonBlocks(
+  spec: DiscordComponentMessageSpec,
+  buttons: readonly MessagePresentationButton[],
+) {
+  if (buttons.length === 0) {
+    return;
+  }
+  for (let index = 0; index < buttons.length; index += DISCORD_INTERACTIVE_BUTTON_ROW_SIZE) {
+    spec.blocks?.push({
+      type: "actions",
+      buttons: buttons.slice(index, index + DISCORD_INTERACTIVE_BUTTON_ROW_SIZE).map((button) => {
+        const component: DiscordComponentButtonSpec = {
+          label: button.label,
+          style: button.url ? "link" : resolveDiscordInteractiveButtonStyle(button.style),
+        };
+        if (button.value) {
+          component.callbackData = button.value;
+        }
+        if (button.url) {
+          component.url = button.url;
+        }
+        if (button.disabled === true) {
+          component.disabled = true;
+        }
+        return component;
+      }),
+    });
+  }
+}