feat: Make it so commands only deploy to discord if the --deploy argv is passed in the process thread thing.

Author: Asynchronite

src/commands/misc/kill.ts

@@ -1,10 +1,33 @@
-import { EmbedBuilder, ChatInputCommandInteraction, SlashCommandBuilder, SlashCommandUserOption, SlashCommandSubcommandBuilder } from "discord.js";
+import { EmbedBuilder, ChatInputCommandInteraction, SlashCommandBuilder, SlashCommandUserOption, SlashCommandSubcommandBuilder, SlashCommandRoleOption } from "discord.js";
 import { KOGBot } from "../../index.js";
 
 class KillCommand implements SlashCommand {
     data = new SlashCommandBuilder()
-    .setName('kill')
-    .setDescription('Kill a user.')
+        .setName('kill')
+        .setDescription('Kills an entity')
+        .addSubcommand((subcommand: SlashCommandSubcommandBuilder) =>
+            subcommand
+                .setName('user')
+                .setDescription('The user to kill.')
+                .addUserOption((option: SlashCommandUserOption) =>
+                    option
+                        .setName('user')
+                        .setDescription('The user to kill.')
+                        .setRequired(true)
+                )
+            )
+    .addSubcommand((subcommand: SlashCommandSubcommandBuilder) =>
+        subcommand
+            .setName('role')
+            .setDescription('The role to kill.')
+            .addRoleOption((option: SlashCommandRoleOption) =>
+                option
+                    .setName('role')
+                    .setDescription('The role to kill.')
+                    .setRequired(true)
+            )
+        )
+
     dev = true;
     kogBot: KOGBot;
 
@@ -13,30 +36,8 @@ class KillCommand implements SlashCommand {
     }
 
     async execute(interaction: ChatInputCommandInteraction): Promise<void> {
-        try {
-            const user = interaction.options.getUser('user');
-            if (!user) {
-                interaction.reply("No user was mentioned. Please mention a user to kill.");
-                return;
-            }
-
-            const embed = new EmbedBuilder()
-                .setColor("#9033FF")
-                .setTitle('Killed')
-                .setDescription(`I have killed the stinky of <@${user.id}>`);
-
-            await interaction.reply({ embeds: [embed] });
-        } catch (error) {
-            console.error("Error in executing kill command:", error);
-
-            const errorEmbed = new EmbedBuilder()
-                .setColor("#E73A3A")
-                .setTitle("Error")
-                .setDescription("An error occurred while executing the kill command.")
-                .setTimestamp();
-
-            await interaction.reply({ embeds: [errorEmbed], ephemeral: true });
-        }
+        const subCommand = interaction.options.getSubcommand();
+        console.log(subCommand);
     }
 }
 

src/commands/misc/ping.ts

@@ -5,7 +5,6 @@ class PingCommand implements SlashCommand {
     data = new SlashCommandBuilder()
         .setName('ping')
         .setDescription('Check the bot\'s latency.');
-    dev = true; 
     kogBot: KOGBot;
 
     constructor(kogBot: KOGBot) {

src/events/interactionCreate.ts

@@ -7,11 +7,39 @@ export default class ReadyEvent implements GatewayEvent {
 
     async code (kogBot: KOGBot, interaction: Interaction): Promise<void> {
         if (interaction.isChatInputCommand()) {
-            let command: any;
-
-            console.log(kogBot.discord_client.commands.list);
-
-            command = kogBot.discord_client.commands.list.get(interaction.commandName);
+            if (!interaction.guild) {
+                if (interaction.replied || interaction.deferred) {
+                    await interaction.followUp({
+                        embeds: [
+                            new EmbedBuilder()
+                                .setTitle("Command Execution Error")
+                                .setDescription("Commands can only be executed inside guilds.")
+                                .setColor(Colors.Red)
+                                .setFooter({
+                                    text: `${interaction.user.username}`,
+                                    iconURL: interaction.user.avatarURL() as string
+                                })
+                                .setTimestamp()
+                        ]
+                    })
+                } else {
+                    await interaction.reply({
+                        embeds: [
+                            new EmbedBuilder()
+                            .setTitle("Command Execution Error")
+                            .setDescription("Commands can only be executed inside guilds.")
+                            .setColor(Colors.Red)
+                            .setFooter({
+                                text: `${interaction.user.username}`,
+                                iconURL: interaction.user.avatarURL() as string
+                            })
+                            .setTimestamp()
+                        ]
+                    })
+                }
+                return;
+            }
+            let command: SlashCommand = kogBot.discord_client.commands.list.get(interaction.commandName);
 
             if (!command) {
                 interaction.reply({
@@ -29,6 +57,21 @@ export default class ReadyEvent implements GatewayEvent {
                         ]
                 });
                 return;
+            } else if (command.dev && !kogBot.environment.discord.dev_ids.includes(interaction.user.id)) {
+                interaction.reply({
+                    embeds: [
+                        new EmbedBuilder()
+                            .setTitle("Command Execution Error")
+                            .setDescription(`Command \`${interaction.commandName}\` is a developer only command and cannot be executed by non-developers.`)
+                            .setColor(Colors.Red)
+                            .setFooter({
+                                text: `${interaction.guild?.name}`,
+                                iconURL: interaction.guild?.iconURL() as string
+                            })
+                            .setTimestamp()
+                    ]
+                });
+                return;
             }
 
             try {

src/index.ts

@@ -1,4 +1,4 @@
-import { Client, IntentsBitField, REST, SlashCommandBuilder, Routes, SlashCommandSubcommandBuilder, RESTPostAPIApplicationCommandsJSONBody, Collection } from "discord.js";
+import { Client, IntentsBitField, REST, Routes, RESTPostAPIApplicationCommandsJSONBody, Collection } from "discord.js";
 import fs from 'fs';
 import knex, { Knex } from "knex";
 import toml from 'toml';
@@ -111,11 +111,13 @@ class DBot extends Client {
                 console.log("Not deploying commands because of CI environment. Commands successfully parsed!")
                 process.exit(0)
             }
-            console.log(`Deploying ${this.commands.list.size} commands...`);
-            await this.REST.put(
-                Routes.applicationCommands(this.kogBot.environment.discord.client_id),
-                { body: JSONCommands }
-            );
+            if (process.argv.includes('--deploy')) {
+                console.log(`Publishing ${this.commands.list.size} commands to the Discord API...`);
+                await this.REST.put(
+                    Routes.applicationCommands(this.kogBot.environment.discord.client_id),
+                    { body: JSONCommands }
+                );
+            }
         }
     }
 }

src/types/main.d.ts

@@ -1,4 +1,4 @@
-import { ApplicationCommandOptionBase, ChatInputCommandInteraction, SlashCommandBuilder, SlashCommandSubcommandBuilder } from "discord.js";
+import { ApplicationCommandOptionBase, ChatInputCommandInteraction, SlashCommandBuilder, SlashCommandSubcommandBuilder, SlashCommandSubcommandsOnlyBuilder } from "discord.js";
 import { KOGBot } from "index.ts";
 
 global {
@@ -15,7 +15,7 @@ global {
     }
 
     declare interface SlashCommand {
-        data: SlashCommandBuilder;
+        data: SlashCommandBuilder | SlashCommandSubcommandsOnlyBuilder;
         dev?: boolean;
         kogBot: KOGBot;