magmastream 2.6.0-beta.7 → 2.6.0

package/README.md

@@ -44,6 +44,7 @@ Also you can join the [Discord Support Server](https://discord.com/invite/HV59Z3
 | [Lunio](https://discord.com/api/oauth2/authorize?client_id=945030475779551415&permissions=61991952&scope=bot+applications.commands)                                                                                                                   | vexi          |
 | [JukeDisc](https://discord.com/oauth2/authorize?client_id=1109751797549105176&permissions=968552214080&scope=bot+applications.commands)                                                                                                               | Theo          |
 | [Cool Music](https://discord.com/oauth2/authorize?client_id=923529398425096193&permissions=12888394808&redirect_uri=https%3A%2F%2Fdiscord.gg%2Fcool-music-support-925619107460698202&response_type=code&scope=bot%20identify%20applications.commands) | Itz Random    |
+| [Soundy](https://dsc.gg/sndy) | iaMJ          |
 
 If you want to add your own bot create a pull request with your bot added. Please add your full name.
 

package/dist/index.d.ts

@@ -527,7 +527,6 @@ declare class Node {
     extractSpotifyTrackID(url: string): string | null;
     extractSpotifyArtistID(url: string): string | null;
     private handleAutoplay;
-    private handleSpotifyAutoplay;
     private handleFailedTrack;
     private handleRepeatedTrack;
     private playNextTrack;
@@ -997,6 +996,11 @@ interface ManagerOptions {
     defaultSearchPlatform?: SearchPlatform;
     /** Whether the YouTube video titles should be replaced if the Author does not exactly match. */
     replaceYouTubeCredentials?: boolean;
+    /** The last.fm API key.
+     * If you need to create one go here: https://www.last.fm/api/account/create.
+     * If you already have one, get it from here: https://www.last.fm/api/accounts.
+     */
+    lastFmApiKey: string;
     /**
      * Function to send data to the websocket.
      * @param id

package/dist/structures/Manager.js

@@ -146,7 +146,7 @@ class Manager extends events_1.EventEmitter {
                 if (state.dynamicRepeat) {
                     player.setDynamicRepeat(state.dynamicRepeat, state.dynamicLoopInterval._idleTimeout);
                 }
-                if (state.isAutoplay) {
+                if (state.isAutoplay && state?.data?.Internal_BotUser) {
                     player.setAutoplay(state.isAutoplay, state.data.Internal_BotUser);
                 }
             }

package/dist/structures/Node.js

@@ -8,6 +8,7 @@ const nodeCheck_1 = tslib_1.__importDefault(require("../utils/nodeCheck"));
 const ws_1 = tslib_1.__importDefault(require("ws"));
 const fs_1 = tslib_1.__importDefault(require("fs"));
 const path_1 = tslib_1.__importDefault(require("path"));
+const axios_1 = tslib_1.__importDefault(require("axios"));
 exports.validSponsorBlocks = ["sponsor", "selfpromo", "interaction", "intro", "outro", "preview", "music_offtopic", "filler"];
 const sessionIdsFilePath = path_1.default.join(process.cwd(), "node_modules", "magmastream", "dist", "sessionData", "sessionIds.json");
 let sessionIdsMap = new Map();
@@ -367,72 +368,102 @@ class Node {
         return match ? match[1] : null;
     }
     // Handle autoplay
-    async handleAutoplay(player, track) {
+    async handleAutoplay(player, track, attempts = 0) {
+        if (!player.isAutoplay || attempts > 3 || !player.queue.previous)
+            return false;
         const previousTrack = player.queue.previous;
-        if (!player.isAutoplay || !previousTrack)
-            return;
-        const hasSpotifyURL = ["spotify.com", "open.spotify.com"].some((url) => previousTrack.uri.includes(url));
-        if (hasSpotifyURL) {
-            const spotifySuccess = await this.handleSpotifyAutoplay(player); // Check if Spotify autoplay was successful
-            if (spotifySuccess)
-                return; // If successful, exit the function
+        const apiKey = this.manager.options.lastFmApiKey;
+        // If Last.fm API is not available and YouTube is not supported
+        if (!apiKey && !this.info.sourceManagers.includes("youtube"))
+            return false;
+        // Handle YouTube autoplay logic
+        if ((!apiKey && this.info.sourceManagers.includes("youtube")) || (attempts > 2 && this.info.sourceManagers.includes("youtube"))) {
+            const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => previousTrack.uri.includes(url));
+            const videoID = hasYouTubeURL
+                ? previousTrack.uri.split("=").pop()
+                : (await player.search(`${previousTrack.author} - ${previousTrack.title}`, player.get("Internal_BotUser"))).tracks[0]?.uri.split("=").pop();
+            if (!videoID)
+                return false;
+            let randomIndex;
+            let searchURI;
+            do {
+                randomIndex = Math.floor(Math.random() * 23) + 2;
+                searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}&index=${randomIndex}`;
+            } while (track.uri.includes(searchURI));
+            const res = await player.search(searchURI, player.get("Internal_BotUser"));
+            if (res.loadType === "empty" || res.loadType === "error")
+                return false;
+            const foundTrack = res.tracks.find((t) => t.uri !== track.uri && t.author !== track.author && t.title !== track.title);
+            if (!foundTrack)
+                return false;
+            player.queue.add(foundTrack);
+            player.play();
+            return true;
         }
-        const hasYouTubeURL = ["youtube.com", "youtu.be"].some((url) => previousTrack.uri.includes(url));
-        let videoID = previousTrack.uri.substring(previousTrack.uri.indexOf("=") + 1);
-        if (!hasYouTubeURL) {
-            const res = await player.search(`${previousTrack.author} - ${previousTrack.title}`, player.get("Internal_BotUser"));
-            videoID = res.tracks[0].uri.substring(res.tracks[0].uri.indexOf("=") + 1);
+        // Handle Last.fm-based autoplay logic
+        let { author: artist } = previousTrack;
+        const { title, uri } = previousTrack;
+        const enabledSources = this.info.sourceManagers;
+        const isSpotifyEnabled = enabledSources.includes("spotify");
+        const isSpotifyUri = uri.includes("spotify.com");
+        let selectedSource = null;
+        if (isSpotifyEnabled && isSpotifyUri) {
+            selectedSource = "spotify";
         }
-        let randomIndex;
-        let searchURI;
-        do {
-            randomIndex = Math.floor(Math.random() * 23) + 2;
-            searchURI = `https://www.youtube.com/watch?v=${videoID}&list=RD${videoID}&index=${randomIndex}`;
-        } while (track.uri.includes(searchURI));
-        const res = await player.search(searchURI, player.get("Internal_BotUser"));
-        if (res.loadType === "empty" || res.loadType === "error")
-            return;
-        let tracks = res.tracks;
-        if (res.loadType === "playlist")
-            tracks = res.playlist.tracks;
-        const foundTrack = tracks.sort(() => Math.random() - 0.5).find((shuffledTrack) => shuffledTrack.uri !== track.uri);
-        if (!foundTrack)
-            return;
-        if (this.manager.options.replaceYouTubeCredentials) {
-            foundTrack.author = foundTrack.author.replace("- Topic", "");
-            foundTrack.title = foundTrack.title.replace("Topic -", "");
-            if (foundTrack.title.includes("-")) {
-                const [author, title] = foundTrack.title.split("-").map((str) => str.trim());
-                foundTrack.author = author;
-                foundTrack.title = title;
+        else {
+            selectedSource = this.manager.options.defaultSearchPlatform;
+        }
+        if (!artist || !title) {
+            if (!title) {
+                const noTitleUrl = `https://ws.audioscrobbler.com/2.0/?method=artist.getTopTracks&artist=${artist}&autocorrect=1&api_key=${apiKey}&format=json`;
+                const response = await axios_1.default.get(noTitleUrl);
+                if (response.data.error || !response.data.toptracks?.track?.length)
+                    return false;
+                const randomTrack = response.data.toptracks.track[Math.floor(Math.random() * response.data.toptracks.track.length)];
+                const res = await player.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, player.get("Internal_BotUser"));
+                if (res.loadType === "empty" || res.loadType === "error")
+                    return false;
+                const foundTrack = res.tracks.find((t) => t.uri !== track.uri);
+                if (!foundTrack)
+                    return false;
+                player.queue.add(foundTrack);
+                player.play();
+                return true;
+            }
+            else if (!artist) {
+                const noArtistUrl = `https://ws.audioscrobbler.com/2.0/?method=track.search&track=${title}&api_key=${apiKey}&format=json`;
+                const response = await axios_1.default.get(noArtistUrl);
+                artist = response.data.results.trackmatches?.track?.[0]?.artist;
+                if (!artist)
+                    return false;
             }
         }
-        player.queue.add(foundTrack);
-        player.play();
-    }
-    async handleSpotifyAutoplay(player) {
-        const previousTrack = player.queue.previous;
-        const node = this.manager.useableNodes;
-        const isSpotifyPluginEnabled = node.info.plugins.some((plugin) => plugin.name === "lavasrc-plugin");
-        const isSpotifySourceManagerEnabled = node.info.sourceManagers.includes("spotify");
-        if (!isSpotifySourceManagerEnabled || !isSpotifyPluginEnabled)
-            return false;
-        const trackID = this.extractSpotifyTrackID(previousTrack.uri);
-        const artistID = this.extractSpotifyArtistID(previousTrack.pluginInfo.artistUrl);
-        let identifier = [trackID && `seed_tracks=${trackID}`, artistID && `seed_artists=${artistID}`].filter(Boolean).join("&");
-        if (identifier) {
-            identifier = `sprec:${identifier}`;
+        const url = `https://ws.audioscrobbler.com/2.0/?method=track.getSimilar&artist=${artist}&track=${title}&limit=10&autocorrect=1&api_key=${apiKey}&format=json`;
+        const response = await axios_1.default.get(url);
+        if (response.data.error || !response.data.similartracks?.track?.length) {
+            const retryUrl = `https://ws.audioscrobbler.com/2.0/?method=artist.getTopTracks&artist=${artist}&autocorrect=1&api_key=${apiKey}&format=json`;
+            const retryResponse = await axios_1.default.get(retryUrl);
+            if (retryResponse.data.error || !retryResponse.data.toptracks?.track?.length)
+                return false;
+            const randomTrack = retryResponse.data.toptracks.track[Math.floor(Math.random() * retryResponse.data.toptracks.track.length)];
+            const res = await player.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, player.get("Internal_BotUser"));
+            if (res.loadType === "empty" || res.loadType === "error")
+                return false;
+            const foundTrack = res.tracks.find((t) => t.uri !== track.uri);
+            if (!foundTrack)
+                return false;
+            player.queue.add(foundTrack);
+            player.play();
+            return true;
         }
-        if (!identifier)
-            return false;
-        const recommendedResult = (await node.rest.get(`/v4/loadtracks?identifier=${encodeURIComponent(identifier)}`));
-        if (recommendedResult.loadType !== "playlist")
+        const randomTrack = response.data.similartracks.track[Math.floor(Math.random() * response.data.similartracks.track.length)];
+        const res = await player.search({ query: `${randomTrack.artist.name} - ${randomTrack.name}`, source: selectedSource }, player.get("Internal_BotUser"));
+        if (res.loadType === "empty" || res.loadType === "error")
             return false;
-        const playlistData = recommendedResult.data;
-        const recommendedTrack = playlistData.tracks[0];
-        if (!recommendedTrack)
+        const foundTrack = res.tracks.find((t) => t.uri !== track.uri);
+        if (!foundTrack)
             return false;
-        player.queue.add(Utils_1.TrackUtils.build(recommendedTrack, player.get("Internal_BotUser")));
+        player.queue.add(foundTrack);
         player.play();
         return true;
     }
@@ -480,13 +511,22 @@ class Node {
         player.queue.previous = player.queue.current;
         player.queue.current = null;
         if (!player.isAutoplay) {
-            player.queue.previous = player.queue.current;
-            player.queue.current = null;
             player.playing = false;
             this.manager.emit("queueEnd", player, track, payload);
             return;
         }
-        await this.handleAutoplay(player, track);
+        let attempts = 1;
+        let success = false;
+        while (attempts <= 3) {
+            success = await this.handleAutoplay(player, track, attempts);
+            if (success)
+                return;
+            attempts++;
+        }
+        // If all attempts fail, reset the player state and emit queueEnd
+        player.queue.previous = null;
+        player.playing = false;
+        this.manager.emit("queueEnd", player, track, payload);
     }
     trackStuck(player, track, payload) {
         player.stop();

package/dist/utils/managerCheck.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function managerCheck(options) {
     if (!options)
         throw new TypeError("ManagerOptions must not be empty.");
-    const { autoPlay, clientId, clientName, defaultSearchPlatform, nodes, plugins, send, trackPartial, usePriority, useNode, replaceYouTubeCredentials } = options;
+    const { autoPlay, clientId, clientName, defaultSearchPlatform, nodes, plugins, send, trackPartial, usePriority, useNode, replaceYouTubeCredentials, lastFmApiKey, } = options;
     if (typeof autoPlay !== "undefined" && typeof autoPlay !== "boolean") {
         throw new TypeError('Manager option "autoPlay" must be a boolean.');
     }
@@ -49,5 +49,8 @@ function managerCheck(options) {
     if (typeof replaceYouTubeCredentials !== "undefined" && typeof replaceYouTubeCredentials !== "boolean") {
         throw new TypeError('Manager option "replaceYouTubeCredentials" must be a boolean.');
     }
+    if (typeof lastFmApiKey !== "undefined" && (typeof lastFmApiKey !== "string" || lastFmApiKey.trim().length === 0)) {
+        throw new TypeError('Manager option "lastFmApiKey" must be a string.');
+    }
 }
 exports.default = managerCheck;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "magmastream",
-	"version": "2.6.0-beta.7",
+	"version": "2.6.0",
 	"description": "A user-friendly Lavalink client designed for NodeJS.",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -15,9 +15,9 @@
 	},
 	"devDependencies": {
 		"@favware/rollup-type-bundler": "^3.3.0",
-		"@types/lodash": "^4.17.9",
-		"@types/node": "^20.16.10",
-		"@types/ws": "^8.5.12",
+		"@types/lodash": "^4.17.13",
+		"@types/node": "^20.17.9",
+		"@types/ws": "^8.5.13",
 		"@typescript-eslint/eslint-plugin": "^7.18.0",
 		"@typescript-eslint/parser": "^7.18.0",
 		"eslint": "^8.57.1",
@@ -28,10 +28,10 @@
 	},
 	"dependencies": {
 		"@discordjs/collection": "^2.1.1",
-		"axios": "^1.7.7",
+		"axios": "^1.7.9",
 		"events": "^3.3.0",
 		"lodash": "^4.17.21",
-		"tslib": "^2.7.0",
+		"tslib": "^2.8.1",
 		"ws": "^8.18.0"
 	},
 	"peerDependencies": {