aqualink 2.3.0 → 2.3.1

package/build/handlers/autoplay.js

@@ -1,95 +1,115 @@
 const https = require('https');
+const crypto = require('crypto');
 
-function fetch(url, options = {}) {
+function quickFetch(url, options = {}) {
     return new Promise((resolve, reject) => {
-        const req = https.get(url, options, (res) => {
+        const req = https.get(url, options, res => {
             if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-                return fetch(res.headers.location, options).then(resolve).catch(reject);
+                return resolve(quickFetch(res.headers.location, options));
             }
-            
             if (res.statusCode !== 200) {
-                res.resume();
-                reject(new Error(`Request failed. Status code: ${res.statusCode}`));
-                return;
+                res.resume(); 
+                return reject(new Error(`Request failed. Status code: ${res.statusCode}`));
             }
-            
             const chunks = [];
             res.on('data', chunk => chunks.push(chunk));
             res.on('end', () => resolve(Buffer.concat(chunks).toString()));
         });
-        
+        req.on('error', reject);
         req.setTimeout(10000, () => {
             req.destroy();
             reject(new Error('Request timeout'));
         });
-        
-        req.on('error', err => {
-            reject(err);
-        });
-        
         req.end();
     });
 }
 
-async function scAutoPlay(url) {
+async function soundAutoPlay(baseUrl) {
     try {
-        const html = await fetch(`${url}/recommended`);
-        
-        const regex = /<a itemprop="url" href="(\/.*?)"/g;
-        const hrefs = new Set();
+        const html = await quickFetch(`${baseUrl}/recommended`);
+        const regex = /<a\s+itemprop="url"\s+href="(\/[^"]+)"/g;
+        const links = new Set();
         let match;
-        
         while ((match = regex.exec(html)) !== null) {
-            hrefs.add(`https://soundcloud.com${match[1]}`);
+            links.add(`https://soundcloud.com${match[1]}`);
         }
-        
-        if (hrefs.size === 0) {
+        if (!links.size) {
             throw new Error("No recommended tracks found on SoundCloud.");
         }
-        
-        const shuffledHrefs = Array.from(hrefs);
-        for (let i = shuffledHrefs.length - 1; i > 0; i--) {
+        const urls = Array.from(links);
+        for (let i = urls.length - 1; i > 0; i--) {
             const j = Math.floor(Math.random() * (i + 1));
-            [shuffledHrefs[i], shuffledHrefs[j]] = [shuffledHrefs[j], shuffledHrefs[i]];
+            [urls[i], urls[j]] = [urls[j], urls[i]];
         }
-        
-        return shuffledHrefs;
-    } catch (error) {
-        console.error("Error fetching SoundCloud recommendations:", error);
+        return urls;
+    } catch (err) {
+        console.error("Error in SoundCloud autoplay:", err);
         return [];
     }
 }
 
-async function spAutoPlay(track_id) {
+function gerenateToKen() {
+    const totpSecret = Buffer.from(new Uint8Array([
+        53, 53, 48, 55, 49, 52, 53, 56, 53, 51, 52, 56, 55, 52, 57, 57,
+        53, 57, 50, 50, 52, 56, 54, 51, 48, 51, 50, 57, 51, 52, 55
+    ]));
+
+    // Note for  me: Can also be used from Buffer.from("5507145853487499592248630329347", 'utf8');
+
+    const timeStep = Math.floor(Date.now() / 30000);
+    const counter = Buffer.alloc(8);
+    counter.writeBigInt64BE(BigInt(timeStep));
+
+    const hmac = crypto.createHmac('sha1', totpSecret);
+    hmac.update(counter);
+    const hash = hmac.digest();
+    const offset = hash[hash.length - 1] & 0x0f;
+    const binCode =
+        ((hash[offset] & 0x7f) << 24) |
+        ((hash[offset + 1] & 0xff) << 16) |
+        ((hash[offset + 2] & 0xff) << 8) |
+        (hash[offset + 3] & 0xff);
+    const token = (binCode % 1000000).toString().padStart(6, '0');
+    return [token, timeStep * 30000];
+}
+
+async function spotifyAutoPlay(seedTrackId) {
+    const [totp, ts] = gerenateToKen();
+    const params = new URLSearchParams({
+        reason: "transport",
+        productType: "embed",
+        totp,
+        totpVer: "5",
+        ts: ts.toString()
+    });
+    const tokenUrl = `https://open.spotify.com/get_access_token?${params.toString()}`;
+    const tokenData = await quickFetch(tokenUrl);
+
+    let accessToken;
     try {
-        const tokenResponse = await fetch("https://open.spotify.com/get_access_token?reason=transport&productType=embed");
-        const tokenData = JSON.parse(tokenResponse);
-        const accessToken = tokenData?.accessToken;
-        
-        if (!accessToken) throw new Error("Failed to retrieve Spotify access token");
-        
-        const recommendationsResponse = await fetch(
-            `https://api.spotify.com/v1/recommendations?limit=5&seed_tracks=${track_id}&fields=tracks.id`, 
-            {
-                headers: { 
-                    Authorization: `Bearer ${accessToken}`, 
-                    'Content-Type': 'application/json'
-                }
-            }
-        );
-        
-        const data = JSON.parse(recommendationsResponse);
-        const tracks = data?.tracks || [];
-        
-        if (tracks.length === 0) {
-            throw new Error("No recommended tracks found on Spotify.");
+        accessToken = JSON.parse(tokenData).accessToken;
+    } catch {
+        throw new Error("Failed to retrieve Spotify access token.");
+    }
+
+    const recUrl = `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${seedTrackId}`;
+    const recData = await quickFetch(recUrl, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json'
         }
-        
-        return tracks[Math.floor(Math.random() * tracks.length)].id;
-    } catch (error) {
-        console.error("Error fetching Spotify recommendations:", error);
-        return null;
+    });
+
+    let tracks;
+    try {
+        tracks = JSON.parse(recData).tracks;
+    } catch {
+        throw new Error("Failed to parse Spotify recommendations.");
     }
+    return tracks[Math.floor(Math.random() * tracks.length)].id;
 }
 
-module.exports = { scAutoPlay, spAutoPlay };
+module.exports = {
+    scAutoPlay: soundAutoPlay,
+    spAutoPlay: spotifyAutoPlay
+};

package/build/structures/Player.js

@@ -26,24 +26,24 @@ class Player extends EventEmitter {
 
     constructor(aqua, nodes, options = {}) {
         super();
-        
+
         this.aqua = aqua;
         this.nodes = nodes;
         this.guildId = options.guildId;
         this.textChannel = options.textChannel;
         this.voiceChannel = options.voiceChannel;
-        
+
         this.connection = new Connection(this);
         this.filters = new Filters(this);
-        
+
         this.volume = Math.max(0, Math.min(options.defaultVolume ?? 100, 200));
         this.loop = Player.validModes.has(options.loop) ? options.loop : Player.LOOP_MODES.NONE;
-        
+
         this.queue = new Queue();
         this.previousTracks = new Array(50);
         this.previousTracksIndex = 0;
         this.previousTracksCount = 0;
-        
+
         this.shouldDeleteMessage = Boolean(options.shouldDeleteMessage);
         this.leaveOnEnd = Boolean(options.leaveOnEnd);
 
@@ -57,43 +57,46 @@ class Player extends EventEmitter {
         this.nowPlayingMessage = null;
         this.isAutoplayEnabled = false;
         this.isAutoplay = false;
-        
+
         this._boundHandlers = {
             playerUpdate: this._handlePlayerUpdate.bind(this),
             event: this._handleEvent.bind(this)
         };
-        
+
         this.on("playerUpdate", this._boundHandlers.playerUpdate);
         this.on("event", this._boundHandlers.event);
-        
+
         this._dataStore = null;
     }
 
     get previous() {
-        return this.previousTracksCount > 0 ? this.previousTracks[this.previousTracksIndex] : null;
+        if (this.previousTracksCount === 0) return null;
+
+        const previousIndex = (this.previousTracksIndex - 1 + 50) % 50;
+        return this.previousTracks[previousIndex];
     }
-    
+
     get currenttrack() {
         return this.current;
     }
 
     async autoplay(player) {
         if (!player) throw new Error("Quick Fix: player.autoplay(player)");
-    
+
         if (!this.isAutoplayEnabled) {
             this.aqua.emit("debug", this.guildId, "Autoplay is disabled.");
             return this;
         }
-    
+
         this.isAutoplay = true;
         if (!this.previous) return this;
-    
+
         try {
             const { sourceName, identifier, uri, requester } = this.previous.info;
             this.aqua.emit("debug", this.guildId, `Attempting autoplay for ${sourceName}`);
-    
+
             let query, source, response;
-    
+
             const sourceHandlers = {
                 youtube: async () => {
                     return {
@@ -118,51 +121,51 @@ class Player extends EventEmitter {
                     };
                 }
             };
-            
+
             const handler = sourceHandlers[sourceName];
             if (!handler) return this;
-            
+
             const result = await handler();
             if (!result) return this;
-            
+
             ({ query, source } = result);
-    
+
             response = await this.aqua.resolve({ query, source, requester });
-    
+
             if (!response?.tracks?.length || ["error", "empty", "LOAD_FAILED", "NO_MATCHES"].includes(response.loadType)) {
                 return this.stop();
             }
-    
+
             const track = response.tracks[Math.floor(Math.random() * response.tracks.length)];
-    
+
             if (!track?.info?.title) {
                 throw new Error("Invalid track object: missing title or info.");
             }
-    
+
             track.requester = this.previous.requester || { id: "Unknown" };
-    
+
             this.queue.push(track);
             await this.play();
-    
+
             return this;
         } catch (error) {
             console.error("Autoplay error:", error);
             return this.stop();
         }
     }
-    
+
     setAutoplay(enabled) {
         this.isAutoplayEnabled = Boolean(enabled);
         this.aqua.emit("debug", this.guildId, `Autoplay has been ${enabled ? "enabled" : "disabled"}.`);
         return this;
     }
-    
+
     addToPreviousTrack(track) {
         if (!track) return;
-        
+
         this.previousTracks[this.previousTracksIndex] = track;
         this.previousTracksIndex = (this.previousTracksIndex + 1) % 50;
-        
+
         if (this.previousTracksCount < 50) {
             this.previousTracksCount++;
         }
@@ -171,7 +174,7 @@ class Player extends EventEmitter {
     _handlePlayerUpdate({ state }) {
         if (state) {
             const { position, timestamp, ping } = state;
-            
+
             if (position !== undefined) this.position = position;
             if (timestamp !== undefined) this.timestamp = timestamp;
             if (ping !== undefined) this.ping = ping;
@@ -190,7 +193,7 @@ class Player extends EventEmitter {
 
     async play() {
         if (!this.connected || !this.queue.length) return;
-        
+
         const item = this.queue.shift();
         this.current = item.track ? item : await item.resolve(this.aqua);
         this.playing = true;
@@ -200,18 +203,19 @@ class Player extends EventEmitter {
         return this.updatePlayer({ track: { encoded: this.current.track } });
     }
 
-    connect({ guildId, voiceChannel, deaf = true, mute = false }) {
-        if (this.connected) throw new Error("Player is already connected.");
-        
+    connect(options = {}) {
+        const { voiceChannel, deaf = true, mute = false } = options;
+
+
         const payload = {
-            guild_id: guildId,
-            channel_id: voiceChannel,
+            guild_id: this.guildId,
+            channel_id: this.voiceChannel,
             self_deaf: deaf,
             self_mute: mute
         };
-        
+
         this.send(payload);
-        
+
         this.connected = true;
         this.aqua.emit("debug", this.guildId, `Player connected to voice channel: ${voiceChannel}.`);
         return this;
@@ -219,41 +223,41 @@ class Player extends EventEmitter {
 
     destroy() {
         if (!this.connected) return this;
-        
+
         this.disconnect();
-        
+
         this._cleanupNowPlayingMessage();
-        
+
         this.isAutoplay = false;
 
         this.off("playerUpdate", this._boundHandlers.playerUpdate);
         this.off("event", this._boundHandlers.event);
-        
+
         this.aqua.destroyPlayer(this.guildId);
         this.nodes.rest.destroyPlayer(this.guildId);
-        
+
         this.clearData();
         this.removeAllListeners();
-        
+
         this._boundHandlers = null;
         this.queue = null;
         this.previousTracks = null;
         this.connection = null;
         this.filters = null;
-        
+
         return this;
     }
-    
+
     _cleanupNowPlayingMessage() {
         if (this.nowPlayingMessage) {
-            this.nowPlayingMessage.delete().catch(() => {});
+            this.nowPlayingMessage.delete().catch(() => { });
             this.nowPlayingMessage = null;
         }
     }
 
     pause(paused) {
         if (this.paused === paused) return this;
-        
+
         this.paused = paused;
         this.updatePlayer({ paused });
         return this;
@@ -271,7 +275,7 @@ class Player extends EventEmitter {
 
     seek(position) {
         if (!this.playing) return this;
-        
+
         this.position += position;
         this.updatePlayer({ position: this.position });
         return this;
@@ -287,7 +291,7 @@ class Player extends EventEmitter {
 
     setVolume(volume) {
         if (volume < 0 || volume > 200) throw new Error("Volume must be between 0 and 200.");
-        
+
         this.volume = volume;
         this.updatePlayer({ volume });
         return this;
@@ -295,7 +299,7 @@ class Player extends EventEmitter {
 
     setLoop(mode) {
         if (!Player.validModes.has(mode)) throw new Error("Loop mode must be 'none', 'track', or 'queue'.");
-        
+
         this.loop = mode;
         this.updatePlayer({ loop: mode });
         return this;
@@ -309,26 +313,26 @@ class Player extends EventEmitter {
 
     setVoiceChannel(channel) {
         if (!channel?.length) throw new TypeError("Channel must be a non-empty string.");
-        
+
         if (this.connected && channel === this.voiceChannel) {
             throw new ReferenceError(`Player already connected to ${channel}.`);
         }
-        
+
         this.voiceChannel = channel;
-        
+
         this.connect({
             deaf: this.deaf,
             guildId: this.guildId,
             voiceChannel: channel,
             mute: this.mute
         });
-        
+
         return this;
     }
 
     disconnect() {
         if (!this.connected) return this;
-        
+
         this.connected = false;
         this.send({ guild_id: this.guildId, channel_id: null });
         this.voiceChannel = null;
@@ -367,7 +371,7 @@ class Player extends EventEmitter {
 
     async trackEnd(player, track, payload) {
         this.addToPreviousTrack(track);
-        
+
         if (this.shouldDeleteMessage && this.nowPlayingMessage) {
             try {
                 await this.nowPlayingMessage.delete();
@@ -376,7 +380,7 @@ class Player extends EventEmitter {
                 console.error("Error deleting now playing message:", error);
             }
         }
-        
+
         const reason = payload.reason;
         if (reason === "LOAD_FAILED" || reason === "CLEANUP") {
             if (!player.queue.length) {
@@ -398,7 +402,7 @@ class Player extends EventEmitter {
             await player.play();
         }
     }
-    
+
     async _handleTrackLooping(player, track) {
         if (this.loop === Player.LOOP_MODES.TRACK) {
             player.queue.unshift(track);
@@ -406,7 +410,7 @@ class Player extends EventEmitter {
             player.queue.push(track);
         }
     }
-    
+
     async _handleEmptyQueue(player) {
         if (this.isAutoplayEnabled) {
             await player.autoplay(player);
@@ -432,7 +436,7 @@ class Player extends EventEmitter {
 
     async socketClosed(player, payload) {
         const { code, guildId } = payload || {};
-        
+
         if (code === 4015 || code === 4009) {
             this.send({
                 guild_id: guildId,
@@ -441,7 +445,7 @@ class Player extends EventEmitter {
                 self_deaf: this.deaf,
             });
         }
-        
+
         this.aqua.emit("socketClosed", player, payload);
         this.pause(true);
         this.aqua.emit("debug", this.guildId, "Player paused due to socket closure.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",