first commit

discord-bot/.eslintrc.json

@@ -0,0 +1,49 @@
+{
+	"extends": "eslint:recommended",
+	"env": {
+		"node": true,
+		"es6": true
+	},
+	"parserOptions": {
+		"ecmaVersion": 2021
+	},
+	"rules": {
+		"arrow-spacing": ["warn", { "before": true, "after": true }],
+		"brace-style": ["error", "1tbs", { "allowSingleLine": true }],
+		"comma-dangle": ["error", "always-multiline"],
+		"comma-spacing": "error",
+		"comma-style": "error",
+		"curly": ["error", "multi-line", "consistent"],
+		"dot-location": ["error", "property"],
+		"handle-callback-err": "off",
+		"indent": ["error", 2],
+		"keyword-spacing": "error",
+		"max-nested-callbacks": ["error", { "max": 4 }],
+		"max-statements-per-line": ["error", { "max": 2 }],
+		"no-console": "off",
+		"no-empty-function": "error",
+		"no-floating-decimal": "error",
+		"no-inline-comments": "error",
+		"no-lonely-if": "error",
+		"no-multi-spaces": "error",
+		"no-multiple-empty-lines": ["error", { "max": 2, "maxEOF": 1, "maxBOF": 0 }],
+		"no-shadow": ["error", { "allow": ["err", "resolve", "reject"] }],
+		"no-trailing-spaces": ["error"],
+		"no-var": "error",
+		"object-curly-spacing": ["error", "always"],
+		"prefer-const": "error",
+		"quotes": ["error", "single"],
+		"semi": ["error", "always"],
+		"space-before-blocks": "error",
+		"space-before-function-paren": ["error", {
+			"anonymous": "never",
+			"named": "never",
+			"asyncArrow": "always"
+		}],
+		"space-in-parens": "error",
+		"space-infix-ops": "error",
+		"space-unary-ops": "error",
+		"spaced-comment": "error",
+		"yoda": "error"
+	}
+}

discord-bot/.gitignore

@@ -0,0 +1,2 @@
+.env
+node_modules

discord-bot/commands/clear.js

@@ -0,0 +1,24 @@
+const { SlashCommandBuilder, PermissionFlagsBits } = require('discord.js');
+
+module.exports = {
+  data: new SlashCommandBuilder()
+    .setName('clear')
+    .setDescription('Clear 1-100 messages')
+    .setDefaultMemberPermissions(PermissionFlagsBits.Administrator)
+    .addNumberOption(option => option
+      .setName('amount')
+      .setDescription('The amount of messages to clear')
+      .setRequired(true)),
+
+  async execute({ interaction, createEmbed, client }) {
+    const amount = interaction.options.getNumber('amount');
+
+    if (amount < 1 || amount > 100) return await interaction.reply({ embeds: [createEmbed.basic('The amount must be between 1-100')] });
+
+    const channel = client.channels.cache.get(interaction.channelId);
+
+    channel.bulkDelete(amount);
+
+    await interaction.reply({ embeds: [createEmbed.basic(`Cleared **${amount}** messages`)], ephemeral: true });
+  },
+};

discord-bot/commands/music.js

