Currently, there is no way (that I know of) to access the underlying interaction on a slash command. This would be useful in order to perform actions not yet supported by gatekeeper (eg: #18), without losing gatekeeper's niceties like auto-syncing commands.

Maybe expose it as a something like readonly nativeInteraction: Interaction, to use the react convention for event handlers?

Currently, context.ephemeralReply returns void because:

This does not return a reply handle; ephemeral replies can't be updated or deleted manually
— interaction-context.ts:52

However, I did a little testing and it seems to update just like regular replies. Maybe there was an API update since then?

Here's my test code:

import assert from "assert";
import { Client, Intents } from "discord.js";
import { setTimeout } from "timers/promises";
import { GUILD_ID, TOKEN } from "../src/config";

console.clear();

const client = new Client({
  intents: [Intents.FLAGS.GUILD_VOICE_STATES, Intents.FLAGS.GUILDS],
});
client.login(TOKEN);

client.on("ready", async () => {
  const acm = client.application?.commands;
  assert(acm);

  const cmd = await acm.create(
    {
      type: "CHAT_INPUT",
      name: "edit-reply",
      description: "Editind ephemeral reply",
    },
    GUILD_ID!,
  );
});

client.on("interactionCreate", async (interaction) => {
  assert(interaction.isApplicationCommand());

  await interaction.deferReply({ ephemeral: true });

  await setTimeout(1_000);

  await interaction.editReply({
    embeds: [{ color: "RED", description: "First reply" }],
    // prettier-ignore
    components: [
      {type: "ACTION_ROW", components: [
        {type: "BUTTON", disabled: true, style: "PRIMARY", label: "Am I enabled?", customId: "btn"},
      ]},
    ],
  });

  await setTimeout(1_000);

  await interaction.editReply({
    embeds: [{ color: "AQUA", description: "Edited reply" }],
    // prettier-ignore
    components: [
      {type: "ACTION_ROW", components: [
        {type: "BUTTON", disabled: false, style: "PRIMARY", label: "I'm enabled!", customId: "btn"},
      ]},
    ],
  });
});

This argument would be passed in from the constructor:

// bot-context.ts
type BotContext = {
  message: string
}

// main.ts
await Gatekeeper.create<BotContext>({
  client,
  commandFolder: join(dirname(fileURLToPath(import.meta.url)), "commands"),
  context: { message: "hi" },
})

// commands/message.ts
export default function addCommands(
  gatekeeper: Gatekeeper,
  { message }: BotContext,
) {
  gatekeeper.addCommand({
    name: "message",
    description: "sends a message",
    async run(context) {
      context.reply(message)
    },
  })
}

This would allow passing values around through commands without having to use globals

A lot more flexible than just accepting a folder path.

Would probably be in the form of an option:

Gatekeeper.create({
	client,
	commandFiles: './**/*.command.ts',
})

The type should restrict defining onClick and url at the same time, via a union that accepts one or the other

At the moment, every time a command gets run, it registers a new listener in Discord.JS to listen for message component interaction events. Listeners get removed after 15 minutes, but this can still show the "10 max listeners exceeded" warning in Node.JS. Need to refactor the structure of things to handle all component interactions through one interaction event listener

Do bots even actually send these? ...eh, logging it anyhow. stickerComponent.

This can come in the form of a fileComponent, rendered once for each file to attach.

After a bot restarts, the messages it previously created become "inactive", and it can no longer respond to them. It'd be a cool feature to allow instances to persist, somehow. Might require accepting some storage adapter from the library user.

The allowed mention config for messages seems kind of weird as a component, as it doesn't show up in the actual message, but there's not really a better way to represent it, honestly. allowedMentionsComponent

Add onError callbacks to enable catching errors, for individual commands and globally on the gatekeeper instance

Add an aliases option for commands to register the same command for those extra names

I personally don't have a huge use case for this, but others might ¯\_(ツ)_/¯

I've had some requests to use JSX for rendering replies... maybe that can work? Can only try and see ¯\_(ツ)_/¯

https://discord.com/developers/docs/interactions/message-components#button-object-button-structure

This one should just be a passthrough ¯\_(ツ)_/¯

Instead of context.defer(), define defer: true in the command options. This makes sense because a command can only be deferred once

Not sure about event handlers 🤔 ideas:

• Another option deferComponents: true
• Pass an option object to the handler option, e.g. onClick: { defer: true, callback: () => {} }

Namely:

• User, which resolves to a DJS User
• Channel, which resolves to a DJS Channel
• Role, which resolves to a DJS Role
• Mentionable, which resolves to User | GuildMember | Role,
  or maybe something easier to resolve, like { type: 'user', user: User } | { type: 'guildMember', member: GuildMember } | ...