@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/internal/commands.ts

@@ -1,188 +0,0 @@
-import {
-  ApplicationCommandOptionType,
-  ApplicationCommandType,
-  InteractionContextType,
-  type RESTPostAPIApplicationCommandsJSONBody,
-} from "discord-api-types/v10";
-import type { BaseMessageInteractiveComponent } from "./components.js";
-import type { AutocompleteInteraction, CommandInteraction } from "./interactions.js";
-
-export type ConditionalCommandOption = (interaction: unknown) => boolean;
-export type CommandOption = Record<string, unknown> & {
-  name: string;
-  description?: string;
-  type: ApplicationCommandOptionType;
-  required?: boolean;
-  choices?: Array<{ name: string; value: string | number | boolean }>;
-  autocomplete?: boolean | ((interaction: AutocompleteInteraction) => Promise<void>);
-};
-export type CommandOptions = CommandOption[];
-
-type RawSubcommandOption = {
-  name?: unknown;
-  type?: unknown;
-  options?: RawSubcommandOption[];
-};
-
-function clean<T extends Record<string, unknown>>(value: T): T {
-  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as T;
-}
-
-function resolveConditionalCommandOption(
-  value: boolean | ConditionalCommandOption,
-  interaction: unknown,
-): boolean {
-  return typeof value === "function" ? value(interaction) : value;
-}
-
-export async function deferCommandInteractionIfNeeded(
-  command: BaseCommand,
-  interaction: CommandInteraction,
-): Promise<void> {
-  if (!resolveConditionalCommandOption(command.defer, interaction)) {
-    return;
-  }
-  await interaction.defer({
-    ephemeral: resolveConditionalCommandOption(command.ephemeral, interaction),
-  });
-}
-
-function readRawCommandOptions(interaction: CommandInteraction): RawSubcommandOption[] {
-  const options = (interaction.rawData as { data?: { options?: unknown } }).data?.options;
-  return Array.isArray(options) ? (options as RawSubcommandOption[]) : [];
-}
-
-function findSelectedSubcommand(
-  subcommands: Command[],
-  interaction: CommandInteraction,
-): Command | undefined {
-  const subcommandName = readRawCommandOptions(interaction).find(
-    (option) => option.type === ApplicationCommandOptionType.Subcommand,
-  )?.name;
-  return typeof subcommandName === "string"
-    ? subcommands.find((command) => command.name === subcommandName)
-    : undefined;
-}
-
-function findCommandOption(
-  options: CommandOptions | undefined,
-  name: string | undefined,
-): CommandOption | undefined {
-  if (!name) {
-    return undefined;
-  }
-  return options?.find((option) => option.name === name);
-}
-
-function hasCommandOptions(
-  command: BaseCommand,
-): command is BaseCommand & { options?: CommandOptions } {
-  return "options" in command;
-}
-
-export function resolveFocusedCommandOptionAutocompleteHandler(
-  command: BaseCommand,
-  interaction: AutocompleteInteraction,
-): ((interaction: AutocompleteInteraction) => Promise<void>) | undefined {
-  const focusedName = interaction.options.getFocused()?.name;
-  const options =
-    "subcommands" in command && Array.isArray(command.subcommands)
-      ? findSelectedSubcommand(command.subcommands, interaction)?.options
-      : hasCommandOptions(command)
-        ? command.options
-        : undefined;
-  const autocomplete = findCommandOption(options, focusedName)?.autocomplete;
-  return typeof autocomplete === "function" ? autocomplete : undefined;
-}
-
-export abstract class BaseCommand {
-  id?: string;
-  abstract name: string;
-  description?: string;
-  nameLocalizations?: Record<string, string>;
-  descriptionLocalizations?: Record<string, string>;
-  defer: boolean | ConditionalCommandOption = false;
-  ephemeral: boolean | ConditionalCommandOption = false;
-  abstract type: ApplicationCommandType;
-  integrationTypes = [0, 1];
-  contexts = [
-    InteractionContextType.Guild,
-    InteractionContextType.BotDM,
-    InteractionContextType.PrivateChannel,
-  ];
-  permission?: bigint | bigint[];
-  components?: BaseMessageInteractiveComponent[];
-  guildIds?: string[];
-  abstract serializeOptions(): unknown[] | undefined;
-  serialize(): RESTPostAPIApplicationCommandsJSONBody {
-    return clean({
-      name: this.name,
-      name_localizations: this.nameLocalizations,
-      description:
-        this.type === ApplicationCommandType.ChatInput ? (this.description ?? "") : undefined,
-      description_localizations: this.descriptionLocalizations,
-      type: this.type,
-      options: this.serializeOptions() as RESTPostAPIApplicationCommandsJSONBody["options"],
-      integration_types: this.integrationTypes,
-      contexts: this.contexts,
-      default_member_permissions: Array.isArray(this.permission)
-        ? this.permission.reduce((sum, entry) => sum | entry, 0n).toString()
-        : this.permission
-          ? this.permission.toString()
-          : null,
-    }) as RESTPostAPIApplicationCommandsJSONBody;
-  }
-}
-
-export abstract class Command extends BaseCommand {
-  options?: CommandOptions;
-  type = ApplicationCommandType.ChatInput;
-  abstract run(interaction: unknown): unknown;
-  async autocomplete(interaction: unknown): Promise<void> {
-    throw new Error(
-      `The ${(interaction as { rawData?: { data?: { name?: string } } }).rawData?.data?.name ?? this.name} command does not support autocomplete`,
-    );
-  }
-  async preCheck(interaction: unknown): Promise<unknown> {
-    return Boolean(interaction) || true;
-  }
-  serializeOptions() {
-    return this.options?.map((option) => {
-      if (typeof option.autocomplete === "function") {
-        const { autocomplete: _autocomplete, ...rest } = option;
-        return { ...rest, autocomplete: true };
-      }
-      return option;
-    }) as unknown[];
-  }
-}
-
-export abstract class CommandWithSubcommands extends BaseCommand {
-  type = ApplicationCommandType.ChatInput;
-  abstract subcommands: Command[];
-  async run(interaction: CommandInteraction): Promise<unknown> {
-    const subcommand = findSelectedSubcommand(this.subcommands, interaction);
-    if (!subcommand) {
-      const subcommandName = readRawCommandOptions(interaction).find(
-        (option) => option.type === ApplicationCommandOptionType.Subcommand,
-      )?.name;
-      throw new Error(
-        `Unknown Discord subcommand: ${typeof subcommandName === "string" ? subcommandName : "<missing>"}`,
-      );
-    }
-    await deferCommandInteractionIfNeeded(subcommand, interaction);
-    return await subcommand.run(interaction);
-  }
-  serializeOptions() {
-    return this.subcommands.map((command) =>
-      clean({
-        name: command.name,
-        name_localizations: command.nameLocalizations,
-        description: command.description ?? "",
-        description_localizations: command.descriptionLocalizations,
-        type: ApplicationCommandOptionType.Subcommand,
-        options: command.serializeOptions(),
-      }),
-    );
-  }
-}

