473 lines
17 KiB
JavaScript
473 lines
17 KiB
JavaScript
const { Client, GatewayIntentBits } = require('discord.js');
|
||
const {
|
||
joinVoiceChannel,
|
||
createAudioPlayer,
|
||
createAudioResource,
|
||
AudioPlayerStatus,
|
||
VoiceConnectionStatus,
|
||
entersState,
|
||
StreamType,
|
||
} = require('@discordjs/voice');
|
||
const { spawn } = require('child_process');
|
||
const { PassThrough } = require('stream');
|
||
const fs = require('fs');
|
||
const path = require('path');
|
||
const crypto = require('crypto');
|
||
|
||
// ─── Config ──────────────────────────────────────────────────────────────────
|
||
// SECURITY: never hardcode a bot token. This file previously had one baked in
|
||
// as a fallback — that token is now exposed and should be rotated in the
|
||
// Discord Developer Portal ASAP. Only read from the environment.
|
||
const TOKEN = process.env.DISCORD_TOKEN;
|
||
if (!TOKEN) {
|
||
console.error('❌ Missing DISCORD_TOKEN environment variable.');
|
||
process.exit(1);
|
||
}
|
||
const PREFIX = '!';
|
||
const VOLUME = 0.3; // 0.0 - 1.0
|
||
|
||
// ─── Cache setup ─────────────────────────────────────────────────────────────
|
||
const CACHE_DIR = path.join(__dirname, 'cache');
|
||
if (!fs.existsSync(CACHE_DIR)) fs.mkdirSync(CACHE_DIR);
|
||
|
||
// On startup, remove any leftover .tmp files from downloads that never
|
||
// finished (e.g. the process was killed mid-write). These are never valid
|
||
// cache entries, so there's no reason to keep them around.
|
||
for (const f of fs.readdirSync(CACHE_DIR)) {
|
||
if (f.endsWith('.tmp')) {
|
||
try { fs.unlinkSync(path.join(CACHE_DIR, f)); } catch {}
|
||
}
|
||
}
|
||
|
||
// Metadata cache: maps query/url → { title, duration, url }
|
||
const META_FILE = path.join(CACHE_DIR, 'metadata.json');
|
||
let metaCache = {};
|
||
if (fs.existsSync(META_FILE)) {
|
||
try { metaCache = JSON.parse(fs.readFileSync(META_FILE, 'utf8')); }
|
||
catch { metaCache = {}; }
|
||
}
|
||
|
||
function saveMetaCache() {
|
||
fs.writeFileSync(META_FILE, JSON.stringify(metaCache, null, 2));
|
||
}
|
||
|
||
function getAudioCachePath(url) {
|
||
const hash = crypto.createHash('md5').update(url).digest('hex');
|
||
return path.join(CACHE_DIR, `${hash}.opus`);
|
||
}
|
||
|
||
// ─── State (per guild) ────────────────────────────────────────────────────────
|
||
const guilds = new Map();
|
||
|
||
function getState(guildId) {
|
||
if (!guilds.has(guildId)) {
|
||
guilds.set(guildId, {
|
||
connection: null,
|
||
player: null,
|
||
queue: [],
|
||
playing: false,
|
||
textChannel: null,
|
||
});
|
||
}
|
||
return guilds.get(guildId);
|
||
}
|
||
|
||
// ─── Download manager ──────────────────────────────────────────────────────
|
||
// Downloads are tracked globally (not per-guild), keyed by URL. This means:
|
||
// - If guild A and guild B both request the same song at the same time,
|
||
// only ONE yt-dlp/ffmpeg pair is spawned; both playbacks tap into it.
|
||
// - If a listener disconnects (skip/leave/stop), the download itself is
|
||
// NOT killed — it keeps writing to disk and completes normally, so the
|
||
// cache is populated correctly for next time instead of ending up with
|
||
// a truncated file.
|
||
// - The cache file only ever appears at its final path once fully written
|
||
// (write to .tmp, then atomic rename on success).
|
||
const activeDownloads = new Map(); // url -> DownloadJob
|
||
|
||
class DownloadJob {
|
||
constructor(url) {
|
||
this.url = url;
|
||
this.cachePath = getAudioCachePath(url);
|
||
this.tmpPath = this.cachePath + '.tmp';
|
||
this.subscribers = new Set();
|
||
this.source = new PassThrough(); // fan-out: ffmpeg output -> all subscribers + cache file
|
||
this.failed = false;
|
||
this._start();
|
||
}
|
||
|
||
_start() {
|
||
const ytdlp = spawn('yt-dlp', [
|
||
'-f', 'bestaudio',
|
||
'--no-playlist',
|
||
'-o', '-',
|
||
'--', this.url,
|
||
], { stdio: ['ignore', 'pipe', 'pipe'] });
|
||
|
||
const ffmpeg = spawn('ffmpeg', [
|
||
'-hide_banner', '-loglevel', 'error',
|
||
'-i', 'pipe:0',
|
||
'-af', `volume=${VOLUME}`,
|
||
'-c:a', 'libopus',
|
||
'-b:a', '128k',
|
||
'-f', 'opus',
|
||
'pipe:1',
|
||
], { stdio: ['pipe', 'pipe', 'pipe'] });
|
||
|
||
this.ytdlp = ytdlp;
|
||
this.ffmpeg = ffmpeg;
|
||
|
||
ytdlp.stderr.on('data', (d) => console.error('[yt-dlp]', d.toString().trim()));
|
||
ffmpeg.stderr.on('data', (d) => console.error('[ffmpeg]', d.toString().trim()));
|
||
|
||
ytdlp.stdout.pipe(ffmpeg.stdin);
|
||
|
||
ytdlp.on('error', (err) => this._fail(err));
|
||
ffmpeg.on('error', (err) => this._fail(err));
|
||
|
||
ytdlp.on('exit', (code) => {
|
||
if (code !== 0 && code !== null) {
|
||
console.error(`[yt-dlp] exited with code ${code}`);
|
||
try { ffmpeg.stdin.destroy(); } catch {}
|
||
}
|
||
});
|
||
|
||
const cacheStream = fs.createWriteStream(this.tmpPath);
|
||
this.cacheStream = cacheStream;
|
||
|
||
ffmpeg.stdout.pipe(this.source);
|
||
this.source.pipe(cacheStream);
|
||
|
||
ffmpeg.on('close', (code) => {
|
||
if (code !== 0 && code !== null) {
|
||
this._fail(new Error(`ffmpeg exited with code ${code}`));
|
||
}
|
||
});
|
||
|
||
cacheStream.on('error', (err) => this._fail(err));
|
||
|
||
cacheStream.on('finish', () => {
|
||
if (this.failed) return; // already handled via _fail cleanup
|
||
fs.rename(this.tmpPath, this.cachePath, (err) => {
|
||
if (err) {
|
||
console.error('[Cache] Rename failed:', err.message);
|
||
} else {
|
||
console.log(`[Cache] Saved: ${path.basename(this.cachePath)}`);
|
||
}
|
||
activeDownloads.delete(this.url);
|
||
});
|
||
});
|
||
}
|
||
|
||
_fail(err) {
|
||
if (this.failed) return;
|
||
this.failed = true;
|
||
console.error(`[Download] Failed for ${this.url}:`, err.message);
|
||
try { this.ytdlp.kill(); } catch {}
|
||
try { this.ffmpeg.kill(); } catch {}
|
||
try { this.cacheStream.destroy(); } catch {}
|
||
fs.unlink(this.tmpPath, () => {}); // never leave a partial file behind
|
||
for (const sub of this.subscribers) sub.destroy(err);
|
||
activeDownloads.delete(this.url);
|
||
}
|
||
|
||
// Each consumer (a guild's playback) gets its own tap on the shared
|
||
// source. Closing this tap (e.g. because the guild skipped the track)
|
||
// only removes that listener — it does not affect the download itself.
|
||
subscribe() {
|
||
const sub = new PassThrough();
|
||
this.subscribers.add(sub);
|
||
this.source.pipe(sub);
|
||
const cleanup = () => this.subscribers.delete(sub);
|
||
sub.on('close', cleanup);
|
||
sub.on('end', cleanup);
|
||
return sub;
|
||
}
|
||
}
|
||
|
||
function getOrStartDownload(url) {
|
||
let job = activeDownloads.get(url);
|
||
if (!job) {
|
||
console.log(`[Download] Starting: ${url}`);
|
||
job = new DownloadJob(url);
|
||
activeDownloads.set(url, job);
|
||
} else {
|
||
console.log(`[Download] Joining in-progress download: ${url}`);
|
||
}
|
||
return job;
|
||
}
|
||
|
||
// ─── Discord client ───────────────────────────────────────────────────────────
|
||
const client = new Client({
|
||
intents: [
|
||
GatewayIntentBits.Guilds,
|
||
GatewayIntentBits.GuildVoiceStates,
|
||
GatewayIntentBits.GuildMessages,
|
||
GatewayIntentBits.MessageContent,
|
||
],
|
||
});
|
||
|
||
client.once('ready', () => {
|
||
console.log(`✅ Logged in as ${client.user.tag}`);
|
||
});
|
||
|
||
client.on('messageCreate', async (message) => {
|
||
if (message.author.bot) return;
|
||
if (!message.content.startsWith(PREFIX)) return;
|
||
|
||
const args = message.content.slice(PREFIX.length).trim().split(/ +/);
|
||
const command = args.shift().toLowerCase();
|
||
|
||
try {
|
||
if (command === 'play') {
|
||
const query = args.join(' ');
|
||
if (!query) return message.channel.send('❌ Podaj link lub frazę do wyszukania!');
|
||
await cmdPlay(message, query);
|
||
|
||
} else if (command === 'skip') {
|
||
await cmdSkip(message);
|
||
|
||
} else if (command === 'queue') {
|
||
await cmdQueue(message);
|
||
|
||
} else if (command === 'stop') {
|
||
await cmdStop(message);
|
||
|
||
} else if (command === 'leave') {
|
||
await cmdLeave(message);
|
||
|
||
} else if (command === 'help') {
|
||
await message.channel.send(
|
||
'🎵 **Komendy:**\n' +
|
||
'`!play <url/szukaj>` – dodaj utwór do kolejki\n' +
|
||
'`!skip` – pomiń aktualny utwór\n' +
|
||
'`!queue` – pokaż kolejkę\n' +
|
||
'`!stop` – zatrzymaj i wyczyść kolejkę\n' +
|
||
'`!leave` – rozłącz bota'
|
||
);
|
||
}
|
||
} catch (err) {
|
||
console.error(`[ERROR] command=${command}`, err);
|
||
message.channel.send(`⚠️ Błąd: ${err.message}`);
|
||
}
|
||
});
|
||
|
||
// ─── Commands ─────────────────────────────────────────────────────────────────
|
||
|
||
async function cmdPlay(message, query) {
|
||
const voiceChannel = message.member?.voice?.channel;
|
||
if (!voiceChannel) return message.channel.send('❌ Dołącz do kanału głosowego!');
|
||
|
||
const state = getState(message.guildId);
|
||
state.textChannel = message.channel;
|
||
|
||
if (!state.connection ||
|
||
state.connection.state.status === VoiceConnectionStatus.Destroyed ||
|
||
state.connection.state.status === VoiceConnectionStatus.Disconnected) {
|
||
|
||
console.log(`[Voice] Connecting to: ${voiceChannel.name}`);
|
||
|
||
state.connection = joinVoiceChannel({
|
||
channelId: voiceChannel.id,
|
||
guildId: message.guildId,
|
||
adapterCreator: message.guild.voiceAdapterCreator,
|
||
selfDeaf: true,
|
||
});
|
||
|
||
state.connection.on('stateChange', (o, n) => console.log(`[Voice] ${o.status} → ${n.status}`));
|
||
state.connection.on('error', (err) => console.error('[Voice error]', err.message));
|
||
|
||
try {
|
||
await entersState(state.connection, VoiceConnectionStatus.Ready, 30_000);
|
||
console.log('[Voice] Ready!');
|
||
} catch (err) {
|
||
console.error('[Voice] Connect failed:', err.message);
|
||
state.connection.destroy();
|
||
state.connection = null;
|
||
return message.channel.send('❌ Nie udało się połączyć z kanałem głosowym.');
|
||
}
|
||
}
|
||
|
||
if (!state.player) {
|
||
state.player = createAudioPlayer();
|
||
state.connection.subscribe(state.player);
|
||
|
||
state.player.on(AudioPlayerStatus.Idle, () => {
|
||
state.playing = false;
|
||
playNext(message.guildId);
|
||
});
|
||
|
||
state.player.on('error', (err) => {
|
||
console.error('[Player error]', err.message);
|
||
state.playing = false;
|
||
state.textChannel?.send(`⚠️ Błąd odtwarzacza: ${err.message}`);
|
||
playNext(message.guildId);
|
||
});
|
||
}
|
||
|
||
const cacheKey = query.toLowerCase().trim();
|
||
if (metaCache[cacheKey]) {
|
||
const song = metaCache[cacheKey];
|
||
const audioCached = fs.existsSync(getAudioCachePath(song.url));
|
||
console.log(`[Meta] HIT: "${query}" → ${song.url} (audio cached: ${audioCached})`);
|
||
state.queue.push(song);
|
||
await message.channel.send(
|
||
`✅ ${audioCached ? '⚡ Błyskawicznie z cache: ' : 'Dodano do kolejki: '}**${song.title}** [${song.duration}]`
|
||
);
|
||
if (!state.playing) playNext(message.guildId);
|
||
return;
|
||
}
|
||
|
||
await message.channel.send(`🔍 Szukam: **${query}**…`);
|
||
const song = await resolveSong(query);
|
||
|
||
metaCache[cacheKey] = song;
|
||
metaCache[song.url.toLowerCase()] = song;
|
||
saveMetaCache();
|
||
console.log(`[Meta] Cached: "${query}" → ${song.url}`);
|
||
|
||
state.queue.push(song);
|
||
await message.channel.send(`✅ Dodano do kolejki: **${song.title}** [${song.duration}]`);
|
||
|
||
if (!state.playing) playNext(message.guildId);
|
||
}
|
||
|
||
async function cmdSkip(message) {
|
||
const state = getState(message.guildId);
|
||
if (!state.playing || !state.player) {
|
||
return message.channel.send('❌ Nic nie jest teraz odtwarzane.');
|
||
}
|
||
state.player.stop();
|
||
await message.channel.send('⏭️ Pominięto utwór.');
|
||
}
|
||
|
||
async function cmdQueue(message) {
|
||
const state = getState(message.guildId);
|
||
if (state.queue.length === 0) {
|
||
return message.channel.send('📭 Kolejka jest pusta.');
|
||
}
|
||
const list = state.queue
|
||
.map((s, i) => `${i + 1}. **${s.title}** [${s.duration}]`)
|
||
.join('\n');
|
||
await message.channel.send(`📜 **Kolejka:**\n${list}`);
|
||
}
|
||
|
||
async function cmdStop(message) {
|
||
const state = getState(message.guildId);
|
||
state.queue = [];
|
||
state.player?.stop();
|
||
state.playing = false;
|
||
await message.channel.send('⏹️ Zatrzymano i wyczyszczono kolejkę.');
|
||
}
|
||
|
||
async function cmdLeave(message) {
|
||
const state = getState(message.guildId);
|
||
state.queue = [];
|
||
state.player?.stop();
|
||
state.playing = false;
|
||
state.connection?.destroy();
|
||
state.connection = null;
|
||
state.player = null;
|
||
await message.channel.send('👋 Rozłączono.');
|
||
}
|
||
|
||
// ─── Playback ─────────────────────────────────────────────────────────────────
|
||
|
||
function playNext(guildId) {
|
||
const state = getState(guildId);
|
||
if (state.queue.length === 0) {
|
||
state.playing = false;
|
||
state.textChannel?.send('📭 Kolejka zakończona.');
|
||
return;
|
||
}
|
||
|
||
const song = state.queue.shift();
|
||
state.playing = true;
|
||
state.textChannel?.send(`▶️ Odtwarzam: **${song.title}** [${song.duration}]`);
|
||
|
||
try {
|
||
const resource = buildAudioResource(song.url);
|
||
state.player.play(resource);
|
||
} catch (err) {
|
||
console.error('[playNext error]', err);
|
||
state.textChannel?.send(`⚠️ Nie można odtworzyć: ${err.message}`);
|
||
state.playing = false;
|
||
playNext(guildId);
|
||
}
|
||
}
|
||
|
||
// ─── Audio resource with caching ─────────────────────────────────────────────
|
||
|
||
function buildAudioResource(url) {
|
||
const cachePath = getAudioCachePath(url);
|
||
|
||
// Cache HIT — instant play from disk. Because writes are atomic
|
||
// (tmp file + rename), a file only exists here if it's complete.
|
||
if (fs.existsSync(cachePath)) {
|
||
console.log(`[Cache] HIT: ${path.basename(cachePath)}`);
|
||
return createAudioResource(fs.createReadStream(cachePath), {
|
||
inputType: StreamType.OggOpus,
|
||
});
|
||
}
|
||
|
||
// Cache MISS — join (or start) a shared download for this URL.
|
||
// Skipping/stopping playback later will NOT interrupt this download;
|
||
// it keeps running and completes the cache file in the background.
|
||
const job = getOrStartDownload(url);
|
||
const stream = job.subscribe();
|
||
|
||
return createAudioResource(stream, {
|
||
inputType: StreamType.OggOpus,
|
||
});
|
||
}
|
||
|
||
// ─── yt-dlp metadata fetch ────────────────────────────────────────────────────
|
||
|
||
// Dedupe concurrent identical metadata lookups too (e.g. two people paste
|
||
// the same fresh link in the same second) so we don't spawn yt-dlp twice.
|
||
const pendingMetadata = new Map(); // cacheKey/query -> Promise
|
||
|
||
function resolveSong(query) {
|
||
if (pendingMetadata.has(query)) {
|
||
return pendingMetadata.get(query);
|
||
}
|
||
|
||
const isUrl = query.startsWith('http://') || query.startsWith('https://');
|
||
const ytQuery = isUrl ? query : `ytsearch1:${query}`;
|
||
|
||
const promise = new Promise((resolve, reject) => {
|
||
const proc = spawn('yt-dlp', [
|
||
'--no-playlist',
|
||
'--print', '%(title)s|||%(duration_string)s|||%(webpage_url)s',
|
||
'--', ytQuery,
|
||
]);
|
||
|
||
let stdout = '';
|
||
let stderr = '';
|
||
proc.stdout.on('data', (d) => stdout += d.toString());
|
||
proc.stderr.on('data', (d) => stderr += d.toString());
|
||
|
||
proc.on('close', (code) => {
|
||
const line = stdout.split('\n').find(l => l.includes('|||')) || '';
|
||
const parts = line.split('|||');
|
||
if (parts.length >= 3) {
|
||
resolve({
|
||
title: parts[0].trim(),
|
||
duration: parts[1].trim(),
|
||
url: parts[2].trim(),
|
||
});
|
||
} else if (code !== 0) {
|
||
reject(new Error(stderr.trim() || `yt-dlp exited with code ${code}`));
|
||
} else {
|
||
resolve({ title: query, duration: '?:??', url: query });
|
||
}
|
||
});
|
||
}).finally(() => {
|
||
pendingMetadata.delete(query);
|
||
});
|
||
|
||
pendingMetadata.set(query, promise);
|
||
return promise;
|
||
}
|
||
|
||
// ─── Start ────────────────────────────────────────────────────────────────────
|
||
client.login(TOKEN); |