index.js

/**
 * @fileoverview Initializes the MooSaurus Discord bot client.
 * Loads commands and events, sets up DisTube with yt-dlp and cookies.txt,
 * and exports an async factory function to return the fully initialized client.
 *
 * @author DJ Stomp <85457381+DJStompZone@users.noreply.github.com>
 * @license MIT
 * @see {@link https://github.com/StompZone/MooSaurus}
 * @since 2025-08-06
 */

const { execFile } = require("child_process");
const { promisify } = require("util");
const execFileAsync = promisify(execFile);
const { Client, Collection, GatewayIntentBits, Partials, Colors, EmbedBuilder } = require("discord.js");
const { DisTube } = require("distube");
const { SoundCloudPlugin } = require("@distube/soundcloud");
const { YtDlpPlugin } = require("@distube/yt-dlp");
const path = require("path");
const fs = require("fs");
const { registerCustomFonts } = require("./src/utils/registerFonts");
const config = require("./config.js");
const sodium = require("libsodium-wrappers");
const Localization = require("./src/utils/localization");

/**
 * @function createClient
 * @name createClient
 * @async
 * @description
 * Sets up and initializes the MooSaurus Discord bot client.
 *
 * - Loads and prepares the Discord client with required intents and partials.
 * - Registers custom fonts for canvas-based rendering (e.g., music cards).
 * - Injects config, localization, and command handling.
 * - Loads all command files from `src/commands`.
 * - Loads all event files from `src/events` and attaches them to the client.
 * - Sets up the DisTube music system with YouTube cookies support via yt-dlp.
 * - Authenticates and logs in using the bot token in config.
 *
 * @returns {Promise<import("discord.js").Client>} Fully initialized and authenticated Discord.js client.
 *
 * @example
 * const createClient = require('./index');
 * (async () => {
 *   const client = await createClient();
 *   console.log(`Logged in as ${client.user.tag}`);
 * })();
 */
async function createClient() {
    await sodium.ready;
    registerCustomFonts();

    const client = new Client({
        intents: [
            GatewayIntentBits.Guilds,
            GatewayIntentBits.GuildVoiceStates,
            GatewayIntentBits.GuildMessages,
            GatewayIntentBits.MessageContent,
        ],
        partials: [Partials.Channel],
    });

    client.config = config;
    client.localization = new Localization(client);
    client.commands = new Collection();

    loadCommands(client);
    loadEvents(client);
    initDisTube(client);

    await client.login(client.config.token);
    console.log("🚀 Bot is online!");
    return client;
}

/**
 * @function loadCommands
 * @name loadCommands
 * @description
 * Loads all command modules from the `src/commands` directory and registers them to the client's command map.
 * Also registers any aliases listed in the config under `config.aliases`.
 *
 * @param {import("discord.js").Client} client - The Discord client instance.
 */
function loadCommands(client) {
    const commandsPath = path.join(__dirname, "src", "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 ("name" in command && "execute" in command) {
            client.commands.set(command.name, command);
            const aliases = client.config.aliases[command.name];
            if (aliases && Array.isArray(aliases)) {
                aliases.forEach(alias => client.commands.set(alias, command));
            }
        } else {
            console.warn(`⚠️ Command ${filePath} missing "name" or "execute"`);
        }
    }
}

/**
 * @function loadEvents
 * @name loadEvents
 * @description
 * Loads all event handlers from the `src/events` directory and attaches them to the client.
 * Supports both persistent and `once` events.
 *
 * @param {import("discord.js").Client} client - The Discord client instance.
 */
function loadEvents(client) {
    const eventsPath = path.join(__dirname, "src", "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(...args, client));
        } else {
            client.on(event.name, (...args) => event.execute(...args, client));
        }
    }
}


const { Readable } = require("stream");

