muthera 1.0.5 → 1.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muthera",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "A simple Lavalink wrapper for Discord music bot. Forked from Niizuki.",
   "main": "src/index.js",
   "scripts": {

package/src/functions/autoPlay.js

@@ -64,42 +64,59 @@ async function amAutoPlay(track_id, retries = 3) {
 }
 
 async function spAutoPlay(track_id, retries = 3) {
-  async function fetchWithRetry(url, options, retries) {
-    for (let attempt = 0; attempt < retries; attempt++) {
+  async function fetchWithRetry(url, options = {}, retriesLeft = retries) {
+    for (let attempt = 0; attempt < retriesLeft; attempt++) {
       try {
         const res = await fetch(url, options);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
         return await res.json();
       } catch (error) {
-        if (attempt === retries - 1) {
-          throw new Error("No track found.");
-        }
+        if (attempt === retriesLeft - 1) throw new Error("No track found.");
+        await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
       }
     }
   }
+
   const tokenResponse = await fetchWithRetry(
-    "https://open.spotify.com/get_access_token?reason=transport&productType=embed",
-    {},
-    retries
+    "https://open.spotify.com/get_access_token?reason=transport&productType=embed"
   );
   const accessToken = tokenResponse.accessToken;
+  if (!accessToken) throw new Error("Failed to get Spotify token.");
 
-  const recommendationsResponse = await fetchWithRetry(
-    `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${track_id}`,
-    {
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json",
-      },
-    },
-    retries
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+  };
+
+  // Get the track to find its artist
+  const trackData = await fetchWithRetry(
+    `https://api.spotify.com/v1/tracks/${track_id}`,
+    { headers }
   );
+  const artistId = trackData?.artists?.[0]?.id;
+  if (!artistId) throw new Error("No artist found for track.");
 
-  return recommendationsResponse.tracks[
-    Math.floor(Math.random() * recommendationsResponse.tracks.length)
-  ].id;
+  // Get related artists
+  const relatedData = await fetchWithRetry(
+    `https://api.spotify.com/v1/artists/${artistId}/related-artists`,
+    { headers }
+  );
+  const relatedArtists = relatedData?.artists ?? [];
+  if (!relatedArtists.length) throw new Error("No related artists found.");
+
+  // Pick a random related artist and get their top tracks
+  const randomArtist = relatedArtists[Math.floor(Math.random() * relatedArtists.length)];
+  const topTracksData = await fetchWithRetry(
+    `https://api.spotify.com/v1/artists/${randomArtist.id}/top-tracks?market=US`,
+    { headers }
+  );
+  const tracks = topTracksData?.tracks ?? [];
+  if (!tracks.length) throw new Error("No top tracks found.");
+
+  return tracks[Math.floor(Math.random() * tracks.length)].id;
 }
 
-async function dzAutoPlay(trackId, retries = 3) {
+async function dzAutoPlay(trackId, title = null, artist = null, retries = 3) {
   async function fetchWithRetryJson(url, options = {}, retriesLeft = 3) {
     for (let attempt = 0; attempt < retriesLeft; attempt++) {
       try {
@@ -113,7 +130,23 @@ async function dzAutoPlay(trackId, retries = 3) {
     }
   }
 
-  const trackData = await fetchWithRetryJson(`https://api.deezer.com/track/${trackId}`, {}, retries);
+  let trackData = null;
+
+  if (trackId) {
+    try {
+      trackData = await fetchWithRetryJson(`https://api.deezer.com/track/${trackId}`, {}, retries);
+      if (trackData?.error) trackData = null;
+    } catch (_) {}
+  }
+
+  if (!trackData && title && artist) {
+    try {
+      const q = encodeURIComponent(`${title} ${artist}`);
+      const searchRes = await fetchWithRetryJson(`https://api.deezer.com/search?q=${q}&limit=1`, {}, retries);
+      if (searchRes?.data?.[0]) trackData = searchRes.data[0];
+    } catch (_) {}
+  }
+
   if (!trackData || trackData.error) throw new Error("Deezer track not found");
 
   const originalTrackId = String(trackData.id);

package/src/structures/Muthera.js

@@ -155,26 +155,28 @@ class Muthera extends EventEmitter {
         `/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`
       );
 
+      let tracks = [];
       if (response.loadType === "track") {
-        this.tracks = [new Track(response.data, requester, node)];
+        tracks = [new Track(response.data, requester, node)];
       } else if (response.loadType === "playlist") {
-        this.tracks = response.data.tracks.map(
+        tracks = response.data.tracks.map(
           (track) => new Track(track, requester, node)
         );
       } else if (
         response.loadType === "error" ||
         response.loadType === "empty"
       ) {
-        this.tracks = null;
+        tracks = [];
       } else {
-        this.tracks = response.data.map(
+        tracks = response.data?.map(
           (track) => new Track(track, requester, node)
-        );
+        ) ?? [];
       }
 
-      this.playlistInfo = response.data.info ?? null;
-      this.loadType = response.loadType ?? null;
-      return this;
+      const playlistInfo = response.data?.info ?? null;
+      const loadType = response.loadType ?? null;
+      
+      return { tracks, loadType, playlistInfo };
     } catch (error) {
       throw new Error(error);
     }

package/src/structures/mutheraPlayer.js

@@ -121,6 +121,37 @@ class Player extends EventEmitter {
             return this.stop();
           }
 
+          return this;
+        } catch (e) {
+          return this.stop();
+        }
+      } else if (player.previous.info.sourceName === "youtubemusic") {
+        try {
+          let data = `https://music.youtube.com/watch?v=${player.previous.info.identifier}&list=RD${player.previous.info.identifier}`;
+          let response = await this.muthera.resolve({
+            query: data,
+            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();
@@ -227,65 +258,70 @@ class Player extends EventEmitter {
         }
       } 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",
+          const artist = player.previous.info.author;
+          const title = player.previous.info.title;
+          const platform = this.muthera.defaultSearchPlatform;
+
+          if (platform.includes("dz")) {
+            // Use Deezer related-artist API for proper similar song recommendations
+            const data = await dzAutoPlay(null, title, artist);
+            if (!data) return this.stop();
+
+            const response = await this.muthera.resolve({
+              query: data,
               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;
-          }
+            if (
+              !response ||
+              !response.tracks ||
+              ["error", "empty"].includes(response.loadType) ||
+              response.tracks.length === 0
+            )
+              return this.stop();
 
-          let track = availableTracks[Math.floor(Math.random() * availableTracks.length)];
+            const track =
+              response.tracks[Math.floor(Math.random() * response.tracks.length)];
 
-          if (this.connected) {
-            this.queue.push(track);
-            await this.play();
+            if (this.connected) {
+              this.queue.push(track);
+              await this.play();
+            } else {
+              return this.stop();
+            }
+            return this;
           } else {
-            return this.stop();
-          }
+            // For YouTube and other platforms, search by artist and filter current song
+            const response = await this.muthera.resolve({
+              query: artist,
+              source: platform,
+              requester: player.previous.info.requester,
+            });
 
-          return this;
+            if (
+              !response ||
+              !response.tracks ||
+              ["error", "empty"].includes(response.loadType) ||
+              response.tracks.length === 0
+            )
+              return this.stop();
+
+            const filtered = response.tracks.filter(
+              (t) => t.info.title.toLowerCase() !== title.toLowerCase()
+            );
+            const pool = filtered.length > 0 ? filtered : response.tracks;
+            const track = pool[Math.floor(Math.random() * pool.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);
+          console.log(e);
           return this.stop();
         }
       }
@@ -483,14 +519,26 @@ class Player extends EventEmitter {
     this.muthera.emit("queueEnd", player);
   }
 
-  trackError(player, track, payload) {
+  async trackError(player, track, payload) {
     this.muthera.emit("trackError", player, track, payload);
-    this.stop();
+    this.playing = false;
+    this.previous = track;
+    if (player.queue.length > 0) {
+      await player.play();
+    } else {
+      this.muthera.emit("queueEnd", player);
+    }
   }
 
-  trackStuck(player, track, payload) {
+  async trackStuck(player, track, payload) {
     this.muthera.emit("trackStuck", player, track, payload);
-    this.stop();
+    this.playing = false;
+    this.previous = track;
+    if (player.queue.length > 0) {
+      await player.play();
+    } else {
+      this.muthera.emit("queueEnd", player);
+    }
   }
 
   socketClosed(player, payload) {