muthera 1.0.2

package/src/structures/mutheraPlayer.js

@@ -0,0 +1,524 @@
+const { EventEmitter } = require("events");
+const { Connection } = require("./mutheraConnection");
+const { Queue } = require("./mutheraQueue");
+const {
+  scAutoPlay,
+  spAutoPlay,
+  amAutoPlay,
+  dzAutoPlay,
+} = require("../functions/autoPlay");
+
+class Player extends EventEmitter {
+  constructor(muthera, node, options) {
+    super();
+    this.muthera = muthera;
+    this.node = node;
+    this.sessionId = node.sessionId;
+    this.options = options;
+    this.guildId = options.guildId;
+    this.textChannel = options.textChannel;
+    this.voiceChannel = options.voiceChannel;
+    this.connection = new Connection(this);
+    this.mute = options.mute ?? false;
+    this.deaf = options.deaf ?? false;
+    this.volume = options.volume ?? 100;
+    this.loop = options.loop ?? "none";
+    this.data = {};
+    this.queue = new Queue();
+    this.position = 0;
+    this.current = null;
+    this.previous = null;
+    this.playing = false;
+    this.paused = false;
+    this.connected = false;
+    this.timestamp = 0;
+    this.ping = 0;
+    this.isAutoplay = false;
+
+    this.on("playerUpdate", (packet) => {
+      (this.connected = packet.state.connected),
+        (this.position = packet.state.position),
+        (this.ping = packet.state.ping);
+      this.timestamp = packet.state.time;
+
+      this.muthera.emit("playerUpdate", this, packet);
+    });
+
+    this.on("event", (data) => {
+      this.handleEvent(data);
+    });
+  }
+
+  async play() {
+    if (!this.connected) throw new Error("Player are not initialize.");
+    if (!this.queue.length) return;
+
+    this.current = this.queue.shift();
+
+    if (!this.current.track) {
+      this.current = await this.current.resolve(this.muthera);
+    }
+
+    this.playing = true;
+    this.position = 0;
+
+    const { track } = this.current;
+
+    this.node.rest.updatePlayer({
+      guildId: this.guildId,
+      data: {
+        encodedTrack: track,
+      },
+    });
+
+    return this;
+  }
+
+  /**
+   *
+   * @param {this} player
+   * @returns
+   */
+  async autoplay(player) {
+    if (!player) {
+      if (player == null) {
+        this.isAutoplay = false;
+        return this;
+      } else if (player == false) {
+        this.isAutoplay = false;
+        return this;
+      } else throw new Error("No argument provided.");
+    }
+
+    this.isAutoplay = true;
+
+    if (player.previous) {
+      if (player.previous.info.sourceName === "youtube") {
+        try {
+          let data = `https://www.youtube.com/watch?v=${player.previous.info.identifier}&list=RD${player.previous.info.identifier}`;
+          let response = await this.muthera.resolve({
+            query: data,
+            source: "ytmsearch",
+            requester: player.previous.info.requester,
+          });
+
+          if (
+            !response ||
+            !response.tracks ||
+            ["error", "empty"].includes(response.loadType)
+          )
+            return this.stop();
+
+          let track =
+            response.tracks[
+              Math.floor(Math.random() * Math.floor(response.tracks.length))
+            ];
+
+          if (this.connected) {
+            this.queue.push(track);
+            await this.play();
+          } else {
+            return this.stop();
+          }
+
+          return this;
+        } catch (e) {
+          return this.stop();
+        }
+      } else if (player.previous.info.sourceName === "soundcloud") {
+        try {
+          scAutoPlay(player.previous.info.uri).then(async (data) => {
+            let response = await this.muthera.resolve({
+              query: data,
+              source: "scsearch",
+              requester: player.previous.info.requester,
+            });
+
+            if (
+              !response ||
+              !response.tracks ||
+              ["error", "empty"].includes(response.loadType)
+            )
+              return this.stop();
+
+            let track =
+              response.tracks[
+                Math.floor(Math.random() * Math.floor(response.tracks.length))
+              ];
+
+            if (this.connected) {
+              this.queue.push(track);
+              await this.play();
+            } else {
+              return this.stop();
+            }
+
+            return this;
+          });
+        } catch (e) {
+          console.log(e);
+          return this.stop();
+        }
+      } else if (player.previous.info.sourceName === "deezer") {
+        try {
+          const data = await dzAutoPlay(player.previous.info.identifier);
+          if (!data) return this.stop();
+
+          const response = await this.muthera.resolve({
+            query: data,
+            requester: player.previous.info.requester,
+          });
+
+          if (
+            !response ||
+            !response.tracks ||
+            ["error", "empty"].includes(response.loadType)
+          )
+            return this.stop();
+          
+          const track =
+            response.tracks[Math.floor(Math.random() * response.tracks.length)];
+
+          if (this.connected) {
+            this.queue.push(track);
+            await this.play();
+          } else {
+            return this.stop();
+          }
+          return this;
+        } catch (e) {
+          console.log(e);
+          return this.stop();
+        }
+      } else if (player.previous.info.sourceName === "applemusic") {
+        try {
+          const data = await amAutoPlay(player.previous.info.identifier);
+
+          const randomTrack = data[Math.floor(Math.random() * data.length)];
+
+          const trackUrl = randomTrack.trackViewUrl;
+
+          const response = await this.muthera.resolve({
+            query: trackUrl,
+            requester: player.previous.info.requester,
+          });
+
+          if (
+            !response ||
+            !response.tracks ||
+            ["error", "empty"].includes(response.loadType)
+          )
+            return this.stop();
+
+          const track =
+            response.tracks[Math.floor(Math.random() * response.tracks.length)];
+
+          if (this.connected) {
+            this.queue.push(track);
+            await this.play();
+          } else {
+            return this.stop();
+          }
+
+          return this;
+        } catch (e) {
+          console.log(e);
+          return this.stop();
+        }
+      } else if (player.previous.info.sourceName === "spotify") {
+        try {
+          // Use YouTube Music search as fallback for Spotify autoplay since Spotify API is blocked
+          const title = player.previous.info.title || '';
+          const artist = player.previous.info.author || '';
+          
+          // Create multiple search strategies for better results
+          const searchQueries = [
+            `${artist} similar songs`,
+            `${artist} music mix`,
+            `music like ${title}`,
+            `${artist} playlist`,
+            `${title} ${artist} radio`
+          ];
+          
+          // Try different search queries until we find tracks
+          let response = null;
+          for (const query of searchQueries) {
+            response = await this.muthera.resolve({
+              query: query,
+              source: "ytmsearch",
+              requester: player.previous.info.requester,
+            });
+            
+            if (response && response.tracks && response.tracks.length > 0 && 
+                !["error", "empty"].includes(response.loadType)) {
+              break;
+            }
+          }
+
+          if (
+            !response ||
+            !response.tracks ||
+            ["error", "empty"].includes(response.loadType) ||
+            response.tracks.length === 0
+          )
+            return this.stop();
+
+          // Filter out tracks that are too similar to the current one
+          let availableTracks = response.tracks.filter(track => 
+            track.info.title.toLowerCase() !== title.toLowerCase()
+          );
+          
+          // If no different tracks found, use all tracks but skip first one
+          if (availableTracks.length === 0) {
+            availableTracks = response.tracks.slice(1);
+            if (availableTracks.length === 0) availableTracks = response.tracks;
+          }
+
+          let track = availableTracks[Math.floor(Math.random() * availableTracks.length)];
+
+          if (this.connected) {
+            this.queue.push(track);
+            await this.play();
+          } else {
+            return this.stop();
+          }
+
+          return this;
+        } catch (e) {
+          console.log('Spotify autoplay error:', e);
+          return this.stop();
+        }
+      }
+    } else return this;
+  }
+
+  connect(options = this) {
+    const { guildId, voiceChannel, deaf = true, mute = false } = options;
+    this.send({
+      guild_id: guildId,
+      channel_id: voiceChannel,
+      self_deaf: deaf,
+      self_mute: mute,
+    });
+    this.connected = true;
+    this.muthera.emit(
+      "debug",
+      this.guildId,
+      "Player has been successfully connected."
+    );
+  }
+
+  stop() {
+    this.position = 0;
+    this.playing = false;
+    this.node.rest.updatePlayer({
+      guildId: this.guildId,
+      data: { encodedTrack: null },
+    });
+    return this;
+  }
+
+  pause(toggle = true) {
+    this.node.rest.updatePlayer({
+      guildId: this.guildId,
+      data: { paused: toggle },
+    });
+    this.playing = !toggle;
+    this.paused = toggle;
+    return this;
+  }
+
+  seek(position) {
+    const trackLength = this.current.info.length;
+    this.position = Math.max(0, Math.min(trackLength, position));
+    this.node.rest.updatePlayer({ guildId: this.guildId, data: { position } });
+  }
+
+  setVolume(volume) {
+    if (volume < 0 || volume > 100) {
+      throw new Error("Volume number must be between 0 to 100.");
+    }
+    this.node.rest.updatePlayer({ guildId: this.guildId, data: { volume } });
+    this.volume = volume;
+    return this;
+  }
+
+  setLoop(mode) {
+    if (!mode) {
+      throw new Error("You must provide an argument to set loop.");
+    }
+    if (!["none", "track", "queue"].includes(mode)) {
+      throw new Error("Set loop rguments must be 'none', 'track', or 'queue'");
+    }
+    this.loop = mode;
+    return this;
+  }
+
+  setTextChannel(channel) {
+    if (typeof channel !== "string")
+      throw new TypeError("Channel must be present and a non-empty string.");
+    this.textChannel = channel;
+    return this;
+  }
+
+  setVoiceChannel(channel, options) {
+    if (typeof channel !== "string")
+      throw new TypeError("Channel must be present and a non-empty string.");
+
+    if (this.connected && channel === this.voiceChannel) {
+      throw new ReferenceError(
+        `Player is already connected to channel: ${channel}.`
+      );
+    }
+    this.voiceChannel = channel;
+
+    if (options) {
+      this.mute = options.mute ?? this.mute;
+      this.deaf = options.deaf ?? this.deaf;
+    }
+
+    this.connect({
+      deaf: this.deaf,
+      guildId: this.guildId,
+      voiceChannel: this.voiceChannel,
+      textChannel: this.textChannel,
+      mute: this.mute,
+    });
+    return this;
+  }
+
+  disconnect() {
+    if (!this.voiceChannel) {
+      return;
+    }
+    this.connected = false;
+    this.send({
+      guild_id: this.guildId,
+      channel_id: null,
+      self_mute: false,
+      self_deaf: false,
+    });
+    this.muthera.emit("queueEnd", this);
+    return this;
+  }
+
+  destroy() {
+    if (!this.voiceChannel) {
+      return;
+    }
+    this.connected = false;
+    this.send({
+      guild_id: this.guildId,
+      channel_id: null,
+      self_mute: false,
+      self_deaf: false,
+    });
+    this.node.rest.destroyPlayer(this.guildId);
+    this.muthera.emit("playerDisconnect", this);
+    this.muthera.emit(
+      "debug",
+      this.guildId,
+      "Destroyed the player and clear the queue."
+    );
+    this.muthera.players.delete(this.guildId);
+  }
+
+  async handleEvent(payload) {
+    const player = this.muthera.players.get(payload.guildId);
+    if (!player) return;
+    const track = this.current;
+    track.info.thumbnail = await track.info.thumbnail;
+
+    switch (payload.type) {
+      case "TrackStartEvent":
+        this.trackStart(player, track, payload);
+        break;
+      case "TrackEndEvent":
+        this.trackEnd(player, track, payload);
+        break;
+      case "TrackExceptionEvent":
+        this.trackError(player, track, payload);
+        break;
+      case "TrackStuckEvent":
+        this.trackStuck(player, track, payload);
+        break;
+      case "WebSocketClosedEvent":
+        this.socketClosed(player, payload);
+        break;
+      default:
+        const error = new Error(
+          `Node encountered an unknown event: '${payload.type}'`
+        );
+        this.muthera.emit("nodeError", this, error);
+        break;
+    }
+  }
+
+  trackStart(player, track, payload) {
+    this.playing = true;
+    this.paused = false;
+    this.muthera.emit("trackStart", player, track, payload);
+  }
+
+  trackEnd(player, track, payload) {
+    this.previous = track;
+    if (this.loop === "track") {
+      player.queue.unshift(this.previous);
+      this.muthera.emit("trackEnd", player, track, payload);
+      return player.play();
+    } else if (track && this.loop === "queue") {
+      player.queue.push(this.previous);
+      this.muthera.emit("trackEnd", player, track, payload);
+      return player.play();
+    }
+
+    if (player.queue.length === 0) {
+      this.playing = false;
+      return this.muthera.emit("queueEnd", player);
+    } else if (player.queue.length > 0) {
+      this.muthera.emit("trackEnd", player, track, payload);
+      return player.play();
+    }
+    this.playing = false;
+    this.muthera.emit("queueEnd", player);
+  }
+
+  trackError(player, track, payload) {
+    this.muthera.emit("trackError", player, track, payload);
+    this.stop();
+  }
+
+  trackStuck(player, track, payload) {
+    this.muthera.emit("trackStuck", player, track, payload);
+    this.stop();
+  }
+
+  socketClosed(player, payload) {
+    if ([4015, 4009].includes(payload.code)) {
+      this.send({
+        guild_id: payload.guildId,
+        channel_id: this.voiceChannel,
+        self_mute: this.mute,
+        self_deaf: this.deaf,
+      });
+    }
+
+    this.muthera.emit("socketClosed", player, payload);
+    this.pause(true);
+    this.muthera.emit("debug", this.guildId, "An error has occured.");
+  }
+
+  set(key, value) {
+    return (this.data[key] = value);
+  }
+
+  get(key) {
+    return this.data[key];
+  }
+
+  send(data) {
+    this.muthera.send({ op: 4, d: data });
+  }
+}
+
+module.exports = { Player };

