INTREACTION CREATE LISTENER RAHH

Author: Asynchronite

src/commands/misc/ping.ts

@@ -1,6 +1,5 @@
-/* import { SlashCommandBuilder, EmbedBuilder, ChatInputCommandInteraction } from "discord.js";
-import { KOGBot } from "index.ts"; 
-import { SlashCommand } from "main.d.ts"; 
+import { SlashCommandBuilder, EmbedBuilder, ChatInputCommandInteraction, Colors } from "discord.js";
+import { KOGBot } from "index.js"; 
 
 class PingCommand implements SlashCommand {
     name = 'ping';
@@ -15,31 +14,28 @@ class PingCommand implements SlashCommand {
     }
 
     async execute(interaction: ChatInputCommandInteraction): Promise<void> {
-        try {
-            const start = Date.now();
-            await interaction.reply('Pinging...');
-            const latency = Date.now() - start;
-
-            const embed = new EmbedBuilder()
-                .setColor("#9033FF")
-                .setTitle('Pong!')
-                .setDescription(`Returned Successfully\nBot Latency: ${latency}ms\nAPI Latency: ${interaction.client.ws.ping}ms`);
-
-            await interaction.followUp({ embeds: [embed] });
-        } catch (error) {
-            console.error("Error in executing ping command:", error);
-
-            const errorEmbed = new EmbedBuilder()
-                .setColor("#E73A3A")
-                .setTitle("Error")
-                .setDescription("An error occurred while executing the ping command.")
-                .setTimestamp();
-
-            await interaction.reply({ embeds: [errorEmbed], ephemeral: true });
-        }
+        const ping = Math.floor(interaction.client.ws.ping);
+
+        const message = await interaction.reply({
+            embeds: [
+                new EmbedBuilder()
+                    .setTitle("Pong!")
+                    .setDescription(`🏓**Client latency** \`${ping}\` ms\n🌐 **Round-trip** \`Calculating...\``)
+                    .setColor(Colors.Blue)
+            ]
+        });
+
+        const round = Math.floor(message.interaction.createdTimestamp - interaction.createdTimestamp);
+
+        await interaction.editReply({
+            embeds: [
+                new EmbedBuilder()
+                    .setTitle("Pong!")
+                    .setDescription(`🏓**Client latency**: \`${ping}\` ms\n🌐 **Round-trip**: \`${round}\` ms`)
+                    .setColor(Colors.Green)
+            ]
+        });
     }
 }
 
-export default PingCommand;
-
-*/
+export default PingCommand;

src/events/interactionCreate.ts

@@ -0,0 +1,40 @@
+import { Client, Interaction, Colors, EmbedBuilder } from "discord.js";
+import { KOGBot } from "index.js";
+
+export default class ReadyEvent implements GatewayEvent {
+    name: string = 'interactionCreate';
+    once: boolean = false;
+
+    async code (kogBot: KOGBot, interaction: Interaction) {
+        if (interaction.isChatInputCommand()) {
+            const receivedCommand = interaction.commandName;
+            const params = interaction.options;
+            
+            const commandObj = kogBot.discord_client.commands.list.find(cmd => cmd.instance.name === receivedCommand);
+
+            if (!commandObj) {
+                interaction.reply("Command not found bro");
+                return;
+            }
+
+            try {
+                await commandObj.instance.execute(interaction);
+            } catch (err) {
+                const replied = interaction.replied || interaction.deferred;
+                const replyData = {
+                    embeds: [
+                        new EmbedBuilder()
+                            .setTitle("Command Execution Error")
+                            .setDescription(`${err}`)
+                            .setColor(Colors.Red)
+                            .setFooter({
+                                text: `${interaction.guild?.name}`,
+                                iconURL: interaction.guild?.iconURL() as string
+                            })
+                            .setTimestamp()
+                    ]
+                };
+            }
+        }
+    }
+}

src/events/ready.ts

@@ -14,6 +14,8 @@ export default class ReadyEvent implements GatewayEvent {
                 name: debug ? 'debug mode ⚠️' : 'with Knex.',
                 type: debug ? ActivityType.Competing : ActivityType.Playing
             }]
-        })
+        });
+
+        console.log(`Logged in as ${client.user?.tag}!`);
     }
 }

src/index.ts

@@ -1,4 +1,4 @@
-import { Client, IntentsBitField, Message, REST } from "discord.js";
+import { Client, IntentsBitField, REST, SlashCommandBuilder, Routes, SlashCommandSubcommandBuilder } from "discord.js";
 import fs from 'fs';
 import knex, { Knex } from "knex";
 import toml from 'toml';
@@ -27,8 +27,11 @@ class DBot extends Client {
         this.REST.setToken(this.kogBot.environment.discord.client_token);
 
         if (!kogBot.ci_workflow) {
+            if (process.argv.includes('--deploy')) {
+                this.commands.deploy().then(() => console.log("Commands deployed."));
+            }
             this.gatewayEvents.listen().then(() => console.log("Listening to events."));
-            this.login(this.kogBot.environment.discord.client_token);
+            this.login(this.kogBot.environment.discord.client_token).then(() => console.log("Logged in, welcome!"));
         }
     }
 
@@ -73,6 +76,64 @@ class DBot extends Client {
             }
         }
     }
+
+    commands = {
+        list: [] as any[],
+
+        parse: async () => {
+            const folderPath = join(__dirname, 'commands');
+            const commandCategories = fs.readdirSync(folderPath);
+            const commands = [];
+
+            for (const category of commandCategories) {
+                const commandsPath = join(folderPath, category);
+                const commandFiles = readdirSync(commandsPath).filter(file => file.endsWith('.js'));
+
+                for (const file of commandFiles) {
+                    const filePath = join(commandsPath, file);
+                    const commandClass = (await import(`file://${filePath}`)).default;
+                    const command: SlashCommand = new commandClass(this.kogBot);
+                    const slashCommand = new SlashCommandBuilder();
+                    
+                    slashCommand.setName(command.name);
+                    slashCommand.setDescription(command.description);
+                    
+                    if (command.subcommands.length > 0) {
+                        for (const subcommand of command.subcommands) {
+                            const sub = new SlashCommandSubcommandBuilder()
+                                .setName(subcommand.name)
+                                .setDescription(subcommand.description);
+                            for (const parameter of command.parameters) {
+                                sub.options.push(parameter);
+                            }
+                            slashCommand.addSubcommand(sub);
+
+                        }
+                        
+                    }
+
+                    commands.push({
+                        builder: slashCommand,
+                        instance: command
+                    });
+                }
+            }
+            return commands;
+        },
+
+        deploy: async () => {
+            this.commands.list = await this.commands.parse();
+            if (process.argv.includes('--ci')) {
+                console.log("Not deploying commands because of CI environment. Commands successfully parsed!")
+                process.exit(0)
+            }
+            console.log(`Deploying ${this.commands.list.length} commands...`);
+            await this.REST.put(
+                Routes.applicationCommands(this.kogBot.environment.discord.client_id),
+                { body: this.commands.list.map(cmd => cmd.builder) }
+            );
+        }
+    }
 }
 
 class KOGBot_Client {