muthera 1.0.9 → 1.0.11

package/package.json

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

package/src/functions/autoPlay.js

@@ -1,204 +1,250 @@
-const { JSDOM } = require("jsdom");
-
-async function scAutoPlay(url) {
-  const res = await fetch(`${url}/recommended`);
-
-  const html = await res.text();
-
-  const dom = new JSDOM(html);
-  const document = dom.window.document;
-
-  const secondNoscript = document.querySelectorAll("noscript")[1];
-  const sectionElement = secondNoscript.querySelector("section");
-  const articleElements = sectionElement.querySelectorAll("article");
-
-  articleElements.forEach((articleElement) => {
-    const h2Element = articleElement.querySelector('h2[itemprop="name"]');
-
-    const aElement = h2Element.querySelector('a[itemprop="url"]');
-    const href = `https://soundcloud.com${aElement.getAttribute("href")}`;
-
-    return href;
-  });
-}
-
-async function amAutoPlay(track_id, retries = 3) {
-  async function fetchWithRetry(url, options, retries) {
-    for (let attempt = 0; attempt < retries; attempt++) {
-      try {
-        const res = await fetch(url, options);
-        return await res.json();
-      } catch (error) {
-        if (attempt === retries - 1) {
-          throw new Error("No track found.");
-        }
-      }
-    }
-  }
-  const trackData = await fetchWithRetry(
-    `https://itunes.apple.com/lookup?id=${track_id}`,
-    retries
-  );
-
-  if (!trackData.results || trackData.results.length === 0) {
-    throw new Error("No track found.");
-  }
-
-  const track = trackData.results[0];
-  const genreName = track.primaryGenreName;
-
-  const relatedData = await fetchWithRetry(
-    `https://itunes.apple.com/search?term=${encodeURIComponent(
-      genreName
-    )}&entity=song`,
-    retries
-  );
-
-  if (!relatedData.results || relatedData.results.length === 0) {
-    throw new Error("No track found.");
-  }
-
-  return relatedData.results.filter(
-    (item) => item.wrapperType === "track" && item.trackId !== track_id
-  );
-}
-
-async function spAutoPlay(track_id, retries = 3) {
-  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 === 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"
-  );
-  const accessToken = tokenResponse.accessToken;
-  if (!accessToken) throw new Error("Failed to get Spotify token.");
-
-  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.");
-
-  // 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, title = null, artist = null, retries = 3) {
-  async function fetchWithRetryJson(url, options = {}, retriesLeft = 3) {
-    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 (err) {
-        if (attempt === retriesLeft - 1) throw err;
-        await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
-      }
-    }
-  }
-
-  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) return null;
-
-  const originalTrackId = String(trackData.id);
-  const artistId = trackData.artist?.id ? String(trackData.artist.id) : null;
-  const candidates = new Map();
-
-  function addTracksArray(arr) {
-    if (!Array.isArray(arr)) return;
-    for (const t of arr) {
-      if (!t || !t.id) continue;
-      const tid = String(t.id);
-      if (tid === originalTrackId) continue;
-      if (!candidates.has(tid)) candidates.set(tid, t);
-    }
-  }
-
-  if (artistId) {
-    try {
-      const topRes = await fetchWithRetryJson(`https://api.deezer.com/artist/${artistId}/top?limit=12`, {}, retries);
-      if (topRes?.data) addTracksArray(topRes.data);
-    } catch (_) {}
-  }
-
-  if (artistId) {
-    try {
-      const relRes = await fetchWithRetryJson(`https://api.deezer.com/artist/${artistId}/related`, {}, retries);
-      const relatedArtists = (relRes && relRes.data) || [];
-      const toFetch = relatedArtists.slice(0, 5);
-
-      const topPromises = toFetch.map((ra) =>
-        fetchWithRetryJson(`https://api.deezer.com/artist/${ra.id}/top?limit=6`, {}, retries)
-          .then((r) => (r?.data ? r.data : []))
-          .catch(() => [])
-      );
-
-      const topResults = await Promise.all(topPromises);
-      topResults.forEach((arr) => addTracksArray(arr));
-    } catch (_) {}
-  }
-
-  if (candidates.size === 0) {
-    try {
-      const q = `${encodeURIComponent(trackData.title || "")} ${encodeURIComponent(trackData.artist?.name || "")}`;
-      const searchRes = await fetchWithRetryJson(`https://api.deezer.com/search?q=${q}&limit=20`, {}, retries);
-      if (searchRes?.data) addTracksArray(searchRes.data);
-    } catch (_) {}
-  }
-
-  const arr = Array.from(candidates.values());
-  if (!arr.length) return null;
-  const pick = arr[Math.floor(Math.random() * arr.length)];
-  return `https://www.deezer.com/track/${pick.id}`;
-} 
-
-module.exports = { scAutoPlay, spAutoPlay, amAutoPlay, dzAutoPlay };
+const { JSDOM } = require("jsdom");
+
+async function scAutoPlay(url) {
+  const res = await fetch(`${url}/recommended`);
+
+  const html = await res.text();
+
+  const dom = new JSDOM(html);
+  const document = dom.window.document;
+
+  const secondNoscript = document.querySelectorAll("noscript")[1];
+  const sectionElement = secondNoscript.querySelector("section");
+  const articleElements = sectionElement.querySelectorAll("article");
+
+  articleElements.forEach((articleElement) => {
+    const h2Element = articleElement.querySelector('h2[itemprop="name"]');
+
+    const aElement = h2Element.querySelector('a[itemprop="url"]');
+    const href = `https://soundcloud.com${aElement.getAttribute("href")}`;
+
+    return href;
+  });
+}
+
+async function amAutoPlay(track_id, retries = 3) {
+  async function fetchWithRetry(url, options, retries) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+      try {
+        const res = await fetch(url, options);
+        return await res.json();
+      } catch (error) {
+        if (attempt === retries - 1) {
+          throw new Error("No track found.");
+        }
+      }
+    }
+  }
+  const trackData = await fetchWithRetry(
+    `https://itunes.apple.com/lookup?id=${track_id}`,
+    retries
+  );
+
+  if (!trackData.results || trackData.results.length === 0) {
+    throw new Error("No track found.");
+  }
+
+  const track = trackData.results[0];
+  const genreName = track.primaryGenreName;
+
+  const relatedData = await fetchWithRetry(
+    `https://itunes.apple.com/search?term=${encodeURIComponent(
+      genreName
+    )}&entity=song`,
+    retries
+  );
+
+  if (!relatedData.results || relatedData.results.length === 0) {
+    throw new Error("No track found.");
+  }
+
+  return relatedData.results.filter(
+    (item) => item.wrapperType === "track" && item.trackId !== track_id
+  );
+}
+
+async function spAutoPlay(track_id, clientId, clientSecret, retries = 3) {
+  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 === retriesLeft - 1) throw new Error("No track found.");
+        await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
+      }
+    }
+  }
+
+  let accessToken;
+
+  if (clientId && clientSecret) {
+    // Client Credentials flow — no user login needed, suitable for bots
+    const credentials = Buffer.from(`${clientId}:${clientSecret}`).toString("base64");
+    const tokenResponse = await fetchWithRetry(
+      "https://accounts.spotify.com/api/token",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${credentials}`,
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: "grant_type=client_credentials",
+      }
+    );
+    accessToken = tokenResponse.access_token;
+  } else {
+    // Fallback: public embed token (no credentials required, but limited)
+    const tokenResponse = await fetchWithRetry(
+      "https://open.spotify.com/get_access_token?reason=transport&productType=embed"
+    );
+    accessToken = tokenResponse.accessToken;
+  }
+
+  if (!accessToken) throw new Error("Failed to get Spotify token.");
+
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+  };
+
+  // Get the track to find its artist and genre info
+  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.");
+
+  const candidates = new Map();
+
+  // 1. Get artist's top tracks (always works with Client Credentials)
+  try {
+    const topTracksData = await fetchWithRetry(
+      `https://api.spotify.com/v1/artists/${artistId}/top-tracks?market=US`,
+      { headers }
+    );
+    for (const t of topTracksData?.tracks ?? []) {
+      if (t?.id && t.id !== track_id) candidates.set(t.id, t);
+    }
+  } catch (_) {}
+
+  // 2. Get artist's albums, then sample tracks from a random album
+  try {
+    const albumsData = await fetchWithRetry(
+      `https://api.spotify.com/v1/artists/${artistId}/albums?include_groups=album,single&market=US&limit=20`,
+      { headers }
+    );
+    const albums = albumsData?.items ?? [];
+    if (albums.length) {
+      // Pick up to 3 random albums to sample from
+      const shuffled = albums.sort(() => Math.random() - 0.5).slice(0, 3);
+      await Promise.all(
+        shuffled.map(async (album) => {
+          try {
+            const albumTracks = await fetchWithRetry(
+              `https://api.spotify.com/v1/albums/${album.id}/tracks?limit=10`,
+              { headers }
+            );
+            for (const t of albumTracks?.items ?? []) {
+              if (t?.id && t.id !== track_id) candidates.set(t.id, t);
+            }
+          } catch (_) {}
+        })
+      );
+    }
+  } catch (_) {}
+
+  if (!candidates.size) throw new Error("No tracks found.");
+
+  const pool = Array.from(candidates.values());
+  return pool[Math.floor(Math.random() * pool.length)].id;
+}
+
+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 {
+        const res = await fetch(url, options);
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        return await res.json();
+      } catch (err) {
+        if (attempt === retriesLeft - 1) throw err;
+        await new Promise((r) => setTimeout(r, 200 * (attempt + 1)));
+      }
+    }
+  }
+
+  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) return null;
+
+  const originalTrackId = String(trackData.id);
+  const artistId = trackData.artist?.id ? String(trackData.artist.id) : null;
+  const candidates = new Map();
+
+  function addTracksArray(arr) {
+    if (!Array.isArray(arr)) return;
+    for (const t of arr) {
+      if (!t || !t.id) continue;
+      const tid = String(t.id);
+      if (tid === originalTrackId) continue;
+      if (!candidates.has(tid)) candidates.set(tid, t);
+    }
+  }
+
+  if (artistId) {
+    try {
+      const topRes = await fetchWithRetryJson(`https://api.deezer.com/artist/${artistId}/top?limit=12`, {}, retries);
+      if (topRes?.data) addTracksArray(topRes.data);
+    } catch (_) {}
+  }
+
+  if (artistId) {
+    try {
+      const relRes = await fetchWithRetryJson(`https://api.deezer.com/artist/${artistId}/related`, {}, retries);
+      const relatedArtists = (relRes && relRes.data) || [];
+      const toFetch = relatedArtists.slice(0, 5);
+
+      const topPromises = toFetch.map((ra) =>
+        fetchWithRetryJson(`https://api.deezer.com/artist/${ra.id}/top?limit=6`, {}, retries)
+          .then((r) => (r?.data ? r.data : []))
+          .catch(() => [])
+      );
+
+      const topResults = await Promise.all(topPromises);
+      topResults.forEach((arr) => addTracksArray(arr));
+    } catch (_) {}
+  }
+
+  if (candidates.size === 0) {
+    try {
+      const q = `${encodeURIComponent(trackData.title || "")} ${encodeURIComponent(trackData.artist?.name || "")}`;
+      const searchRes = await fetchWithRetryJson(`https://api.deezer.com/search?q=${q}&limit=20`, {}, retries);
+      if (searchRes?.data) addTracksArray(searchRes.data);
+    } catch (_) {}
+  }
+
+  const arr = Array.from(candidates.values());
+  if (!arr.length) return null;
+  const pick = arr[Math.floor(Math.random() * arr.length)];
+  return `https://www.deezer.com/track/${pick.id}`;
+} 
+
+module.exports = { scAutoPlay, spAutoPlay, amAutoPlay, dzAutoPlay };