@@ -0,0 +1,173 @@
+const { SlashCommandBuilder } = require('discord.js');
+const { QueryType } = require('discord-player');
+
+module.exports = {
+  data: new SlashCommandBuilder()
+    .setName('music')
+    .setDescription('Play and configure music')
+    .addSubcommand(subcommand => subcommand
+      .setName('play')
+      .setDescription('Play music')
+      .addStringOption(option => option
+        .setName('link-or-query')
+        .setDescription('The song or link you want to play')
+        .setRequired(true)))
+    .addSubcommand(subcommand => subcommand
+      .setName('skip')
+      .setDescription('Skip current song'))
+    .addSubcommand(subcommand => subcommand
+      .setName('stop')
+      .setDescription('Stop current queue'))
+    .addSubcommand(subcommand => subcommand
+      .setName('pause')
+      .setDescription('Pause the current song'))
+    .addSubcommand(subcommand => subcommand
+      .setName('shuffle')
+      .setDescription('Shuffle the queue'))
+    .addSubcommand(subcommand => subcommand
+      .setName('resume')
+      .setDescription('Resume the current song'))
+    .addSubcommand(subcommand => subcommand
+      .setName('filter')
+      .setDescription('Apply a filter')
+      .addStringOption(option => option
+        .setName('type')
+        .setDescription('Type of filter')
+        .setRequired(true)
+        .addChoices(
+          { name: 'Bassboost', value: 'bassboost_low' },
+          { name: 'Nightcore', value: 'nightcore' },
+        )))
+    .addSubcommand(subcommand => subcommand
+      .setName('volume')
+      .setDescription('Set volume')
+      .addNumberOption(option => option
+        .setName('percentage')
+        .setDescription('The percentage of the volume between 1 and 100')
+        .setRequired(true))),
+
+  async execute({ interaction, createEmbed, client }) {
+    if (!interaction.member.voice.channelId) return await interaction.reply({ embeds: [createEmbed.basic('You are not in a voice channel!')], ephemeral: true });
+    if (interaction.guild.members.me.voice.channelId && interaction.member.voice.channelId !== interaction.guild.members.me.voice.channelId) {
+      return await interaction.reply({ embeds: [createEmbed.basic('You are not in my voice channel!')], ephemeral: true });
+    }
+
+
+    if (interaction.options.getSubcommand() === 'play') {
+      const query = interaction.options.getString('link-or-query');
+
+      const queue = client.player.createQueue(interaction.guild, {
+        ytdlOptions: {
+          filter: 'audioonly',
+          highWaterMark: 1 << 30,
+          dlChunkSize: 0,
+        },
+        metadata: {
+          channel: interaction.channel,
+        },
+      });
+
+      // verify vc connection
+      try {
+        if (!queue.connection) await queue.connect(interaction.member.voice.channel);
+      } catch {
+        queue.destroy();
+        return await interaction.reply({ embeds: [createEmbed.basic('Could not join your voice channel!')], ephemeral: true });
+      }
+
+      await interaction.reply({ embeds: [createEmbed.basic('Searching...')], ephemeral: true });
+
+      const searchResult = await client.player.search(query, {
+        requestedBy: interaction.user,
+        searchEngine: QueryType.AUTO,
+      });
+      if (!searchResult || !searchResult.tracks[0]) return await interaction.editReply({ embeds: [createEmbed.basic(`Track or playlist **${query}** not found!`)], ephemeral: true });
+
+      searchResult.playlist ? queue.addTracks(searchResult.tracks) : queue.addTrack(searchResult.tracks[0]);
+      if (!queue.playing) await queue.play();
+
+      if (!searchResult.playlist) await interaction.editReply({ embeds: [createEmbed.basic(`Adding track **${searchResult.tracks[0].title}**`)], ephemeral: false });
+      else await interaction.editReply({ embeds: [createEmbed.basic(`Adding **${searchResult.playlist.tracks.length}** tracks from playlist **${searchResult.playlist.title}**`)], ephemeral: false });
+
+    } else if (interaction.options.getSubcommand() === 'skip') {
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      const currentTrack = queue.nowPlaying();
+      const success = queue.skip();
+
+      await interaction.reply({ embeds: [createEmbed.basic(success ? `Skipped **${currentTrack.title}**` : 'Something went wrong')] });
+    } else if (interaction.options.getSubcommand() === 'volume') {
+      const vol = interaction.options.getNumber('percentage');
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      if (vol < 1 || vol > 100) return interaction.reply({ embeds: [createEmbed.basic('Volume must be between 1 and 100')] });
+
+      const success = queue.setVolume(vol);
+
+      await interaction.reply({ embeds: [createEmbed.basic(success ? `Volume set to **${vol}%**` : 'Something went wrong')] });
+    } else if (interaction.options.getSubcommand() === 'stop') {
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      queue.destroy();
+
+      await interaction.reply({ embeds: [createEmbed.basic('Stopped the player')] });
+    } else if (interaction.options.getSubcommand() === 'pause') {
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      queue.setPaused(true);
+
+      await interaction.reply({ embeds: [createEmbed.basic('Paused the player')] });
+    } else if (interaction.options.getSubcommand() === 'resume') {
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      queue.setPaused(false);
+
+      await interaction.reply({ embeds: [createEmbed.basic('Resumed the player')] });
+    } else if (interaction.options.getSubcommand() === 'filter') {
+      const filter = interaction.options.getString('type');
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      if (filter === 'bassboost_low') {
+        await queue.setFilters({
+          bassboost_low: !queue.getFiltersEnabled().includes('bassboost_low'),
+          normalizer2: !queue.getFiltersEnabled().includes('bassboost_low'),
+        });
+      }
+
+      if (filter === 'nightcore') {
+        await queue.setFilters({
+          nightcore: !queue.getFiltersEnabled().includes('nightcore'),
+        });
+      }
+
+      await interaction.reply({ embeds: [createEmbed.basic(queue.getFiltersEnabled().includes(filter) ? `Applied **${filter}** filter` : `Removed **${filter}** filter`)] });
+    } else if (interaction.options.getSubcommand() === 'shuffle') {
+
+      const queue = client.player.getQueue(interaction.guild);
+
+      if (!queue || !queue.playing) return await interaction.reply({ embeds: [createEmbed.basic('No music is being played')] });
+
+      const success = queue.shuffle();
+
+      await interaction.reply({ embeds: [createEmbed.basic(success ? 'The queue has been shuffled' : 'Something went wrong')] });
+    }
+  },
+};