package/src/structures/mutheraQueue.js

@@ -0,0 +1,37 @@
+class Queue extends Array {
+  get size() {
+    return this.length;
+  }
+
+  get first() {
+    return this.length ? this[0] : null;
+  }
+
+  add(track) {
+    this.push(track);
+    return this;
+  }
+
+  remove(index) {
+    if (index >= 0 && index < this.length) {
+      return this.splice(index, 1)[0];
+    } else {
+      throw new Error(
+        "Index out of range. The number was too big or too small."
+      );
+    }
+  }
+
+  clear() {
+    this.length = 0;
+  }
+
+  shuffle() {
+    for (let i = this.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [this[i], this[j]] = [this[j], this[i]];
+    }
+  }
+}
+
+module.exports = { Queue };

package/src/structures/mutheraRest.js

@@ -0,0 +1,98 @@
+class Rest {
+    constructor(muthera, options) {
+        this.muthera = muthera;
+        this.url = `http${options.secure ? "s" : ""}://${options.host}:${options.port}`;
+        this.sessionId = options.sessionId;
+        this.password = options.password;
+        this.version = options.restVersion;
+        this.calls = 0;
+    }
+
+    setSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+
+    async makeRequest(method, endpoint, body = null) {
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: this.password,
+        };
+
+        const requestOptions = {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : null,
+        };
+
+        const response = await fetch(this.url + endpoint, requestOptions);
+
+        this.calls++
+
+        if (response.statusCode === 204) {
+            return null;
+        }
+
+        try {
+            const data = await response.json();
+            return data;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    async getPlayers() {
+        return this.makeRequest("GET", `/v4/sessions/${this.sessionId}/players`);
+    }
+
+    async updatePlayer(options) {
+        return this.makeRequest("PATCH", `/v4/sessions/${this.sessionId}/players/${options.guildId}?noReplace=false`, options.data).then((res) => {
+            this.muthera.emit("res", options.guildId, res);
+        })
+    }
+
+    async destroyPlayer(guildId) {
+        return this.makeRequest("DELETE", `/v4/sessions/${this.sessionId}/players/${guildId}`);
+    }
+
+    async getTracks(identifier) {
+        return this.makeRequest("GET", `/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`).then((res) => {
+            this.muthera.emit("res", identifier, res);
+        })
+    }
+
+    async decodeTrack(track, node) {
+        if (!node) node = this.leastUsedNodes[0];
+        return this.makeRequest(`GET`, `/v4/decodetrack?encodedTrack=${encodeURIComponent(track)}`);
+    }
+
+    async decodeTracks(tracks) {
+        return await this.makeRequest(`POST`, `/v4/decodetracks`, tracks);
+    }
+
+    async getStats() {
+        return this.makeRequest("GET", `/v4/stats`);
+    }
+
+    async getInfo() {
+        return this.makeRequest("GET", `/v4/info`);
+    }
+
+    async getRoutePlannerStatus() {
+        return await this.makeRequest(`GET`, `/v4/routeplanner/status`);
+    }
+    async getRoutePlannerAddress(address) {
+        return this.makeRequest(`POST`, `/v4/routeplanner/free/address`, { address });
+    }
+
+    async parseResponse(req) {
+        try {
+            this.muthera.emit("mutheraRaw", "Rest", await req.json());
+            return await req.json();
+        }
+        catch (e) {
+            return null;
+        }
+    }
+}
+
+module.exports = { Rest };