Bot de música para Discord: hazte el tuyo en Python o JavaScript

discord.py[voice]>=2.7
python-dotenv

DISCORD_TOKEN=pega-aquí-tu-token

import os
from pathlib import Path

import discord
from discord import app_commands
from dotenv import load_dotenv

load_dotenv()  # lee el token del fichero .env

CARPETA = Path("musica").resolve()  # tus canciones, subidas en «Archivos»
FORMATOS = {".mp3", ".ogg", ".opus", ".flac", ".wav", ".m4a"}

intents = discord.Intents.default()  # ya incluye los estados de voz
client = discord.Client(intents=intents)
tree = app_commands.CommandTree(client)
colas: dict[int, list[Path]] = {}  # una cola por servidor de Discord


def canciones():
    return sorted(p for p in CARPETA.iterdir() if p.suffix.lower() in FORMATOS)


def siguiente(vc: discord.VoiceClient, servidor: int):
    """Pone la primera de la cola; se vuelve a llamar sola al acabar cada canción."""
    cola = colas.get(servidor)
    if not cola or not vc.is_connected():
        return
    ruta = cola.pop(0)
    audio = discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(str(ruta)), volume=0.5)
    vc.play(audio, after=lambda error: siguiente(vc, servidor))


async def autocompletar(interaction: discord.Interaction, actual: str):
    return [
        app_commands.Choice(name=p.stem[:100], value=p.name)
        for p in canciones()
        if actual.lower() in p.stem.lower()
    ][:25]


@tree.command(name="pon", description="Pone una canción de la carpeta musica (o la añade a la cola)")
@app_commands.describe(cancion="Empieza a escribir y elige")
@app_commands.autocomplete(cancion=autocompletar)
@app_commands.guild_only()
async def pon(interaction: discord.Interaction, cancion: str):
    ruta = (CARPETA / cancion).resolve()
    if ruta.parent != CARPETA or not ruta.is_file():  # solo lo que hay en musica/
        await interaction.response.send_message("No encuentro esa canción.", ephemeral=True)
        return
    voz = interaction.user.voice
    if voz is None or voz.channel is None:
        await interaction.response.send_message("Entra antes en un canal de voz.", ephemeral=True)
        return
    await interaction.response.defer()  # conectar a la voz puede tardar más de 3 s
    vc = interaction.guild.voice_client
    if vc is None:
        vc = await voz.channel.connect()
    elif vc.channel != voz.channel:
        await vc.move_to(voz.channel)
    colas.setdefault(interaction.guild.id, []).append(ruta)
    if vc.is_playing():
        await interaction.followup.send(f"➕ En la cola: **{ruta.stem}**")
    else:
        siguiente(vc, interaction.guild.id)
        await interaction.followup.send(f"▶️ Suena: **{ruta.stem}**")


@tree.command(name="salta", description="Pasa a la siguiente canción de la cola")
@app_commands.guild_only()
async def salta(interaction: discord.Interaction):
    vc = interaction.guild.voice_client
    if vc and vc.is_playing():
        vc.stop()  # al pararla, siguiente() pone la que toca
    await interaction.response.send_message("⏭️ Siguiente")


@tree.command(name="para", description="Para la música, vacía la cola y sale del canal")
@app_commands.guild_only()
async def para(interaction: discord.Interaction):
    colas.pop(interaction.guild.id, None)
    vc = interaction.guild.voice_client
    if vc:
        await vc.disconnect()
    await interaction.response.send_message("⏹️ Música parada")


@tree.command(name="lista", description="Las canciones que hay en la carpeta musica")
async def lista(interaction: discord.Interaction):
    nombres = [p.stem for p in canciones()] or ["(la carpeta musica está vacía)"]
    await interaction.response.send_message("\n".join(nombres)[:2000], ephemeral=True)


@client.event
async def on_ready():
    await tree.sync()  # publica /pon, /salta, /para y /lista
    print(f"Conectado como {client.user}")


client.run(os.environ["DISCORD_TOKEN"])

{
  "name": "mi-bot-de-musica",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "@discordjs/opus": "^0.10.0",
    "@discordjs/voice": "^0.19.2",
    "discord.js": "^14.27.0",
    "dotenv": "^16.4.0"
  }
}

DISCORD_TOKEN=pega-aquí-tu-token

require("dotenv").config(); // lee el token del fichero .env
const fs = require("node:fs");
const path = require("node:path");
const { Client, Events, GatewayIntentBits, MessageFlags, SlashCommandBuilder, InteractionContextType } = require("discord.js");
const { AudioPlayerStatus, createAudioPlayer, createAudioResource, getVoiceConnection, joinVoiceChannel } = require("@discordjs/voice");