discord-bot/commands/ping.js

@@ -0,0 +1,12 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+  data: new SlashCommandBuilder()
+    .setName('ping')
+    .setDescription('Replies with Pong!'),
+
+  async execute({ interaction, createEmbed, client }) {
+    const reply = await interaction.reply({ embeds: [createEmbed.basic(`Websocket heartbeat: **${client.ws.ping}ms**\n Roundtrip latency: **Pinging...**`)], fetchReply: true, ephemeral: true });
+    interaction.editReply({ embeds: [createEmbed.basic(`Websocket heartbeat: **${client.ws.ping}ms**\n Roundtrip latency: **${reply.createdTimestamp - interaction.createdTimestamp}ms**`)], emphemeral: true });
+  },
+};

discord-bot/events/interactionCreate.js

@@ -0,0 +1,26 @@
+const { Events } = require('discord.js');
+
+module.exports = {
+  name: Events.InteractionCreate,
+  async execute({ log, createEmbed, client }, interaction) {
+
+    if (interaction.isChatInputCommand()) {
+      const command = interaction.client.commands.get(interaction.commandName);
+
+      if (!command) {
+        return log.Error(`No command matching ${interaction.commandName} was found`);
+      } else {
+        log.Info(`${interaction.user.username} executed command ${interaction.commandName}`);
+      }
+
+      try {
+        await command.execute({ interaction, log, createEmbed, client });
+      } catch (error) {
+        log.Error(error);
+
+        await interaction.reply({ content: 'There was an error while executing this command!', ephemeral: true });
+      }
+    }
+  },
+
+};

discord-bot/events/ready.js

@@ -0,0 +1,11 @@
+const { Events } = require('discord.js');
+
+module.exports = {
+  name: Events.ClientReady,
+  once: true,
+  execute({ client, log }) {
+    log.Info(`Ready! Logged in as ${client.user.tag}`);
+
+    require('../functions/registerCommands.js').registerCommands(log);
+  },
+};

discord-bot/functions/createEmbed.js

@@ -0,0 +1,12 @@
+const { EmbedBuilder } = require('discord.js');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const basic = (description) => {
+  return new EmbedBuilder()
+    .setColor(process.env.EMBED_COLOR)
+    .setDescription(description);
+};
+
+module.exports = { basic };

discord-bot/functions/player.js

@@ -0,0 +1,31 @@
+const { EmbedBuilder } = require('discord.js');
+
+const registerEvents = ({ createEmbed, client }) => {
+
+  client.player.on('trackStart', (queue, track) => {
+
+    const nowPlayingEmbed = new EmbedBuilder()
+      .setTitle('Now Playing')
+      .setColor(process.env.EMBED_COLOR)
+      .setDescription(`[${track.title}](${track.url})`)
+      .addFields(
+        { name: 'Requested By', value: `${track.requestedBy}`, inline: true },
+        { name: 'Duration', value: track.duration, inline: true },
+        { name: 'Queue', value: `${queue.tracks.length} song(s)`, inline: true },
+        { name: 'Author', value: track.author, inline: true },
+        { name: 'Source', value: track.source, inline: true },
+        { name: 'Volume', value: `${queue.options.initialVolume}%`, inline: true },
+        { name: 'Filters', value: queue.getFiltersEnabled().join('\n') || 'No filters active', inline: false },
+      )
+      .setThumbnail(track.thumbnail)
+      .setTimestamp();
+
+    queue.metadata.channel.send({ embeds: [nowPlayingEmbed] });
+  });
+
+  client.player.on('error', (queue, error) => {
+    console.log(error);
+  });
+};
+
+module.exports = { registerEvents };

