652 lines
25 KiB
JavaScript
652 lines
25 KiB
JavaScript
import 'dotenv/config';
|
||
import dns from 'node:dns';
|
||
import dgram from 'node:dgram';
|
||
// IPv6 sortant cassé sur ce serveur. Force IPv4 partout :
|
||
// - DNS lookup order
|
||
// - dgram sockets (Discord voice UDP) — patch createSocket pour forcer udp4
|
||
dns.setDefaultResultOrder('ipv4first');
|
||
const _origCreateSocket = dgram.createSocket;
|
||
dgram.createSocket = function(opts, cb) {
|
||
if (typeof opts === 'string') {
|
||
if (opts === 'udp6') opts = 'udp4';
|
||
} else if (opts && typeof opts === 'object') {
|
||
if (opts.type === 'udp6') opts = { ...opts, type: 'udp4' };
|
||
}
|
||
return _origCreateSocket.call(this, opts, cb);
|
||
};
|
||
import {
|
||
Client, GatewayIntentBits, Events, REST, Routes,
|
||
SlashCommandBuilder, EmbedBuilder, MessageFlags, ActivityType,
|
||
} from 'discord.js';
|
||
import {
|
||
joinVoiceChannel, createAudioPlayer, createAudioResource,
|
||
AudioPlayerStatus, VoiceConnectionStatus, NoSubscriberBehavior,
|
||
StreamType, entersState, getVoiceConnection,
|
||
} from '@discordjs/voice';
|
||
import { spawn } from 'node:child_process';
|
||
|
||
const TOKEN = process.env.DISCORD_TOKEN;
|
||
if (!TOKEN) { console.error('DISCORD_TOKEN manquant dans .env'); process.exit(1); }
|
||
|
||
const ALONE_TIMEOUT_MS = 180_000;
|
||
const YTDLP = process.env.YTDLP_BIN || '/home/yass/.local/bin/yt-dlp';
|
||
|
||
const C = {
|
||
PRIMARY: 0x5865F2, SUCCESS: 0x57F287, ERROR: 0xED4245,
|
||
WARNING: 0xFEE75C, MUSIC: 0x9B59B6, INFO: 0x00B0F4,
|
||
};
|
||
|
||
const log = (lvl, ...m) =>
|
||
console.log(`[${new Date().toISOString().replace('T',' ').slice(0,19)}] ${lvl.padEnd(8)} musicbot:`, ...m);
|
||
const info = (...m) => log('INFO', ...m);
|
||
const warn = (...m) => log('WARNING', ...m);
|
||
const err = (...m) => log('ERROR', ...m);
|
||
|
||
const fmt = (sec) => {
|
||
if (!sec) return 'Live';
|
||
sec = Math.floor(sec);
|
||
const h = Math.floor(sec / 3600);
|
||
const m = Math.floor((sec % 3600) / 60);
|
||
const s = sec % 60;
|
||
return h ? `${h}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}`
|
||
: `${m}:${String(s).padStart(2,'0')}`;
|
||
};
|
||
|
||
const Loop = { OFF: 0, ONE: 1, QUEUE: 2 };
|
||
|
||
class Player {
|
||
constructor(guildId) {
|
||
this.guildId = guildId;
|
||
this.queue = [];
|
||
this.current = null;
|
||
this.connection = null;
|
||
this.audioPlayer = null;
|
||
this.volume = 0.5;
|
||
this.loop = Loop.OFF;
|
||
this.textChannel = null;
|
||
this.aloneSince = null;
|
||
this.skipFlag = false;
|
||
this.currentResource = null;
|
||
this.currentProc = null;
|
||
}
|
||
reset() {
|
||
this.queue = [];
|
||
this.current = null;
|
||
this.loop = Loop.OFF;
|
||
this.skipFlag = false;
|
||
this.aloneSince = null;
|
||
this._killProc();
|
||
}
|
||
_killProc() {
|
||
if (this.currentProc) {
|
||
try { this.currentProc.kill('SIGKILL'); } catch {}
|
||
this.currentProc = null;
|
||
}
|
||
}
|
||
}
|
||
|
||
const players = new Map();
|
||
const getPlayer = (gid) => {
|
||
let p = players.get(gid);
|
||
if (!p) { p = new Player(gid); players.set(gid, p); }
|
||
return p;
|
||
};
|
||
|
||
const trim = (s, n = 128) => {
|
||
s = String(s ?? '');
|
||
return s.length > n ? s.slice(0, n - 1) + '…' : s;
|
||
};
|
||
|
||
function setIdlePresence() {
|
||
client.user?.setPresence({
|
||
activities: [{ name: '/play', type: ActivityType.Listening }],
|
||
status: 'online',
|
||
});
|
||
}
|
||
|
||
function setPlayingPresence(track) {
|
||
if (!track) return setIdlePresence();
|
||
const now = Date.now();
|
||
const activity = {
|
||
name: trim(track.title || 'Musique'),
|
||
type: ActivityType.Listening,
|
||
details: trim(track.title || 'Musique'),
|
||
state: trim(`par ${track.uploader || 'Inconnu'}`),
|
||
};
|
||
// Timeline live façon Spotify (uniquement si on connaît la durée)
|
||
if (track.duration && track.duration > 0) {
|
||
activity.timestamps = { start: now, end: now + Math.floor(track.duration * 1000) };
|
||
} else {
|
||
// Live → compteur ascendant
|
||
activity.timestamps = { start: now };
|
||
}
|
||
if (track.webpage_url) activity.url = track.webpage_url;
|
||
if (track.thumbnail) {
|
||
activity.assets = {
|
||
large_image: track.thumbnail,
|
||
large_text: trim(track.title || 'Musique'),
|
||
small_text: 'Music Bot',
|
||
};
|
||
}
|
||
client.user?.setPresence({ activities: [activity], status: 'online' });
|
||
}
|
||
|
||
// ── yt-dlp helpers ───────────────────────────────────────────────────────────
|
||
function ytSearchInfo(query) {
|
||
return new Promise((resolve, reject) => {
|
||
const isUrl = /^https?:\/\//i.test(query);
|
||
const target = isUrl ? query : `ytsearch1:${query}`;
|
||
const args = [
|
||
'-J', '--no-playlist', '--no-warnings', '--quiet',
|
||
'--default-search', 'ytsearch',
|
||
'-f', 'bestaudio/best',
|
||
target,
|
||
];
|
||
const p = spawn(YTDLP, args, { stdio: ['ignore', 'pipe', 'pipe'] });
|
||
let out = '', errBuf = '';
|
||
p.stdout.on('data', (d) => out += d);
|
||
p.stderr.on('data', (d) => errBuf += d);
|
||
p.on('error', reject);
|
||
p.on('close', (code) => {
|
||
if (code !== 0) return reject(new Error(errBuf.trim() || `yt-dlp exit ${code}`));
|
||
try {
|
||
const j = JSON.parse(out);
|
||
const e = (j.entries && j.entries[0]) ? j.entries[0] : j;
|
||
resolve({
|
||
title: e.title ?? 'Titre inconnu',
|
||
url: e.url,
|
||
webpage_url: e.webpage_url ?? e.original_url ?? '',
|
||
duration: e.duration ?? null,
|
||
thumbnail: e.thumbnail ?? null,
|
||
uploader: e.uploader ?? e.channel ?? 'Inconnu',
|
||
});
|
||
} catch (e) { reject(e); }
|
||
});
|
||
});
|
||
}
|
||
|
||
function spawnAudioStream(track) {
|
||
const args = [
|
||
'-o', '-',
|
||
'-f', 'bestaudio/best',
|
||
'--no-playlist', '--no-warnings', '--quiet',
|
||
'--no-part',
|
||
track.webpage_url || track.url,
|
||
];
|
||
const p = spawn(YTDLP, args, { stdio: ['ignore', 'pipe', 'pipe'] });
|
||
p.stderr.on('data', (d) => warn('yt-dlp:', d.toString().trim()));
|
||
p.on('error', (e) => err('yt-dlp spawn:', e.message));
|
||
return p;
|
||
}
|
||
|
||
// ── Embeds ───────────────────────────────────────────────────────────────────
|
||
const footer = (e) => e.setFooter({ text: 'Music Bot' }).setTimestamp();
|
||
const mk = (title, desc, color = C.PRIMARY) => {
|
||
const e = new EmbedBuilder().setTitle(title).setColor(color);
|
||
if (desc) e.setDescription(desc);
|
||
return footer(e);
|
||
};
|
||
const nowPlayingEmbed = (t, queueLen, loop, vol) => {
|
||
const loopIcon = { [Loop.OFF]: '', [Loop.ONE]: ' • Loop one', [Loop.QUEUE]: ' • Loop queue' }[loop];
|
||
const e = new EmbedBuilder()
|
||
.setTitle(`Lecture en cours${loopIcon}`)
|
||
.setDescription(`**[${t.title}](${t.webpage_url || ''})**`)
|
||
.setColor(C.MUSIC)
|
||
.addFields(
|
||
{ name: 'Durée', value: fmt(t.duration), inline: true },
|
||
{ name: 'Artiste', value: String(t.uploader), inline: true },
|
||
{ name: 'Volume', value: `${Math.round(vol * 100)}%`, inline: true },
|
||
{ name: 'File', value: `${queueLen} titre(s)`, inline: true },
|
||
);
|
||
if (t.thumbnail) e.setImage(t.thumbnail);
|
||
return footer(e);
|
||
};
|
||
|
||
// ── Voice / playback ─────────────────────────────────────────────────────────
|
||
function sendVoiceStateLeave(guild) {
|
||
try {
|
||
guild.shard.send({
|
||
op: 4,
|
||
d: { guild_id: guild.id, channel_id: null, self_mute: false, self_deaf: false },
|
||
});
|
||
info(`VOICE_STATE_UPDATE leave envoyé → ${guild.name}`);
|
||
} catch (e) { warn('clear voice state:', e.message); }
|
||
}
|
||
|
||
async function ensureConnection(interaction) {
|
||
const member = interaction.member;
|
||
const ch = member?.voice?.channel;
|
||
if (!ch) throw new Error('Tu dois être dans un salon vocal.');
|
||
|
||
const p = getPlayer(interaction.guildId);
|
||
let conn = getVoiceConnection(interaction.guildId);
|
||
|
||
if (conn && conn.joinConfig.channelId !== ch.id) {
|
||
conn.destroy();
|
||
conn = null;
|
||
p.connection = null;
|
||
}
|
||
|
||
// Si Discord pense que le bot est déjà dans un salon vocal mais on n'a pas
|
||
// de connection active, c'est une session zombie — on envoie un leave et on attend.
|
||
const me = interaction.guild.members.me;
|
||
if (!conn && me?.voice?.channelId) {
|
||
info(`État vocal zombie détecté dans ${interaction.guild.name}, nettoyage…`);
|
||
sendVoiceStateLeave(interaction.guild);
|
||
await new Promise(r => setTimeout(r, 1000));
|
||
}
|
||
|
||
if (!conn) {
|
||
conn = joinVoiceChannel({
|
||
channelId: ch.id,
|
||
guildId: interaction.guildId,
|
||
adapterCreator: interaction.guild.voiceAdapterCreator,
|
||
selfDeaf: true,
|
||
selfMute: false,
|
||
});
|
||
|
||
conn.on('debug', (msg) => info('voice debug:', msg));
|
||
conn.on('stateChange', (oldS, newS) => {
|
||
const extra = newS.reason ? ` reason=${newS.reason}` : '';
|
||
const closeCode = newS.closeCode ?? oldS.closeCode;
|
||
const cc = closeCode ? ` close=${closeCode}` : '';
|
||
info(`voice state: ${oldS.status} → ${newS.status}${extra}${cc}`);
|
||
if (newS.networking) {
|
||
newS.networking.on('debug', (m) => info('net debug:', m));
|
||
newS.networking.on('error', (e) => err('net error:', e?.message || e));
|
||
newS.networking.on('close', (c) => err(`voice WS closed code=${c}`));
|
||
newS.networking.on('stateChange', (a, b) => info(`net state: ${a.code} → ${b.code}`));
|
||
}
|
||
if (newS.status === VoiceConnectionStatus.Disconnected) {
|
||
Promise.race([
|
||
entersState(conn, VoiceConnectionStatus.Signalling, 5_000),
|
||
entersState(conn, VoiceConnectionStatus.Connecting, 5_000),
|
||
]).catch(() => {
|
||
info(`Connexion vocale perdue (guild ${interaction.guildId})`);
|
||
try { conn.destroy(); } catch {}
|
||
const pp = getPlayer(interaction.guildId);
|
||
pp.connection = null;
|
||
pp._killProc();
|
||
});
|
||
}
|
||
});
|
||
conn.on('error', (e) => err('voice connection error:', e?.message || e));
|
||
|
||
try {
|
||
await entersState(conn, VoiceConnectionStatus.Ready, 30_000);
|
||
} catch (e) {
|
||
const finalState = conn.state.status;
|
||
try { conn.destroy(); } catch {}
|
||
// Cleanup zombie session côté Discord pour la prochaine tentative
|
||
sendVoiceStateLeave(interaction.guild);
|
||
throw new Error(`Connexion vocale échouée (état final: ${finalState}): ${e.message}`);
|
||
}
|
||
|
||
p.connection = conn;
|
||
}
|
||
|
||
if (!p.audioPlayer) {
|
||
p.audioPlayer = createAudioPlayer({
|
||
behaviors: { noSubscriber: NoSubscriberBehavior.Pause },
|
||
});
|
||
p.audioPlayer.on('error', (e) => err('audio player error:', e.message));
|
||
p.audioPlayer.on(AudioPlayerStatus.Idle, () => playNext(interaction.guildId));
|
||
conn.subscribe(p.audioPlayer);
|
||
} else {
|
||
conn.subscribe(p.audioPlayer);
|
||
}
|
||
|
||
return p;
|
||
}
|
||
|
||
function startTrack(p, track) {
|
||
p._killProc();
|
||
const proc = spawnAudioStream(track);
|
||
p.currentProc = proc;
|
||
const resource = createAudioResource(proc.stdout, {
|
||
inputType: StreamType.Arbitrary,
|
||
inlineVolume: true,
|
||
});
|
||
resource.volume?.setVolume(p.volume);
|
||
p.currentResource = resource;
|
||
p.audioPlayer.play(resource);
|
||
setPlayingPresence(track);
|
||
}
|
||
|
||
async function playNext(guildId) {
|
||
const p = getPlayer(guildId);
|
||
if (!p.connection || !p.audioPlayer) { p.current = null; return; }
|
||
|
||
const skip = p.skipFlag;
|
||
p.skipFlag = false;
|
||
|
||
if (!skip && p.loop === Loop.ONE && p.current) {
|
||
try { startTrack(p, p.current); return; }
|
||
catch (e) { err('Loop ONE:', e.message); }
|
||
}
|
||
if (!skip && p.loop === Loop.QUEUE && p.current) {
|
||
p.queue.push(p.current);
|
||
}
|
||
|
||
if (p.queue.length === 0) {
|
||
p.current = null;
|
||
setIdlePresence();
|
||
if (p.textChannel) {
|
||
try { await p.textChannel.send({ embeds: [mk('File terminée', 'Utilisez `/play` pour ajouter des musiques.', C.INFO)] }); } catch {}
|
||
}
|
||
return;
|
||
}
|
||
|
||
p.current = p.queue.shift();
|
||
try {
|
||
startTrack(p, p.current);
|
||
if (p.textChannel) {
|
||
await p.textChannel.send({ embeds: [nowPlayingEmbed(p.current, p.queue.length, p.loop, p.volume)] });
|
||
}
|
||
} catch (e) {
|
||
err('startTrack:', e.message);
|
||
setTimeout(() => playNext(guildId), 500);
|
||
}
|
||
}
|
||
|
||
// ── Bot ──────────────────────────────────────────────────────────────────────
|
||
const client = new Client({
|
||
intents: [
|
||
GatewayIntentBits.Guilds,
|
||
GatewayIntentBits.GuildVoiceStates,
|
||
GatewayIntentBits.GuildMessages,
|
||
],
|
||
});
|
||
|
||
const commands = [
|
||
new SlashCommandBuilder().setName('join').setDescription('Rejoint votre salon vocal'),
|
||
new SlashCommandBuilder().setName('play').setDescription('Joue une musique (nom ou URL YouTube)')
|
||
.addStringOption(o => o.setName('query').setDescription('Nom ou URL').setRequired(true)),
|
||
new SlashCommandBuilder().setName('playtop').setDescription('Ajoute une musique en tête de file')
|
||
.addStringOption(o => o.setName('query').setDescription('Nom ou URL').setRequired(true)),
|
||
new SlashCommandBuilder().setName('skip').setDescription('Passe à la musique suivante'),
|
||
new SlashCommandBuilder().setName('pause').setDescription('Met la lecture en pause'),
|
||
new SlashCommandBuilder().setName('resume').setDescription('Reprend la lecture'),
|
||
new SlashCommandBuilder().setName('stop').setDescription('Arrête la musique et vide la file'),
|
||
new SlashCommandBuilder().setName('leave').setDescription('Déconnecte le bot du salon vocal'),
|
||
new SlashCommandBuilder().setName('queue').setDescription('Affiche la file d\'attente'),
|
||
new SlashCommandBuilder().setName('nowplaying').setDescription('Affiche la musique en cours'),
|
||
new SlashCommandBuilder().setName('volume').setDescription('Règle le volume (0–100)')
|
||
.addIntegerOption(o => o.setName('niveau').setDescription('0 à 100').setRequired(true).setMinValue(0).setMaxValue(100)),
|
||
new SlashCommandBuilder().setName('clear').setDescription('Vide la file d\'attente'),
|
||
new SlashCommandBuilder().setName('remove').setDescription('Supprime un titre de la file par sa position')
|
||
.addIntegerOption(o => o.setName('position').setDescription('1 = premier').setRequired(true).setMinValue(1)),
|
||
new SlashCommandBuilder().setName('loop').setDescription('Gère la répétition')
|
||
.addStringOption(o => o.setName('mode').setDescription('off, one ou queue').setRequired(true)
|
||
.addChoices(
|
||
{ name: 'off — Pas de répétition', value: 'off' },
|
||
{ name: 'one — Répète le titre', value: 'one' },
|
||
{ name: 'queue — Répète la file', value: 'queue' },
|
||
)),
|
||
new SlashCommandBuilder().setName('shuffle').setDescription('Mélange la file d\'attente'),
|
||
].map(c => c.toJSON());
|
||
|
||
client.once(Events.ClientReady, async (c) => {
|
||
info(`Connecté: ${c.user.tag} | ${c.guilds.cache.size} serveur(s)`);
|
||
setIdlePresence();
|
||
|
||
// Nettoyage des sessions vocales zombie après redémarrage
|
||
for (const [, guild] of c.guilds.cache) {
|
||
const me = guild.members.me;
|
||
if (me?.voice?.channelId) {
|
||
info(`Nettoyage état vocal zombie → ${guild.name}`);
|
||
sendVoiceStateLeave(guild);
|
||
}
|
||
}
|
||
|
||
try {
|
||
const rest = new REST({ version: '10' }).setToken(TOKEN);
|
||
const data = await rest.put(Routes.applicationCommands(c.user.id), { body: commands });
|
||
info(`${data.length} commande(s) synchronisée(s)`);
|
||
} catch (e) { err('Sync slash:', e.message); }
|
||
});
|
||
|
||
client.on(Events.VoiceStateUpdate, (oldS, newS) => {
|
||
const guild = newS.guild ?? oldS.guild;
|
||
const conn = getVoiceConnection(guild.id);
|
||
if (!conn) return;
|
||
const p = getPlayer(guild.id);
|
||
|
||
// Bot kick/leave
|
||
if (newS.id === client.user.id && oldS.channelId && !newS.channelId) {
|
||
info(`Bot déconnecté vocal → ${guild.name}`);
|
||
p.reset();
|
||
p.connection = null;
|
||
p.audioPlayer?.stop(true);
|
||
p.audioPlayer = null;
|
||
setIdlePresence();
|
||
return;
|
||
}
|
||
|
||
const channelId = conn.joinConfig.channelId;
|
||
const channel = guild.channels.cache.get(channelId);
|
||
if (!channel) return;
|
||
const humans = channel.members.filter(m => !m.user.bot).size;
|
||
if (humans === 0) {
|
||
if (!p.aloneSince) { p.aloneSince = Date.now(); info(`Seul dans ${channel.name} (${guild.name}), timer démarré`); }
|
||
} else if (p.aloneSince) {
|
||
p.aloneSince = null;
|
||
}
|
||
});
|
||
|
||
setInterval(() => {
|
||
for (const [gid, p] of players) {
|
||
if (!p.aloneSince) continue;
|
||
const conn = getVoiceConnection(gid);
|
||
if (!conn) { p.aloneSince = null; continue; }
|
||
if (Date.now() - p.aloneSince >= ALONE_TIMEOUT_MS) {
|
||
const guild = client.guilds.cache.get(gid);
|
||
info(`Auto-disconnect ${guild?.name ?? gid} (seul depuis ${Math.round((Date.now()-p.aloneSince)/1000)}s)`);
|
||
const ch = p.textChannel;
|
||
p.reset();
|
||
try { conn.destroy(); } catch {}
|
||
p.connection = null;
|
||
p.audioPlayer?.stop(true);
|
||
p.audioPlayer = null;
|
||
setIdlePresence();
|
||
if (ch) ch.send({ embeds: [mk('Déconnexion automatique',
|
||
`Seul dans le salon depuis **${Math.round(ALONE_TIMEOUT_MS/60000)} min**, je me déconnecte.`, C.INFO)] }).catch(() => {});
|
||
}
|
||
}
|
||
}, 30_000);
|
||
|
||
// ── Slash handlers ───────────────────────────────────────────────────────────
|
||
async function withVoice(interaction, fn) {
|
||
if (!interaction.member?.voice?.channel) {
|
||
return interaction.reply({ embeds: [mk('Erreur', 'Rejoignez un salon vocal d\'abord !', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
}
|
||
await interaction.deferReply();
|
||
try {
|
||
const p = await ensureConnection(interaction);
|
||
p.textChannel = interaction.channel;
|
||
await fn(interaction, p);
|
||
} catch (e) {
|
||
err('cmd error:', e.message);
|
||
const payload = { embeds: [mk('Erreur', `\`\`\`${e.message}\`\`\``, C.ERROR)] };
|
||
if (interaction.deferred) await interaction.editReply(payload).catch(() => {});
|
||
else await interaction.reply({ ...payload, flags: MessageFlags.Ephemeral }).catch(() => {});
|
||
}
|
||
}
|
||
|
||
client.on(Events.InteractionCreate, async (i) => {
|
||
if (!i.isChatInputCommand()) return;
|
||
const name = i.commandName;
|
||
|
||
try {
|
||
if (name === 'join') {
|
||
return withVoice(i, async (i, p) => {
|
||
const ch = i.member.voice.channel;
|
||
await i.editReply({ embeds: [mk('Connecté', `Maintenant dans **${ch.name}** !`, C.SUCCESS)] });
|
||
});
|
||
}
|
||
|
||
if (name === 'play' || name === 'playtop') {
|
||
return withVoice(i, async (i, p) => {
|
||
const query = i.options.getString('query', true);
|
||
await i.editReply({ embeds: [mk('Recherche…', `**${query}**`, C.WARNING)] });
|
||
let track;
|
||
try { track = await ytSearchInfo(query); }
|
||
catch (e) {
|
||
return i.editReply({ embeds: [mk('Erreur', `Impossible de trouver ce titre.\n\`\`\`${e.message}\`\`\``, C.ERROR)] });
|
||
}
|
||
if (name === 'playtop') p.queue.unshift(track); else p.queue.push(track);
|
||
|
||
const e = mk(name === 'playtop' ? 'Ajouté en tête de file' : 'Ajouté à la file',
|
||
`**[${track.title}](${track.webpage_url})**`, C.SUCCESS)
|
||
.addFields(
|
||
{ name: 'Durée', value: fmt(track.duration), inline: true },
|
||
{ name: 'Artiste', value: String(track.uploader), inline: true },
|
||
{ name: 'Position', value: name === 'playtop' ? '#1' : `#${p.queue.length}`, inline: true },
|
||
);
|
||
if (track.thumbnail) e.setThumbnail(track.thumbnail);
|
||
await i.editReply({ embeds: [e] });
|
||
|
||
if (p.audioPlayer.state.status === AudioPlayerStatus.Idle) playNext(i.guildId);
|
||
});
|
||
}
|
||
|
||
if (name === 'skip') {
|
||
const p = getPlayer(i.guildId);
|
||
if (!p.audioPlayer || p.audioPlayer.state.status === AudioPlayerStatus.Idle) {
|
||
return i.reply({ embeds: [mk('Erreur', 'Aucune musique en cours.', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
}
|
||
const title = p.current?.title ?? '?';
|
||
p.skipFlag = true;
|
||
p.audioPlayer.stop(true);
|
||
return i.reply({ embeds: [mk('Skippé', `**${title}** passée.`, C.INFO)] });
|
||
}
|
||
|
||
if (name === 'pause') {
|
||
const p = getPlayer(i.guildId);
|
||
if (p.audioPlayer?.state.status === AudioPlayerStatus.Playing) {
|
||
p.audioPlayer.pause();
|
||
return i.reply({ embeds: [mk('Pause', 'Musique mise en pause.', C.WARNING)] });
|
||
}
|
||
return i.reply({ embeds: [mk('Erreur', 'Aucune musique en cours.', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
}
|
||
|
||
if (name === 'resume') {
|
||
const p = getPlayer(i.guildId);
|
||
if (p.audioPlayer?.state.status === AudioPlayerStatus.Paused) {
|
||
p.audioPlayer.unpause();
|
||
return i.reply({ embeds: [mk('Reprise', 'La musique a repris !', C.SUCCESS)] });
|
||
}
|
||
return i.reply({ embeds: [mk('Erreur', 'La musique n\'est pas en pause.', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
}
|
||
|
||
if (name === 'stop') {
|
||
const p = getPlayer(i.guildId);
|
||
const count = p.queue.length;
|
||
p.reset();
|
||
p.audioPlayer?.stop(true);
|
||
setIdlePresence();
|
||
return i.reply({ embeds: [mk('Stop', `Arrêté. **${count}** titre(s) supprimé(s) de la file.`, C.INFO)] });
|
||
}
|
||
|
||
if (name === 'leave') {
|
||
const conn = getVoiceConnection(i.guildId);
|
||
if (!conn) return i.reply({ embeds: [mk('Erreur', 'Je ne suis pas dans un salon vocal.', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
const p = getPlayer(i.guildId);
|
||
p.reset();
|
||
p.audioPlayer?.stop(true);
|
||
p.audioPlayer = null;
|
||
try { conn.destroy(); } catch {}
|
||
p.connection = null;
|
||
setIdlePresence();
|
||
return i.reply({ embeds: [mk('Déconnecté', 'À bientôt !', C.INFO)] });
|
||
}
|
||
|
||
if (name === 'queue') {
|
||
const p = getPlayer(i.guildId);
|
||
if (!p.current && p.queue.length === 0) {
|
||
return i.reply({ embeds: [mk('File vide', 'Utilisez `/play` pour ajouter des musiques !', C.INFO)] });
|
||
}
|
||
const loopLabel = { [Loop.OFF]: 'Off', [Loop.ONE]: 'Titre', [Loop.QUEUE]: 'File' }[p.loop];
|
||
const e = new EmbedBuilder().setTitle('File d\'attente').setColor(C.MUSIC).setTimestamp();
|
||
if (p.current) e.addFields({
|
||
name: 'En cours',
|
||
value: `**[${p.current.title}](${p.current.webpage_url})** — ${fmt(p.current.duration)}`,
|
||
inline: false,
|
||
});
|
||
if (p.queue.length) {
|
||
const lines = p.queue.slice(0, 10).map((s, i) => `\`${i+1}.\` **${s.title}** — ${fmt(s.duration)}`).join('\n');
|
||
const more = p.queue.length > 10 ? `\n*… et ${p.queue.length - 10} autre(s)*` : '';
|
||
e.addFields({ name: `Prochaines (${p.queue.length})`, value: lines + more, inline: false });
|
||
}
|
||
e.setFooter({ text: `Music Bot • Loop : ${loopLabel}` });
|
||
return i.reply({ embeds: [e] });
|
||
}
|
||
|
||
if (name === 'nowplaying') {
|
||
const p = getPlayer(i.guildId);
|
||
if (!p.current) return i.reply({ embeds: [mk('Erreur', 'Aucune musique en cours.', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
return i.reply({ embeds: [nowPlayingEmbed(p.current, p.queue.length, p.loop, p.volume)] });
|
||
}
|
||
|
||
if (name === 'volume') {
|
||
const niveau = i.options.getInteger('niveau', true);
|
||
const p = getPlayer(i.guildId);
|
||
p.volume = niveau / 100;
|
||
p.currentResource?.volume?.setVolume(p.volume);
|
||
const bar = '█'.repeat(Math.floor(niveau / 10)) + '░'.repeat(10 - Math.floor(niveau / 10));
|
||
return i.reply({ embeds: [mk('Volume', `**${niveau}%**\n${bar}`, C.SUCCESS)] });
|
||
}
|
||
|
||
if (name === 'clear') {
|
||
const p = getPlayer(i.guildId);
|
||
if (!p.queue.length) return i.reply({ embeds: [mk('Déjà vide', 'La file est déjà vide.', C.INFO)], flags: MessageFlags.Ephemeral });
|
||
const count = p.queue.length;
|
||
p.queue = [];
|
||
return i.reply({ embeds: [mk('Vidé', `**${count}** titre(s) supprimé(s).`, C.SUCCESS)] });
|
||
}
|
||
|
||
if (name === 'remove') {
|
||
const pos = i.options.getInteger('position', true);
|
||
const p = getPlayer(i.guildId);
|
||
if (pos < 1 || pos > p.queue.length) {
|
||
return i.reply({ embeds: [mk('Erreur', `Position invalide (1–${p.queue.length}).`, C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
}
|
||
const removed = p.queue.splice(pos - 1, 1)[0];
|
||
return i.reply({ embeds: [mk('Supprimé', `**${removed.title}** retiré de la file.`, C.INFO)] });
|
||
}
|
||
|
||
if (name === 'loop') {
|
||
const mode = i.options.getString('mode', true);
|
||
const p = getPlayer(i.guildId);
|
||
p.loop = { off: Loop.OFF, one: Loop.ONE, queue: Loop.QUEUE }[mode];
|
||
const labels = {
|
||
off: ['Répétition désactivée', C.INFO],
|
||
one: ['Répétition — titre en cours', C.SUCCESS],
|
||
queue: ['Répétition — file entière', C.SUCCESS],
|
||
};
|
||
const [t, col] = labels[mode];
|
||
return i.reply({ embeds: [mk(t, null, col)] });
|
||
}
|
||
|
||
if (name === 'shuffle') {
|
||
const p = getPlayer(i.guildId);
|
||
if (p.queue.length < 2) return i.reply({ embeds: [mk('Erreur', 'Pas assez de titres dans la file (minimum 2).', C.ERROR)], flags: MessageFlags.Ephemeral });
|
||
for (let k = p.queue.length - 1; k > 0; k--) {
|
||
const j = Math.floor(Math.random() * (k + 1));
|
||
[p.queue[k], p.queue[j]] = [p.queue[j], p.queue[k]];
|
||
}
|
||
return i.reply({ embeds: [mk('Mélangé', `**${p.queue.length}** titres mélangés.`, C.SUCCESS)] });
|
||
}
|
||
} catch (e) {
|
||
err(`Slash ${name}:`, e.message);
|
||
const payload = { embeds: [mk('Erreur inattendue', `\`\`\`${e.message}\`\`\``, C.ERROR)], flags: MessageFlags.Ephemeral };
|
||
if (i.deferred || i.replied) await i.followUp(payload).catch(() => {});
|
||
else await i.reply(payload).catch(() => {});
|
||
}
|
||
});
|
||
|
||
process.on('unhandledRejection', (r) => err('unhandledRejection:', r));
|
||
process.on('uncaughtException', (e) => err('uncaughtException:', e?.stack || e));
|
||
|
||
info('Démarrage du bot…');
|
||
client.login(TOKEN);
|