aqualink 2.6.1-fix3 → 2.6.2

package/build/structures/Aqua.js

@@ -4,16 +4,17 @@ const Player = require("./Player");
 const Track = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const { EventEmitter } = require('tseep');
+const fs = require('fs-extra');
 
 const URL_REGEX = /^https?:\/\//;
 const DEFAULT_OPTIONS = Object.freeze({
-  shouldDeleteMessage: false,
-  defaultSearchPlatform: 'ytsearch',
-  leaveOnEnd: true,
-  restVersion: 'v4',
-  plugins: [],
-  autoResume: false,
-  infiniteReconnects: false
+    shouldDeleteMessage: false,
+    defaultSearchPlatform: 'ytsearch',
+    leaveOnEnd: true,
+    restVersion: 'v4',
+    plugins: [],
+    autoResume: false,
+    infiniteReconnects: false
 });
 const LEAST_USED_CACHE_TTL = 50;
 
@@ -32,9 +33,9 @@ class Aqua extends EventEmitter {
         this.clientId = null;
         this.initiated = false;
         this.version = pkgVersion;
-        
+
         this.options = Object.assign({}, DEFAULT_OPTIONS, options);
-        
+
         const {
             shouldDeleteMessage,
             defaultSearchPlatform,
@@ -45,7 +46,7 @@ class Aqua extends EventEmitter {
             infiniteReconnects,
             send
         } = this.options;
-        
+
         this.shouldDeleteMessage = shouldDeleteMessage;
         this.defaultSearchPlatform = defaultSearchPlatform;
         this.leaveOnEnd = leaveOnEnd;
@@ -53,9 +54,9 @@ class Aqua extends EventEmitter {
         this.plugins = plugins;
         this.autoResume = autoResume;
         this.infiniteReconnects = infiniteReconnects;
-        
+
         this.send = send || this.defaultSendFunction.bind(this);
-        
+
         this._leastUsedCache = { nodes: [], timestamp: 0 };
     }
 
@@ -69,14 +70,14 @@ class Aqua extends EventEmitter {
         if (now - this._leastUsedCache.timestamp < LEAST_USED_CACHE_TTL) {
             return this._leastUsedCache.nodes;
         }
-        
+
         const connectedNodes = [];
         for (const node of this.nodeMap.values()) {
             if (node.connected) connectedNodes.push(node);
         }
-        
+
         connectedNodes.sort((a, b) => a.rest.calls - b.rest.calls);
-        
+
         this._leastUsedCache = { nodes: connectedNodes, timestamp: now };
         return connectedNodes;
     }
@@ -84,35 +85,35 @@ class Aqua extends EventEmitter {
     async init(clientId) {
         if (this.initiated) return this;
         this.clientId = clientId;
-        
+
         try {
             const nodePromises = [];
             for (const node of this.nodes) {
                 nodePromises.push(this.createNode(node));
             }
             await Promise.all(nodePromises);
-            
+
             for (const plugin of this.plugins) {
                 plugin.load(this);
             }
-            
+
             this.initiated = true;
         } catch (error) {
             this.initiated = false;
             throw error;
         }
-        
+
         return this;
     }
 
     async createNode(options) {
         const nodeId = options.name || options.host;
         this.destroyNode(nodeId);
-        
+
         const node = new Node(this, options, this.options);
         this.nodeMap.set(nodeId, node);
         this._leastUsedCache.timestamp = 0;
-        
+
         try {
             await node.connect();
             this.emit("nodeCreate", node);
@@ -127,7 +128,7 @@ class Aqua extends EventEmitter {
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
-        
+
         node.destroy();
         this.nodeMap.delete(identifier);
         this._leastUsedCache.timestamp = 0;
@@ -137,14 +138,14 @@ class Aqua extends EventEmitter {
     updateVoiceState({ d, t }) {
         const player = this.players.get(d.guild_id);
         if (!player) return;
-        
+
         if (t === "VOICE_SERVER_UPDATE" || (t === "VOICE_STATE_UPDATE" && d.user_id === this.clientId)) {
             if (t === "VOICE_SERVER_UPDATE") {
                 player.connection?.setServerUpdate?.(d);
             } else {
                 player.connection?.setStateUpdate?.(d);
             }
-            
+
             if (d.channel_id === null) {
                 this.cleanupPlayer(player);
             }
@@ -153,23 +154,23 @@ class Aqua extends EventEmitter {
 
     fetchRegion(region) {
         if (!region) return this.leastUsedNodes;
-        
+
         const lowerRegion = region.toLowerCase();
         const regionNodes = [];
-        
+
         for (const node of this.nodeMap.values()) {
             if (node.connected && node.regions?.includes(lowerRegion)) {
                 regionNodes.push(node);
             }
         }
-        
+
         const loadCache = new Map();
         regionNodes.sort((a, b) => {
             if (!loadCache.has(a)) loadCache.set(a, this.calculateLoad(a));
             if (!loadCache.has(b)) loadCache.set(b, this.calculateLoad(b));
             return loadCache.get(a) - loadCache.get(b);
         });
-        
+
         return regionNodes;
     }
 
@@ -182,27 +183,28 @@ class Aqua extends EventEmitter {
 
     createConnection(options) {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
-        
+
         const existingPlayer = this.players.get(options.guildId);
         if (existingPlayer && existingPlayer.voiceChannel) return existingPlayer;
-        
+
         const availableNodes = options.region ? this.fetchRegion(options.region) : this.leastUsedNodes;
         const node = availableNodes[0];
         if (!node) throw new Error("No nodes are available");
-        
+
         return this.createPlayer(node, options);
     }
 
     createPlayer(node, options) {
         this.destroyPlayer(options.guildId);
-        
+
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
-        
+
         player.on("destroy", () => {
             this.players.delete(options.guildId);
+            this.emit("playerDestroy", player);
         });
-        
+
         player.connect(options);
         this.emit("playerCreate", player);
         return player;
@@ -211,7 +213,7 @@ class Aqua extends EventEmitter {
     async destroyPlayer(guildId) {
         const player = this.players.get(guildId);
         if (!player) return;
-        
+
         try {
             await player.clearData();
             player.removeAllListeners();
@@ -224,18 +226,18 @@ class Aqua extends EventEmitter {
 
     async resolve({ query, source = this.defaultSearchPlatform, requester, nodes }) {
         if (!this.initiated) throw new Error("Aqua must be initialized before this operation");
-        
+
         const requestNode = this.getRequestNode(nodes);
         const formattedQuery = URL_REGEX.test(query) ? query : `${source}:${query}`;
-        
+
         try {
             const endpoint = `/v4/loadtracks?identifier=${encodeURIComponent(formattedQuery)}`;
             const response = await requestNode.rest.makeRequest("GET", endpoint);
-            
+
             if (["empty", "NO_MATCHES"].includes(response.loadType)) {
                 return await this.handleNoMatches(query);
             }
-            
+
             return this.constructResponse(response, requester, requestNode);
         } catch (error) {
             if (error.name === "AbortError") {
@@ -244,19 +246,19 @@ class Aqua extends EventEmitter {
             throw new Error(`Failed to resolve track: ${error.message}`);
         }
     }
-    
+
     getRequestNode(nodes) {
         if (!nodes) return this.leastUsedNodes[0];
-        
+
         if (nodes instanceof Node) return nodes;
         if (typeof nodes === "string") {
             const mappedNode = this.nodeMap.get(nodes);
             return mappedNode || this.leastUsedNodes[0];
         }
-        
+
         throw new TypeError(`'nodes' must be a string or Node instance, received: ${typeof nodes}`);
     }
-    
+
     async handleNoMatches(query) {
         return {
             loadType: "empty",
@@ -266,8 +268,8 @@ class Aqua extends EventEmitter {
             tracks: []
         };
     }
-    
-    constructResponse(response, requester, requestNode) {
+
+    async constructResponse(response, requester, requestNode) {
         const baseResponse = {
             loadType: response.loadType,
             exception: null,
@@ -275,28 +277,29 @@ class Aqua extends EventEmitter {
             pluginInfo: response.pluginInfo ?? {},
             tracks: []
         };
-        
+
         if (response.loadType === "error" || response.loadType === "LOAD_FAILED") {
             baseResponse.exception = response.data ?? response.exception;
             return baseResponse;
         }
-        
+
         const trackFactory = (trackData) => new Track(trackData, requester, requestNode);
-        
+
         switch (response.loadType) {
             case "track":
                 if (response.data) {
                     baseResponse.tracks.push(trackFactory(response.data));
                 }
                 break;
-
             case "playlist": {
                 const info = response.data?.info;
                 if (info) {
-                    baseResponse.playlistInfo = {
+                    const playlistInfo = {
                         name: info.name ?? info.title,
+                        thumbnail: response.data.pluginInfo?.artworkUrl ?? (response.data.tracks?.[0]?.info?.artworkUrl || null),
                         ...info
                     };
+                    baseResponse.playlistInfo = playlistInfo;
                 }
 
                 const tracks = response.data?.tracks;
@@ -322,7 +325,7 @@ class Aqua extends EventEmitter {
                 break;
             }
         }
-        
+
         return baseResponse;
     }
 
@@ -334,7 +337,7 @@ class Aqua extends EventEmitter {
 
     async search(query, requester, source = this.defaultSearchPlatform) {
         if (!query || !requester) return null;
-        
+
         try {
             const { tracks } = await this.resolve({ query, source, requester });
             return tracks || null;
@@ -344,21 +347,94 @@ class Aqua extends EventEmitter {
         }
     }
 
-    async cleanupPlayer(player) {
-        if (!player) return;
-        
+    async savePlayer(filePath = "./AquaPlayers.json") {
+        const data = Array.from(this.players.values()).map(player => ({
+            guildId: player.guildId,
+            textChannel: player.textChannel,
+            voiceChannel: player.voiceChannel,
+            track: player.current ? {
+                identifier: player.current.identifier,
+                author: player.current.author,
+                title: player.current.title,
+                uri: player.current.uri,
+                sourceName: player.current.sourceName,
+                artworkUrl: player.current.artworkUrl,
+                duration: player.current.duration,
+                position: player.position,
+            } : null,
+            requester: player.requester || player.current?.requester,
+            volume: player.volume,
+            paused: player.paused
+        }));
+        console.log(`Saving ${data.length} players to ${filePath}`);
+        await fs.writeJSON(filePath, data, { spaces: 2 });
+        this.emit("debug", "Aqua", `Saved players to ${filePath}`);
+    }
+
+    async waitForFirstNode() {
+        if (this.leastUsedNodes.length > 0) return;
+        return new Promise(resolve => {
+            const check = () => {
+                if (this.leastUsedNodes.length > 0) {
+                    resolve();
+                } else {
+                    setTimeout(check, 100);
+                }
+            };
+            check();
+        });
+    }
+
+    async loadPlayers(filePath = "./AquaPlayers.json") {
+        if (!fs.existsSync(filePath)) {
+            this.emit("debug", "Aqua", `No player data found at ${filePath}`);
+            return;
+        }
         try {
-            if (player.connection) {
-                try {
-                    await player.destroy()
-                    player.connection = null;
-                } catch (error) {
-                    console.error(`Error disconnecting player connection: ${error.message}`);
+            await this.waitForFirstNode();
+            const data = await fs.readJSON(filePath);
+            for (const playerData of data) {
+                const { guildId, textChannel, voiceChannel, track, volume, paused, requester } = playerData;
+                let player = this.players.get(guildId);
+
+                if (!player) {
+                    player = await this.createConnection({
+                        guildId: guildId,
+                        textChannel: textChannel,
+                        voiceChannel: voiceChannel,
+                        defaultVolume: volume || 65,
+                        deaf: true
+                    });
+                }
+
+                if (track && player) {
+                    const resolved = await this.resolve({ query: track.uri, requester });
+                    if (resolved.tracks && resolved.tracks.length > 0) {
+                        player.queue.add(resolved.tracks[0]);
+                        player.position = track.position || 0;
+                    } else {
+                        this.emit("debug", "Aqua", `Could not resolve track for guild ${guildId}: ${track.uri}`);
+                    }
+                }
+
+                if (player) {
+                    player.paused = paused || false;
+                    if (!player.playing && !player.paused && player.queue.size > 0) {
+                        player.play();
+                    }
                 }
             }
-            
-            this.players.delete(player.guildId);
-            this.emit("playerCleanup", player.guildId);
+            this.emit("debug", "Aqua", `Loaded players from ${filePath}`);
+        } catch (error) {
+            console.error(`Failed to load players from ${filePath}:`, error);
+        }
+    }
+
+    async cleanupPlayer(player) {
+        if (!player) return;
+
+        try {
+            await player.destroy();
         } catch (error) {
             console.error(`Error during player cleanup: ${error.message}`);
         }

package/build/structures/Node.js

@@ -96,7 +96,7 @@ class Node {
             this.aqua.emit("nodeConnected", this);
 
             if (this.autoResume && this.sessionId) {
-                await this.resumePlayers();
+                await this.aqua.loadPlayers();
             }
         } catch (err) {
             this.info = null;
@@ -245,13 +245,33 @@ class Node {
     }
 
     async getStats() {
-        if (this.connected) {
+        
+        if (this.connected && this.stats) {
             return this.stats;
         }
 
         try {
             const newStats = await this.rest.getStats();
-            Object.assign(this.stats, newStats);
+            if (newStats && this.stats) {
+                this.stats.players = newStats.players ?? this.stats.players;
+                this.stats.playingPlayers = newStats.playingPlayers ?? this.stats.playingPlayers;
+                this.stats.uptime = newStats.uptime ?? this.stats.uptime;
+                this.stats.ping = newStats.ping ?? this.stats.ping;
+                
+                if (newStats.memory) {
+                    Object.assign(this.stats.memory, newStats.memory);
+                    this._calculateMemoryPercentages();
+                }
+                
+                if (newStats.cpu) {
+                    Object.assign(this.stats.cpu, newStats.cpu);
+                    this._calculateCpuPercentages();
+                }
+                
+                if (newStats.frameStats) {
+                    Object.assign(this.stats.frameStats, newStats.frameStats);
+                }
+            }
             return this.stats;
         } catch (err) {
             this.emitError(`Failed to fetch node stats: ${err.message}`);
@@ -269,13 +289,12 @@ class Node {
 
         if (payload.memory) {
             Object.assign(this.stats.memory, payload.memory);
-            this.stats.memory.freePercentage = (this.stats.memory.free / this.stats.memory.allocated) * 100;
-            this.stats.memory.usedPercentage = (this.stats.memory.used / this.stats.memory.allocated) * 100;
+            this._calculateMemoryPercentages();
         }
 
         if (payload.cpu) {
             Object.assign(this.stats.cpu, payload.cpu);
-            this.stats.cpu.lavalinkLoadPercentage = (this.stats.cpu.lavalinkLoad / this.stats.cpu.cores) * 100;
+            this._calculateCpuPercentages();
         }
 
         if (payload.frameStats) {
@@ -283,6 +302,21 @@ class Node {
         }
     }
 
+    _calculateMemoryPercentages() {
+        const { memory } = this.stats;
+        if (memory.allocated > 0) {
+            memory.freePercentage = (memory.free / memory.allocated) * 100;
+            memory.usedPercentage = (memory.used / memory.allocated) * 100;
+        }
+    }
+
+    _calculateCpuPercentages() {
+        const { cpu } = this.stats;
+        if (cpu.cores > 0) {
+            cpu.lavalinkLoadPercentage = (cpu.lavalinkLoad / cpu.cores) * 100;
+        }
+    }
+
     _handleReadyOp(payload) {
         if (!payload.sessionId) {
             this.emitError("Ready payload missing sessionId");
@@ -297,10 +331,7 @@ class Node {
 
     async resumePlayers() {
         try {
-            await this.rest.makeRequest("PATCH", `/v4/sessions/${this.sessionId}`, {
-                resuming: true,
-                timeout: this.resumeTimeout
-            });
+            await this.aqua.loadPlayers();
 
             this.aqua.emit("debug", this.name, "Session resumed successfully");
         } catch (err) {

package/build/structures/Player.js

@@ -62,6 +62,7 @@ class Player extends EventEmitter {
             this.position = packet.state.position;
             this.connected = packet.state.connected;
             this.ping = packet.state.ping;
+            this.timestamp = packet.state.timestamp;
 
             this.aqua.emit("playerUpdate", this, packet);
         });
@@ -184,18 +185,18 @@ class Player extends EventEmitter {
         return this.batchUpdatePlayer({ track: { encoded: this.current.track } }, true);
     }
 
-    connect({ deaf = true, mute = false } = {}) {
+    connect(options = this) {
+        const { guildId, voiceChannel, deaf = true, mute = false } = options;
         this.deaf = deaf;
         this.mute = mute;
-        const payload = {
-            guild_id: this.guildId,
-            channel_id: this.voiceChannel,
+        this.send({
+            guild_id: guildId,
+            channel_id: voiceChannel,
             self_deaf: deaf,
-            self_mute: mute
-        };
-        this.send(payload);
+            self_mute: mute,
+        });
         this.connected = true;
-        this.aqua.emit("debug", this.guildId, `Player connected to voice channel: ${this.voiceChannel}.`);
+        this.aqua.emit("debug", guildId, `Player connected to voice channel: ${voiceChannel}.`);
         return this;
     }
 
@@ -288,7 +289,13 @@ class Player extends EventEmitter {
         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, mute: this.mute });
+        this.connect({
+            deaf: this.deaf,
+            guildId: this.guildId,
+            voiceChannel: this.voiceChannel,
+            textChannel: this.textChannel,
+            mute: this.mute,
+        });
         return this;
     }
 

package/build/structures/Track.js

@@ -10,6 +10,7 @@ class Track {
     this.identifier = info.identifier || '';
     this.isSeekable = Boolean(info.isSeekable);
     this.author = info.author || '';
+    this.position = info.position || 0;
     this.length = info.length || 0;
     this.duration = info.length || 0;
     this.isStream = Boolean(info.isStream);
@@ -29,6 +30,7 @@ class Track {
     return {
       identifier: this.identifier,
       isSeekable: this.isSeekable,
+      position: this.position,
       author: this.author,
       length: this.length,
       isStream: this.isStream,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.6.1-fix3",
+  "version": "2.6.2",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",
@@ -42,6 +42,7 @@
   },
   "dependencies": {
     "ws": "^8.18.2",
+    "fs-extra": "^11.3.0",
 		"tseep": "^1.3.1"
   },
   "maintainers": [