package/src/structures/Muthera.js

@@ -23,6 +23,8 @@ class Muthera extends EventEmitter {
     this.initiated = false;
     this.send = options.send || null;
     this.defaultSearchPlatform = options.defaultSearchPlatform || "ytsearch";
+    this.spotifyClientId = options.spotifyClientId || null;
+    this.spotifyClientSecret = options.spotifyClientSecret || null;
     this.tracks = [];
     this.loadType = null;
     this.playlistInfo = null;

package/src/structures/mutheraPlayer.js

@@ -229,6 +229,41 @@ class Player extends EventEmitter {
           } else {
             return fail();
           }
+          return this;
+        } catch (e) {
+          return fail(e);
+        }
+      } else if (player.previous.info.sourceName === "spsearch") {
+        try {
+          const trackId = await spAutoPlay(
+            player.previous.info.identifier,
+            this.muthera.spotifyClientId,
+            this.muthera.spotifyClientSecret
+          );
+          if (!trackId) return fail();
+
+          const response = await this.muthera.resolve({
+            query: `https://open.spotify.com/track/${trackId}`,
+            requester: player.previous.info.requester,
+          });
+
+          if (
+            !response ||
+            !response.tracks ||
+            ["error", "empty"].includes(response.loadType)
+          )
+            return fail();
+
+          const track =
+            response.tracks[Math.floor(Math.random() * response.tracks.length)];
+
+          if (this.connected) {
+            this.queue.push(track);
+            await this.play();
+          } else {
+            return fail();
+          }
+
           return this;
         } catch (e) {
           return fail(e);
@@ -273,7 +308,39 @@ class Player extends EventEmitter {
           const title = player.previous.info.title;
           const platform = this.muthera.defaultSearchPlatform;
 
-          if (platform.includes("dz")) {
+          if (platform.includes("spsearch")) {
+            // Use Spotify related-artist API for proper similar song recommendations
+            const trackId = await spAutoPlay(
+              player.previous.info.identifier,
+              this.muthera.spotifyClientId,
+              this.muthera.spotifyClientSecret
+            );
+            if (!trackId) return fail();
+
+            const response = await this.muthera.resolve({
+              query: `https://open.spotify.com/track/${trackId}`,
+              requester: player.previous.info.requester,
+            });
+
+            if (
+              !response ||
+              !response.tracks ||
+              ["error", "empty"].includes(response.loadType) ||
+              response.tracks.length === 0
+            )
+              return fail();
+
+            const track =
+              response.tracks[Math.floor(Math.random() * response.tracks.length)];
+
+            if (this.connected) {
+              this.queue.push(track);
+              await this.play();
+            } else {
+              return fail();
+            }
+            return this;
+          } else if (platform.includes("dz")) {
             // Use Deezer related-artist API for proper similar song recommendations
             const data = await dzAutoPlay(null, title, artist);
             if (!data) return fail();
@@ -507,6 +574,10 @@ class Player extends EventEmitter {
   }
 
   trackEnd(player, track, payload) {
+    // If the track ended due to an error (loadFailed), trackError() already
+    // handled advancing the queue / emitting queueEnd. Skip to avoid double handling.
+    if (payload.reason === "loadFailed") return;
+
     this.previous = track;
     if (this.loop === "track") {
       player.queue.unshift(this.previous);