Discord slash commands: how they work and how to add them to your bot

DISCORD_TOKEN=your-bot-token
CLIENT_ID=your-application-id
GUILD_ID=your-test-server-id

{
  "name": "slash-bot",
  "private": true,
  "scripts": {
    "deploy": "node --env-file=.env deploy-commands.js",
    "start": "node --env-file=.env index.js"
  },
  "dependencies": {
    "discord.js": "^14.27.0"
  }
}

npm install

const {
  SlashCommandBuilder,
  PermissionFlagsBits,
  InteractionContextType,
  ApplicationIntegrationType,
  MessageFlags,
} = require('discord.js');

// Kept in memory so the example runs on its own. Use a database in a real bot.
const teams = new Map();

module.exports = {
  data: new SlashCommandBuilder()
    .setName('team')
    .setDescription('Manage teams in this server')
    // Hidden from members who lack Manage Roles. Admins can change this per server.
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageRoles)
    // Server only: no DMs, no user installs.
    .setContexts(InteractionContextType.Guild)
    .setIntegrationTypes(ApplicationIntegrationType.GuildInstall)
    .addSubcommand((sub) =>
      sub
        .setName('create')
        .setDescription('Register a new team')
        .addStringOption((opt) =>
          opt.setName('name').setDescription('Team name').setRequired(true).setMaxLength(32),
        )
        .addStringOption((opt) =>
          opt
            .setName('region')
            .setDescription('Where the team plays')
            .setRequired(true)
            .addChoices(
              { name: 'North America', value: 'na' },
              { name: 'Europe', value: 'eu' },
              { name: 'Asia-Pacific', value: 'apac' },
            ),
        )
        .addUserOption((opt) =>
          opt.setName('captain').setDescription('Team captain (defaults to you)'),
        ),
    )
    .addSubcommand((sub) =>
      sub
        .setName('remove')
        .setDescription('Delete a team')
        .addStringOption((opt) =>
          opt
            .setName('name')
            .setDescription('Start typing a team name')
            .setRequired(true)
            .setAutocomplete(true),
        ),
    )
    .addSubcommand((sub) => sub.setName('list').setDescription('List all teams')),

  async autocomplete(interaction) {
    const typed = interaction.options.getFocused().toLowerCase();
    const matches = [...teams.keys()]
      .filter((name) => name.toLowerCase().includes(typed))
      .slice(0, 25); // Discord shows at most 25 suggestions
    await interaction.respond(matches.map((name) => ({ name, value: name })));
  },

  async execute(interaction) {
    const sub = interaction.options.getSubcommand();

    if (sub === 'create') {
      const name = interaction.options.getString('name', true);
      const region = interaction.options.getString('region', true);
      const captain = interaction.options.getUser('captain') ?? interaction.user;
      if (teams.has(name)) {
        return interaction.reply({ content: `${name} already exists.`, flags: MessageFlags.Ephemeral });
      }
      teams.set(name, { region, captainId: captain.id });
      return interaction.reply({
        content: `Created **${name}** (${region.toUpperCase()}), captain <@${captain.id}>.`,
        allowedMentions: { parse: [] }, // show the mention without pinging
      });
    }

    if (sub === 'remove') {
      const name = interaction.options.getString('name', true);
      // Autocomplete only suggests. Users can still type anything, so check it.
      if (!teams.delete(name)) {
        return interaction.reply({ content: `No team called ${name}.`, flags: MessageFlags.Ephemeral });
      }
      return interaction.reply({ content: `Removed ${name}.`, flags: MessageFlags.Ephemeral });
    }

    // sub === 'list'
    const lines = [...teams].map(([name, t]) => `- ${name} (${t.region.toUpperCase()})`);
    return interaction.reply({
      content: lines.length ? lines.join('\n') : 'No teams yet.',
      flags: MessageFlags.Ephemeral,
    });
  },
};

const { SlashCommandBuilder, MessageFlags } = require('discord.js');