discord-bot/functions/registerCommands.js

@@ -0,0 +1,48 @@
+const { REST, Routes } = require('discord.js');
+const fs = require('node:fs');
+const dotenv = require('dotenv');
+
+dotenv.config();
+
+const registerCommands = (log) => {
+  const commands = [];
+  // Grab all the command files from the commands directory you created earlier
+  const commandFiles = fs.readdirSync('./commands').filter(file => file.endsWith('.js'));
+
+  // Grab the SlashCommandBuilder#toJSON() output of each command's data for deployment
+  for (const file of commandFiles) {
+    const command = require(`../commands/${file}`);
+    commands.push(command.data.toJSON());
+  }
+
+  // Construct and prepare an instance of the REST module
+  const rest = new REST({ version: '10' }).setToken(process.env.DISCORD_TOKEN);
+
+  // and deploy your commands!
+  (async () => {
+    try {
+      log.Info(`Started refreshing ${commands.length} application (/) commands.`);
+
+      // The put method is used to fully refresh all commands in the guild with the current set
+      let data = null;
+      if (process.env.GUILD_ID !== 'production') {
+        data = await rest.put(
+          Routes.applicationGuildCommands(process.env.CLIENT_ID, process.env.GUILD_ID),
+          { body: commands },
+        );
+      } else {
+        data = await rest.put(
+          Routes.applicationGuildCommands(process.env.CLIENT_ID),
+          { body: commands },
+        );
+      }
+
+      log.Info(`Successfully reloaded ${data.length} application (/) commands.`);
+    } catch (error) {
+      // And of course, make sure you catch and log any errors!
+      log.Error(error);
+    }
+  })();
+};
+
+module.exports = { registerCommands };

discord-bot/index.js

@@ -0,0 +1,55 @@
+const chalk = require('chalk');
+const { Client, GatewayIntentBits, Collection } = require('discord.js');
+const { Player } = require('discord-player');
+const fs = require('node:fs');
+const path = require('node:path');
+const dotenv = require('dotenv');
+
+const createEmbed = require('./functions/createEmbed.js');
+dotenv.config();
+
+const log = {
+  Info: (message) => console.log(chalk.blue('INFO'), message),
+  Error: (message) => console.log(chalk.red('ERROR'), message),
+  Warn: (message) => console.log(chalk.hex('#FFA500'), message),
+};
+
+// Register client and music events
+const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates] });
+client.player = new Player(client);
+
+require('./functions/player.js').registerEvents({ client, createEmbed });
+
+// Command handling
+client.commands = new Collection();
+
+const commandsPath = path.join(__dirname, 'commands');
+const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));
+
+for (const file of commandFiles) {
+  const filePath = path.join(commandsPath, file);
+  const command = require(filePath);
+
+  if ('data' in command && 'execute' in command) {
+    client.commands.set(command.data.name, command);
+  } else {
+    log.Warn(`The command at ${filePath} is missing a required "data" or "execute" property.`);
+  }
+}
+
+
+// Event handling
+const eventsPath = path.join(__dirname, 'events');
+const eventFiles = fs.readdirSync(eventsPath).filter(file => file.endsWith('.js'));
+
+for (const file of eventFiles) {
+  const filePath = path.join(eventsPath, file);
+  const event = require(filePath);
+  if (event.once) {
+    client.once(event.name, (...args) => event.execute({ client, log, createEmbed }, ...args));
+  } else {
+    client.on(event.name, (...args) => event.execute({ client, log, createEmbed }, ...args));
+  }
+}
+
+client.login(process.env.DISCORD_TOKEN);

discord-bot/package.json

@@ -0,0 +1,23 @@
+{
+  "type": "commonjs",
+  "name": "discord-bot",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@discord-player/downloader": "^3.0.1",
+    "@discord-player/extractor": "^3.0.2",
+    "@discordjs/opus": "^0.8.0",
+    "chalk": "^4.1.2",
+    "discord-player": "^5.3.2",
+    "discord.js": "^14.7.1",
+    "distube": "^4.0.4",
+    "dotenv": "^16.0.3",
+    "eslint": "^8.29.0"
+  }
+}