package/src/internal/components.base.ts

@@ -1,65 +0,0 @@
-import type { BaseComponentInteraction } from "./interactions.js";
-
-export type ComponentParserResult = {
-  key: string;
-  data: Record<string, string | boolean>;
-};
-export type ComponentData<
-  T extends keyof ComponentParserResult["data"] = keyof ComponentParserResult["data"],
-> = {
-  [K in T]: ComponentParserResult["data"][K];
-};
-export type ConditionalComponentOption = (interaction: BaseComponentInteraction) => boolean;
-
-export function parseCustomId(id: string): ComponentParserResult {
-  const [rawKey, ...parts] = id.split(";");
-  const [keyPart, firstValue] = rawKey.split("=");
-  const key = keyPart.includes(":") ? keyPart.split(":")[0] : keyPart;
-  const data: ComponentParserResult["data"] = {};
-  const entries = firstValue === undefined ? parts : [rawKey.slice(key.length + 1), ...parts];
-  for (const entry of entries) {
-    const index = entry.indexOf("=");
-    if (index < 0) {
-      continue;
-    }
-    const name = entry.slice(0, index).replace(/^[^:]+:/, "");
-    const raw = entry.slice(index + 1);
-    data[name] = raw === "true" ? true : raw === "false" ? false : raw;
-  }
-  return { key, data };
-}
-
-export function clean<T extends Record<string, unknown>>(value: T): T {
-  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as T;
-}
-
-export function colorToNumber(value: string | number | undefined): number | undefined {
-  if (typeof value === "number") {
-    return value;
-  }
-  if (typeof value === "string" && /^#?[0-9a-f]{6}$/i.test(value)) {
-    return Number.parseInt(value.replace(/^#/, ""), 16);
-  }
-  return undefined;
-}
-
-export abstract class BaseComponent {
-  abstract readonly type: number;
-  readonly isV2: boolean = false;
-  abstract serialize(): unknown;
-}
-
-export abstract class BaseMessageInteractiveComponent extends BaseComponent {
-  readonly isV2 = false;
-  defer: boolean | ConditionalComponentOption = false;
-  ephemeral: boolean | ConditionalComponentOption = false;
-  abstract customId: string;
-  customIdParser = parseCustomId;
-  run(_interaction: BaseComponentInteraction, _data: ComponentData): unknown {
-    return undefined;
-  }
-}
-
-export abstract class BaseModalComponent extends BaseComponent {
-  abstract customId: string;
-}

package/src/internal/components.message.ts

@@ -1,279 +0,0 @@
-import {
-  ButtonStyle,
-  ComponentType,
-  type APIActionRowComponent,
-  type APIButtonComponent,
-  type APIChannelSelectComponent,
-  type APIComponentInMessageActionRow,
-  type APIContainerComponent,
-  type APIFileComponent,
-  type APIMediaGalleryComponent,
-  type APISectionComponent,
-  type APISeparatorComponent,
-  type APIStringSelectComponent,
-  type APITextDisplayComponent,
-  type APIThumbnailComponent,
-} from "discord-api-types/v10";
-import {
-  BaseComponent,
-  BaseMessageInteractiveComponent,
-  clean,
-  colorToNumber,
-} from "./components.base.js";
-
-abstract class BaseButton extends BaseMessageInteractiveComponent {
-  readonly type = ComponentType.Button;
-  abstract label: string;
-  emoji?: { name: string; id?: string; animated?: boolean };
-  style: ButtonStyle = ButtonStyle.Primary;
-  disabled = false;
-}
-
-export abstract class Button extends BaseButton {
-  serialize(): APIButtonComponent {
-    return clean({
-      type: this.type,
-      style: this.style,
-      custom_id: this.customId,
-      label: this.label,
-      emoji: this.emoji,
-      disabled: this.disabled || undefined,
-    }) as APIButtonComponent;
-  }
-}
-
-export abstract class LinkButton extends BaseButton {
-  customId = "";
-  abstract url: string;
-  style = ButtonStyle.Link;
-  async run(): Promise<never> {
-    throw new Error("Link buttons do not run handlers");
-  }
-  serialize(): APIButtonComponent {
-    return clean({
-      type: this.type,
-      style: this.style,
-      label: this.label,
-      emoji: this.emoji,
-      disabled: this.disabled || undefined,
-      url: this.url,
-    }) as APIButtonComponent;
-  }
-}
-
-export abstract class AnySelectMenu extends BaseMessageInteractiveComponent {
-  placeholder?: string;
-  minValues?: number;
-  maxValues?: number;
-  disabled = false;
-  required?: boolean;
-  abstract serializeOptions(): Record<string, unknown>;
-  serialize() {
-    return clean({
-      ...this.serializeOptions(),
-      custom_id: this.customId,
-      placeholder: this.placeholder,
-      min_values: this.minValues,
-      max_values: this.maxValues,
-      disabled: this.disabled || undefined,
-      required: this.required,
-    });
-  }
-}
-
-export abstract class StringSelectMenu extends AnySelectMenu {
-  readonly type = ComponentType.StringSelect;
-  abstract options: APIStringSelectComponent["options"];
-  serializeOptions() {
-    return { type: this.type, options: this.options };
-  }
-}
-
-export abstract class UserSelectMenu extends AnySelectMenu {
-  readonly type = ComponentType.UserSelect;
-  defaultValues?: unknown[];
-  serializeOptions() {
-    return { type: this.type, default_values: this.defaultValues };
-  }
-}
-
-export abstract class RoleSelectMenu extends AnySelectMenu {
-  readonly type = ComponentType.RoleSelect;
-  defaultValues?: unknown[];
-  serializeOptions() {
-    return { type: this.type, default_values: this.defaultValues };
-  }
-}
-
-export abstract class MentionableSelectMenu extends AnySelectMenu {
-  readonly type = ComponentType.MentionableSelect;
-  defaultValues?: unknown[];
-  serializeOptions() {
-    return { type: this.type, default_values: this.defaultValues };
-  }
-}
-
-export abstract class ChannelSelectMenu extends AnySelectMenu {
-  readonly type = ComponentType.ChannelSelect;
-  channelTypes?: APIChannelSelectComponent["channel_types"];
-  defaultValues?: unknown[];
-  serializeOptions() {
-    return {
-      type: this.type,
-      default_values: this.defaultValues,
-      channel_types: this.channelTypes,
-    };
-  }
-}
-
-export class Row<T extends BaseMessageInteractiveComponent> extends BaseComponent {
-  readonly type = ComponentType.ActionRow;
-  readonly isV2 = false;
-  components: T[];
-  constructor(components: T[] = []) {
-    super();
-    this.components = components;
-  }
-  addComponent(component: T): void {
-    this.components.push(component);
-  }
-  removeComponent(component: T): void {
-    this.components = this.components.filter((entry) => entry !== component);
-  }
-  removeAllComponents(): void {
-    this.components = [];
-  }
-  serialize(): APIActionRowComponent<APIComponentInMessageActionRow> {
-    return {
-      type: this.type,
-      components: this.components.map(
-        (entry) => entry.serialize() as APIComponentInMessageActionRow,
-      ),
-    };
-  }
-}
-
-export class TextDisplay extends BaseComponent {
-  readonly type = ComponentType.TextDisplay;
-  readonly isV2 = true;
-  constructor(public content?: string) {
-    super();
-  }
-  serialize(): APITextDisplayComponent {
-    return clean({ type: this.type, content: this.content }) as APITextDisplayComponent;
-  }
-}
-
-export class Separator extends BaseComponent {
-  readonly type = ComponentType.Separator;
-  readonly isV2 = true;
-  divider = true;
-  spacing: 1 | 2 | "small" | "large" = "small";
-  constructor(options?: { spacing?: Separator["spacing"]; divider?: boolean }) {
-    super();
-    this.spacing = options?.spacing ?? this.spacing;
-    this.divider = options?.divider ?? this.divider;
-  }
-  serialize(): APISeparatorComponent {
-    return clean({
-      type: this.type,
-      divider: this.divider,
-      spacing: this.spacing === "large" ? 2 : this.spacing === "small" ? 1 : this.spacing,
-    }) as APISeparatorComponent;
-  }
-}
-
-export class Thumbnail extends BaseComponent {
-  readonly type = ComponentType.Thumbnail;
-  readonly isV2 = true;
-  constructor(public url?: string) {
-    super();
-  }
-  serialize(): APIThumbnailComponent {
-    return clean({
-      type: this.type,
-      media: this.url ? { url: this.url } : undefined,
-    }) as APIThumbnailComponent;
-  }
-}
-
-export class Section extends BaseComponent {
-  readonly type = ComponentType.Section;
-  readonly isV2 = true;
-  constructor(
-    public components: TextDisplay[] = [],
-    public accessory?: Thumbnail | Button | LinkButton,
-  ) {
-    super();
-  }
-  serialize(): APISectionComponent {
-    return clean({
-      type: this.type,
-      components: this.components.map((entry) => entry.serialize()),
-      accessory: this.accessory?.serialize(),
-    }) as APISectionComponent;
-  }
-}
-
-export class MediaGallery extends BaseComponent {
-  readonly type = ComponentType.MediaGallery;
-  readonly isV2 = true;
-  constructor(public items: Array<{ url: string; description?: string; spoiler?: boolean }> = []) {
-    super();
-  }
-  serialize(): APIMediaGalleryComponent {
-    return {
-      type: this.type,
-      items: this.items.map((entry) => ({
-        media: { url: entry.url },
-        description: entry.description,
-        spoiler: entry.spoiler,
-      })),
-    };
-  }
-}
-
-export class File extends BaseComponent {
-  readonly type = ComponentType.File;
-  readonly isV2 = true;
-  constructor(
-    public file?: `attachment://${string}`,
-    public spoiler = false,
-  ) {
-    super();
-  }
-  serialize(): APIFileComponent {
-    return clean({
-      type: this.type,
-      file: this.file ? { url: this.file } : undefined,
-      spoiler: this.spoiler || undefined,
-    }) as APIFileComponent;
-  }
-}
-
-export class Container extends BaseComponent {
-  readonly type = ComponentType.Container;
-  readonly isV2 = true;
-  components: Array<
-    Row<BaseMessageInteractiveComponent> | TextDisplay | Section | MediaGallery | Separator | File
-  >;
-  accentColor?: string | number;
-  spoiler = false;
-  constructor(
-    components: Container["components"] = [],
-    options?: { accentColor?: string | number; spoiler?: boolean },
-  ) {
-    super();
-    this.components = components;
-    this.accentColor = options?.accentColor;
-    this.spoiler = options?.spoiler ?? false;
-  }
-  serialize(): APIContainerComponent {
-    return clean({
-      type: this.type,
-      components: this.components.map((entry) => entry.serialize()),
-      accent_color: colorToNumber(this.accentColor),
-      spoiler: this.spoiler || undefined,
-    }) as APIContainerComponent;
-  }
-}

package/src/internal/components.modal.ts

@@ -1,95 +0,0 @@
-import { ComponentType, TextInputStyle, type APITextInputComponent } from "discord-api-types/v10";
-import { BaseModalComponent, clean, parseCustomId, type ComponentData } from "./components.base.js";
-import { AnySelectMenu, TextDisplay } from "./components.message.js";
-
-export abstract class TextInput extends BaseModalComponent {
-  readonly type = ComponentType.TextInput;
-  customIdParser = parseCustomId;
-  style: TextInputStyle = TextInputStyle.Short;
-  minLength?: number;
-  maxLength?: number;
-  required?: boolean;
-  value?: string;
-  placeholder?: string;
-  serialize(): APITextInputComponent {
-    return clean({
-      type: this.type,
-      custom_id: this.customId,
-      style: this.style,
-      min_length: this.minLength,
-      max_length: this.maxLength,
-      required: this.required,
-      value: this.value,
-      placeholder: this.placeholder,
-    }) as APITextInputComponent;
-  }
-}
-
-export abstract class CheckboxGroup extends BaseModalComponent {
-  readonly type = 22;
-  options: Array<{ value: string; label: string; description?: string; default?: boolean }> = [];
-  required?: boolean;
-  minValues?: number;
-  maxValues?: number;
-  serialize() {
-    return clean({
-      type: this.type,
-      custom_id: this.customId,
-      options: this.options,
-      required: this.required,
-      min_values: this.minValues,
-      max_values: this.maxValues,
-    });
-  }
-}
-
-export abstract class RadioGroup extends BaseModalComponent {
-  readonly type = 21;
-  options: Array<{ value: string; label: string; description?: string; default?: boolean }> = [];
-  required?: boolean;
-  minValues?: number;
-  maxValues?: number;
-  serialize() {
-    return clean({
-      type: this.type,
-      custom_id: this.customId,
-      options: this.options,
-      required: this.required,
-      min_values: this.minValues,
-      max_values: this.maxValues,
-    });
-  }
-}
-
-export abstract class Label extends BaseModalComponent {
-  readonly type = ComponentType.Label;
-  abstract label: string;
-  description?: string;
-  customId = "";
-  constructor(public component?: TextInput | AnySelectMenu | CheckboxGroup | RadioGroup) {
-    super();
-  }
-  serialize() {
-    return clean({
-      type: this.type,
-      label: this.label,
-      description: this.description,
-      component: this.component?.serialize(),
-    });
-  }
-}
-
-export abstract class Modal {
-  abstract title: string;
-  components: Array<Label | TextDisplay> = [];
-  abstract customId: string;
-  customIdParser = parseCustomId;
-  abstract run(interaction: unknown, data: ComponentData): unknown;
-  serialize() {
-    return {
-      title: this.title,
-      custom_id: this.customId,
-      components: this.components.map((entry) => entry.serialize()),
-    };
-  }
-}

package/src/internal/components.ts

@@ -1,31 +0,0 @@
-export {
-  BaseComponent,
-  BaseMessageInteractiveComponent,
-  BaseModalComponent,
-  clean,
-  colorToNumber,
-  parseCustomId,
-  type ComponentData,
-  type ComponentParserResult,
-  type ConditionalComponentOption,
-} from "./components.base.js";
-export {
-  AnySelectMenu,
-  Button,
-  ChannelSelectMenu,
-  Container,
-  File,
-  LinkButton,
-  MediaGallery,
-  MentionableSelectMenu,
-  RoleSelectMenu,
-  Row,
-  Section,
-  Separator,
-  StringSelectMenu,
-  TextDisplay,
-  Thumbnail,
-  UserSelectMenu,
-} from "./components.message.js";
-export { CheckboxGroup, Label, Modal, RadioGroup, TextInput } from "./components.modal.js";
-export { serializePayload, type MessagePayload, type MessagePayloadObject } from "./payload.js";

package/src/internal/discord.ts

@@ -1,11 +0,0 @@
-export * from "discord-api-types/v10";
-export * from "./api.js";
-export * from "./client.js";
-export * from "./commands.js";
-export * from "./components.js";
-export * from "./embeds.js";
-export * from "./interactions.js";
-export * from "./listeners.js";
-export * from "./payload.js";
-export * from "./rest.js";
-export * from "./structures.js";

package/src/internal/embeds.ts

@@ -1,35 +0,0 @@
-import type { APIEmbed } from "discord-api-types/v10";
-
-function clean<T extends Record<string, unknown>>(value: T): T {
-  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as T;
-}
-
-export class Embed {
-  title?: string;
-  description?: string;
-  url?: string;
-  timestamp?: string;
-  color?: number;
-  footer?: APIEmbed["footer"];
-  image?: string | APIEmbed["image"];
-  thumbnail?: string | APIEmbed["thumbnail"];
-  author?: APIEmbed["author"];
-  fields?: APIEmbed["fields"];
-  constructor(embed?: APIEmbed) {
-    Object.assign(this, embed);
-  }
-  serialize(): APIEmbed {
-    return clean({
-      title: this.title,
-      description: this.description,
-      url: this.url,
-      timestamp: this.timestamp,
-      color: this.color,
-      footer: this.footer,
-      image: typeof this.image === "string" ? { url: this.image } : this.image,
-      thumbnail: typeof this.thumbnail === "string" ? { url: this.thumbnail } : this.thumbnail,
-      author: this.author,
-      fields: this.fields,
-    }) as APIEmbed;
-  }
-}