const CARPETA = path.resolve("musica"); // tus canciones, subidas en «Archivos»
const FORMATOS = [".mp3", ".ogg", ".opus", ".flac", ".wav", ".m4a"];

// Sin GuildVoiceStates el bot no sabe en qué canal de voz estás ni puede entrar
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates] });
const reproductores = new Map(); // un reproductor y una cola por servidor de Discord

const canciones = () => fs.readdirSync(CARPETA).filter((f) => FORMATOS.includes(path.extname(f).toLowerCase())).sort();

function reproductorDe(servidor) {
  if (!reproductores.has(servidor)) {
    const r = { player: createAudioPlayer(), cola: [] };
    // Al acabar una canción, la siguiente de la cola
    r.player.on(AudioPlayerStatus.Idle, () => siguiente(r));
    r.player.on("error", (e) => console.error("Error al reproducir:", e.message));
    reproductores.set(servidor, r);
  }
  return reproductores.get(servidor);
}

function siguiente(r) {
  const ruta = r.cola.shift();
  if (!ruta) return;
  const audio = createAudioResource(ruta, { inlineVolume: true });
  audio.volume.setVolume(0.5);
  r.player.play(audio);
}

const comandos = [
  new SlashCommandBuilder()
    .setName("pon")
    .setDescription("Pone una canción de la carpeta musica (o la añade a la cola)")
    .setContexts(InteractionContextType.Guild)
    .addStringOption((o) => o.setName("cancion").setDescription("Empieza a escribir y elige").setRequired(true).setAutocomplete(true)),
  new SlashCommandBuilder().setName("salta").setDescription("Pasa a la siguiente canción de la cola").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("para").setDescription("Para la música, vacía la cola y sale del canal").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("lista").setDescription("Las canciones que hay en la carpeta musica"),
];

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(comandos.map((x) => x.toJSON())); // publica /pon, /salta, /para y /lista
  console.log(`Conectado como ${c.user.tag}`);
});

client.on(Events.InteractionCreate, async (i) => {
  if (i.isAutocomplete()) {
    const escrito = i.options.getFocused().toLowerCase();
    const opciones = canciones()
      .filter((f) => f.toLowerCase().includes(escrito))
      .slice(0, 25)
      .map((f) => ({ name: path.parse(f).name.slice(0, 100), value: f }));
    return i.respond(opciones);
  }
  if (!i.isChatInputCommand()) return;

  if (i.commandName === "pon") {
    const ruta = path.resolve(CARPETA, i.options.getString("cancion"));
    if (path.dirname(ruta) !== CARPETA || !fs.existsSync(ruta)) {
      return i.reply({ content: "No encuentro esa canción.", flags: MessageFlags.Ephemeral }); // solo lo que hay en musica/
    }
    const canal = i.member.voice.channel;
    if (!canal) return i.reply({ content: "Entra antes en un canal de voz.", flags: MessageFlags.Ephemeral });
    // Entra en tu canal (o se cambia a él si ya estaba en otro)
    const conexion = joinVoiceChannel({ channelId: canal.id, guildId: i.guildId, adapterCreator: i.guild.voiceAdapterCreator });
    const r = reproductorDe(i.guildId);
    conexion.subscribe(r.player);
    r.cola.push(ruta);
    const nombre = path.parse(ruta).name;
    if (r.player.state.status === AudioPlayerStatus.Idle) {
      siguiente(r);
      return i.reply(`▶️ Suena: **${nombre}**`);
    }
    return i.reply(`➕ En la cola: **${nombre}**`);
  }

  if (i.commandName === "salta") {
    reproductores.get(i.guildId)?.player.stop(); // al pararla, pasa a Idle y suena la siguiente
    return i.reply("⏭️ Siguiente");
  }

  if (i.commandName === "para") {
    const r = reproductores.get(i.guildId);
    if (r) {
      r.cola = [];
      r.player.stop();
    }
    getVoiceConnection(i.guildId)?.destroy();
    return i.reply("⏹️ Música parada");
  }

  if (i.commandName === "lista") {
    const nombres = canciones().map((f) => path.parse(f).name);
    return i.reply({ content: (nombres.join("\n") || "(la carpeta musica está vacía)").slice(0, 2000), flags: MessageFlags.Ephemeral });
  }
});

client.login(process.env.DISCORD_TOKEN);