module.exports = {
  data: new SlashCommandBuilder()
    .setName('npm')
    .setDescription('Look up the latest version of an npm package')
    .addStringOption((opt) =>
      opt
        .setName('package')
        .setDescription('Package name, for example discord.js')
        .setRequired(true)
        .setMaxLength(214),
    )
    .addBooleanOption((opt) =>
      opt.setName('private').setDescription('Only show the answer to me'),
    ),

  async execute(interaction) {
    const name = interaction.options.getString('package', true).trim().toLowerCase();
    const hidden = interaction.options.getBoolean('private') ?? false;

    // Acknowledge now. Discord shows "thinking..." and gives us 15 minutes.
    // Ephemeral or not is decided here and can't be changed by editReply.
    await interaction.deferReply(hidden ? { flags: MessageFlags.Ephemeral } : {});

    const url = `https://registry.npmjs.org/${name.replace('/', '%2F')}/latest`;
    const res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
    if (!res.ok) {
      return interaction.editReply(`Couldn't find a package called \`${name}\`.`);
    }
    const pkg = await res.json();
    return interaction.editReply(`**${pkg.name}** ${pkg.version}\n${pkg.description ?? ''}`);
  },
};

const fs = require('node:fs');
const path = require('node:path');
const { REST, Routes } = require('discord.js');

const { DISCORD_TOKEN, CLIENT_ID, GUILD_ID } = process.env;
const target = process.argv[2] ?? 'guild'; // guild | global | clear-guild | list

const commandsDir = path.join(__dirname, 'commands');
const commands = fs
  .readdirSync(commandsDir)
  .filter((file) => file.endsWith('.js'))
  .map((file) => require(path.join(commandsDir, file)).data.toJSON());

const rest = new REST().setToken(DISCORD_TOKEN);
const globalRoute = Routes.applicationCommands(CLIENT_ID);
const guildRoute = Routes.applicationGuildCommands(CLIENT_ID, GUILD_ID);

async function main() {
  // PUT replaces the whole list in that scope: commands you leave out are deleted.
  if (target === 'global') {
    const data = await rest.put(globalRoute, { body: commands });
    console.log(`Registered ${data.length} global commands.`);
  } else if (target === 'clear-guild') {
    await rest.put(guildRoute, { body: [] });
    console.log(`Removed all guild commands from ${GUILD_ID}.`);
  } else if (target === 'list') {
    const globalCommands = await rest.get(globalRoute);
    const guildCommands = await rest.get(guildRoute);
    console.log('Global:', globalCommands.map((c) => `/${c.name}`).join(', ') || '(none)');
    console.log(`Guild ${GUILD_ID}:`, guildCommands.map((c) => `/${c.name}`).join(', ') || '(none)');
  } else {
    const data = await rest.put(guildRoute, { body: commands });
    console.log(`Registered ${data.length} commands in guild ${GUILD_ID}.`);
  }
}

main().catch((err) => {
  console.error(err);
  process.exitCode = 1;
});

npm run deploy               # your test server: shows up at once
npm run deploy -- global     # every server the app is installed in
npm run deploy -- clear-guild
npm run deploy -- list       # what Discord has registered right now

const fs = require('node:fs');
const path = require('node:path');
const { Client, Collection, Events, GatewayIntentBits, MessageFlags } = require('discord.js');

// Slash commands need no privileged intents. Guilds is enough.
const client = new Client({ intents: [GatewayIntentBits.Guilds] });
client.commands = new Collection();

const commandsDir = path.join(__dirname, 'commands');
for (const file of fs.readdirSync(commandsDir).filter((f) => f.endsWith('.js'))) {
  const command = require(path.join(commandsDir, file));
  client.commands.set(command.data.name, command);
}

client.once(Events.ClientReady, (c) => console.log(`Logged in as ${c.user.tag}`));

client.on(Events.InteractionCreate, async (interaction) => {
  const command = client.commands.get(interaction.commandName);

  if (interaction.isAutocomplete()) {
    try {
      await command?.autocomplete?.(interaction);
    } catch (err) {
      console.error(err);
    }
    return;
  }

  if (!interaction.isChatInputCommand()) return;
  if (!command) {
    console.warn(`No handler for /${interaction.commandName}. Re-run the deploy script?`);
    return;
  }

  try {
    await command.execute(interaction);
  } catch (err) {
    console.error(err);
    const content = 'Something went wrong running that command.';
    try {
      if (interaction.replied) {
        await interaction.followUp({ content, flags: MessageFlags.Ephemeral });
      } else if (interaction.deferred) {
        await interaction.editReply({ content });
      } else {
        await interaction.reply({ content, flags: MessageFlags.Ephemeral });
      }
    } catch (replyErr) {
      console.error(replyErr); // for example, the 15-minute token already expired
    }
  }
});