class PatchedYtDlpPlugin extends YtDlpPlugin {
  async resolve(url, options) {
   // to preserve my sanity, fix later
    const ytDlpPath = "/home/moo9xi/MooSaurus/node_modules/@distube/yt-dlp/bin/yt-dlp";
    const cookiesPath = "/home/moo9xi/MooSaurus/cookies.txt";
    const args = [
      "--cookies", cookiesPath,
      "--no-playlist",
      "-f", "bestaudio",
      "-g", // Get the direct audio stream URL
      url
    ];

    const { stdout } = await execFileAsync(ytDlpPath, args);
    const streamURL = stdout.trim();

    const result = {
      stream: streamURL,
      name: `YouTube Stream (${url})`,
      isLive: false,
      type: "youtube",
      source: "youtube",
      url: url
    };
    console.log(result)
    return result;

/*
 try {
      const { stdout } = await execFileAsync(ytDlpPath, args);
      const streamURL = stdout.trim();

      // Just return the original URL, but inject metadata to patch the stream later
      return {
        url,
        metadata: { forceStreamURL: streamURL }
      };
    } catch (err) {
      console.error("❌ Failed to run yt-dlp manually:", err.stderr || err);
      throw new Error("Custom yt-dlp downloader failed");
    }
  }
}


// Its getting late and I am all out of fucks to give.
class PatchedYtDlpPlugin extends YtDlpPlugin {
  constructor(options = {}) {
    super(options)

    // Monkeypatch YouTubePlugin inside DisTube to support forceStreamURL
    this.name = "PatchedYtDlpPlugin"
  }

  patchYouTubePlugin(distube) {
    const youtubePlugin = distube.handler.plugins.find(
      (p) => p.constructor?.name === "YouTubePlugin"
    )

    if (!youtubePlugin || typeof youtubePlugin.getStreamURL !== "function") {
      console.warn("⚠️ Could not find YouTubePlugin to patch.")
      return
    }

    const original = youtubePlugin.getStreamURL.bind(youtubePlugin)
    youtubePlugin.getStreamURL = (song) => {
      if (song.metadata?.forceStreamURL) {
        return song.metadata.forceStreamURL
      }
      return original(song)
    }

    console.log("✅ Patched YouTubePlugin to support forceStreamURL")
  }

  /** @override */
  /*async resolve(url, options) {
    const result = await super.resolve(url, options)

    // Patch happens once on demand
    if (!this._patched && options?.manager?.distube) {
      this.patchYouTubePlugin(options.manager.distube)
      this._patched = true
    }

    // Inject the custom stream into metadata
    if (result && typeof result === "object" && result.stream) {
      return {
        url: url, // original URL so DisTube processes it normally
        metadata: {
          forceStreamURL: result.stream
        }
      }
    }

    return result // fuck it
  }
}
*/
}}


/**
 * @function initDisTube
 * @name initDisTube
 * @description
 * Initializes DisTube and configures its plugins, including yt-dlp with cookies.txt support.
 * Also sets up event listeners for "playSong" and "addSong" events to handle playback messaging.
 *
 * @param {import("discord.js").Client} client - The Discord client instance.
 */
function initDisTube(client) {
   client.distube = new DisTube(client, {
      emitNewSongOnly: true,
      emitAddSongWhenCreatingQueue: false,
      emitAddListWhenCreatingQueue: false,
      plugins: [
        new SoundCloudPlugin(),
        new PatchedYtDlpPlugin()
      ]
    });

    client.distube
        .on("playSong", async (queue, song) => {
            if (!queue.textChannel && song.metadata?.message?.channel) {
                queue.textChannel = song.metadata.message.channel;
            }

            if (client.config.enableLogging) {
                console.log(client.localization.get('events.playSong', {
                    song: song.name,
                    user: song.user.tag,
                }));
            }

            if (queue.currentMessage) {
                await queue.currentMessage.delete().catch(() => {});
                queue.currentMessage = undefined;
            }

            await require("./src/utils/sendMusicCard")(queue, song, client.localization);
        })
        .on("addSong", (queue, song) => {
            const embed = new EmbedBuilder()
                .setColor(Colors.Blue)
                .setDescription(client.localization.get('events.addSong', {
                    song: song.name,
                    duration: formatTime(song.duration),
                    user: song.user.tag,
                }));
            queue.textChannel?.send({ embeds: [embed] }).catch(() => {});
        });
}

/**
 * @function formatTime
 * @name formatTime
 * @description Converts seconds into "mm:ss" format for display in embeds or logs.
 *
 * @param {number} seconds - The number of seconds to format.
 * @returns {string} Formatted time string.
 */
function formatTime(seconds) {
    const mins = Math.floor(seconds / 60);
    const secs = Math.floor(seconds % 60).toString().padStart(2, '0');
    return `${mins}:${secs}`;
}

process.on("uncaughtException", err => console.error("Uncaught Exception:", err));
process.on("unhandledRejection", err => console.error("Unhandled Rejection:", err));

module.exports = createClient;

if (require.main === module) {
  createClient().catch(err => {
    console.error("❌ Failed to start MooSaurus:", err);
    process.exit(1);
  });
}