client.login(process.env.DISCORD_TOKEN);

npm start

import os

import aiohttp
import discord
from discord import app_commands

teams: dict[str, str] = {}  # name -> region. Use a database in a real bot.


class Bot(discord.Client):
    def __init__(self) -> None:
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self) -> None:
        # Register only when asked: SYNC=guild (test server, instant) or SYNC=global.
        sync = os.environ.get("SYNC")
        if sync == "guild":
            guild = discord.Object(id=int(os.environ["GUILD_ID"]))
            self.tree.copy_global_to(guild=guild)
            await self.tree.sync(guild=guild)
        elif sync == "global":
            await self.tree.sync()


bot = Bot()

team = app_commands.Group(
    name="team",
    description="Manage teams in this server",
    default_permissions=discord.Permissions(manage_roles=True),
    allowed_contexts=app_commands.AppCommandContext(guild=True),
    allowed_installs=app_commands.AppInstallationType(guild=True),
)


@team.command(name="create", description="Register a new team")
@app_commands.describe(name="Team name", region="Where the team plays")
@app_commands.choices(region=[
    app_commands.Choice(name="North America", value="na"),
    app_commands.Choice(name="Europe", value="eu"),
    app_commands.Choice(name="Asia-Pacific", value="apac"),
])
async def team_create(
    interaction: discord.Interaction,
    name: app_commands.Range[str, 1, 32],
    region: app_commands.Choice[str],
) -> None:
    if name in teams:
        await interaction.response.send_message(f"{name} already exists.", ephemeral=True)
        return
    teams[name] = region.value
    await interaction.response.send_message(f"Created **{name}** ({region.name}).")


@team.command(name="remove", description="Delete a team")
@app_commands.describe(name="Start typing a team name")
async def team_remove(interaction: discord.Interaction, name: str) -> None:
    if teams.pop(name, None) is None:
        await interaction.response.send_message(f"No team called {name}.", ephemeral=True)
        return
    await interaction.response.send_message(f"Removed {name}.", ephemeral=True)


@team_remove.autocomplete("name")
async def team_name_autocomplete(
    interaction: discord.Interaction, current: str
) -> list[app_commands.Choice[str]]:
    matches = [n for n in teams if current.lower() in n.lower()]
    return [app_commands.Choice(name=n, value=n) for n in matches[:25]]


bot.tree.add_command(team)


@bot.tree.command(name="pypi", description="Look up the latest version of a PyPI package")
@app_commands.describe(package="Package name, for example discord.py", private="Only show the answer to me")
async def pypi(
    interaction: discord.Interaction,
    package: app_commands.Range[str, 1, 100],
    private: bool = False,
) -> None:
    # Acknowledge within 3 seconds; we can then edit the reply for up to 15 minutes.
    await interaction.response.defer(ephemeral=private, thinking=True)
    url = f"https://pypi.org/pypi/{package.strip()}/json"
    timeout = aiohttp.ClientTimeout(total=10)
    async with aiohttp.ClientSession(timeout=timeout) as session:
        async with session.get(url) as resp:
            if resp.status != 200:
                await interaction.edit_original_response(content=f"Couldn't find a package called `{package}`.")
                return
            info = (await resp.json())["info"]
    await interaction.edit_original_response(content=f"**{info['name']}** {info['version']}\n{info['summary'] or ''}")


if __name__ == "__main__":
    bot.run(os.environ["DISCORD_TOKEN"])

python3 -m venv .venv
.venv/bin/pip install -U discord.py
# first run, or after changing commands: register them in your test server
SYNC=guild GUILD_ID=your-test-server-id DISCORD_TOKEN=your-bot-token .venv/bin/python bot.py
# every other run
DISCORD_TOKEN=your-bot-token .venv/bin/python bot.py