aqualink 2.7.0 → 2.7.2

package/build/structures/Aqua.js

@@ -4,7 +4,7 @@ const Player = require("./Player");
 const Track = require("./Track");
 const { version: pkgVersion } = require("../../package.json");
 const { EventEmitter } = require('tseep');
-const fs = require('fs-extra');
+const fs = require('fs/promises');
 
 const URL_REGEX = /^https?:\/\//;
 const DEFAULT_OPTIONS = Object.freeze({
@@ -57,13 +57,21 @@ class Aqua extends EventEmitter {
         this.send = this.options.send || this.defaultSendFunction.bind(this);
 
         this._leastUsedCache = { nodes: [], timestamp: 0 };
-        
+
         this._nodeStates = new Map();
         this._failoverQueue = new Map();
         this._lastFailoverAttempt = new Map();
-        
+
+        this._brokenPlayers = new Map();
+        this._nodeReconnectHandlers = new Map();
+
         this._boundCleanupPlayer = this.cleanupPlayer.bind(this);
         this._boundHandlePlayerDestroy = this._handlePlayerDestroy.bind(this);
+        this._boundHandleNodeReconnect = this._handleNodeReconnect.bind(this);
+        this._boundHandleSocketClosed = this._handleSocketClosed.bind(this);
+
+        this.on('nodeConnect', (node) => this._handleNodeReconnect(node));
+        this.on('nodeDisconnect', (node) => this._handleSocketClosed(node));
     }
 
     defaultSendFunction(packet) {
@@ -100,16 +108,16 @@ class Aqua extends EventEmitter {
                 console.error(`Failed to create node ${node.name || node.host}:`, err);
                 return null;
             }));
-            
+
             const results = await Promise.allSettled(nodePromises);
             const successfulNodes = results.filter(r => r.status === 'fulfilled' && r.value).length;
-            
+
             if (successfulNodes === 0) {
                 throw new Error("No nodes could be connected");
             }
 
-            await Promise.all(this.plugins.map(plugin => 
-                Promise.resolve(plugin.load(this)).catch(err => 
+            await Promise.all(this.plugins.map(plugin =>
+                Promise.resolve(plugin.load(this)).catch(err =>
                     console.error("Plugin load error:", err)
                 )
             ));
@@ -128,6 +136,7 @@ class Aqua extends EventEmitter {
         this.destroyNode(nodeId);
 
         const node = new Node(this, options, this.options);
+        node.players = new Set();
         this.nodeMap.set(nodeId, node);
         this._invalidateCache();
 
@@ -144,6 +153,116 @@ class Aqua extends EventEmitter {
         }
     }
 
+    async _handleNodeReconnect(node) {
+        if (!this.autoResume) return;
+
+        const nodeId = node.name || node.host;
+        this.emit("debug", "Aqua", `Node ${nodeId} reconnected, attempting to rebuild broken players`);
+
+        this._nodeStates.set(nodeId, { connected: true, failoverInProgress: false });
+
+        await this._rebuildBrokenPlayers(node);
+    }
+
+    async _handleSocketClosed(node) {
+        if (!this.autoResume) return;
+
+        const nodeId = node.name || node.host;
+        this.emit("debug", "Aqua", `Socket closed for node ${nodeId}, storing broken players`);
+
+        this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
+
+        await this._storeBrokenPlayersForNode(node);
+    }
+
+    async _storeBrokenPlayersForNode(node) {
+        const nodeId = node.name || node.host;
+        const affectedPlayers = await this._getPlayersForNode(node);
+
+
+        for (const player of affectedPlayers) {
+            try {
+                const playerState = this._capturePlayerState(player);
+                if (playerState) {
+                    playerState.originalNodeId = nodeId;
+                    playerState.brokenAt = Date.now();
+                    this._brokenPlayers.set(player.guildId, playerState);
+
+                    this.emit("debug", "Aqua", `Stored broken player state for guild ${player.guildId}`);
+                }
+            } catch (error) {
+                this.emit("error", null, new Error(`Failed to store broken player state: ${error.message}`));
+            }
+        }
+    }
+
+    async _getPlayersForNode(node) {
+        const affectedPlayers = [];
+        for (const player of this.players.values()) {
+            if (player.nodes === node || player.nodes?.name === node.name) {
+                affectedPlayers.push(player);
+            }
+        }
+        return affectedPlayers;
+    }
+
+    async _rebuildBrokenPlayers(node) {
+        const nodeId = node.name || node.host;
+        const rebuiltCount = 0;
+
+
+
+        for (const [guildId, brokenState] of this._brokenPlayers.entries()) {
+            if (brokenState.originalNodeId !== nodeId) continue;
+            try {
+                await this._rebuildPlayer(brokenState, node);
+                this._brokenPlayers.delete(guildId);
+                rebuiltCount++;
+
+
+                this.emit("debug", "Aqua", `Successfully rebuilt player for guild ${guildId}`);
+            } catch (error) {
+                this.emit("error", null, new Error(`Failed to rebuild player for guild ${guildId}: ${error.message}`));
+
+                if (Date.now() - brokenState.brokenAt > 300000) {
+                    this._brokenPlayers.delete(guildId);
+                }
+            }
+        }
+
+        if (rebuiltCount > 0) {
+            this.emit("playersRebuilt", node, rebuiltCount);
+        }
+    }
+
+    async _rebuildPlayer(brokenState, targetNode) {
+        const { guildId, textChannel, voiceChannel, current, volume = 65, deaf = true } = brokenState;
+
+        const connectionOptions = { guildId, textChannel, voiceChannel, defaultVolume: volume, deaf };
+        const existingPlayer = this.players.get(guildId);
+
+        if (existingPlayer) {
+            await existingPlayer.destroy();
+        }
+
+        setTimeout(async () => {
+            const newestPlayer = await this.createConnection(connectionOptions);
+            this.players.set(guildId, newestPlayer);
+
+            if (current) {
+                try {
+                    await newestPlayer.queue.add(current);
+                    await newestPlayer.play();
+                } catch (error) {
+                    console.error("Error while playing track:", error);
+                }
+            }
+
+            this.emit("trackStart", newestPlayer, brokenState.current);
+            return newestPlayer;
+        }, 2000);
+    }
+
     destroyNode(identifier) {
         const node = this.nodeMap.get(identifier);
         if (!node) return;
@@ -153,6 +272,11 @@ class Aqua extends EventEmitter {
     }
 
     _cleanupNode(nodeId) {
+        const node = this.nodeMap.get(nodeId);
+        if (node) {
+            node.removeAllListeners();
+        }
+
         this.nodeMap.delete(nodeId);
         this._nodeStates.delete(nodeId);
         this._failoverQueue.delete(nodeId);
@@ -166,10 +290,10 @@ class Aqua extends EventEmitter {
 
     async handleNodeFailover(failedNode) {
         if (!this.failoverOptions.enabled) return;
-        
+
         const nodeId = failedNode.name || failedNode.host;
         const now = Date.now();
-        
+
         const nodeState = this._nodeStates.get(nodeId);
         if (nodeState?.failoverInProgress) return;
 
@@ -182,11 +306,11 @@ class Aqua extends EventEmitter {
         this._nodeStates.set(nodeId, { connected: false, failoverInProgress: true });
         this._lastFailoverAttempt.set(nodeId, now);
         this._failoverQueue.set(nodeId, currentAttempts + 1);
-        
+
         try {
             this.emit("nodeFailover", failedNode);
-            
-            const affectedPlayers = this._getPlayersForNode(failedNode);
+
+            const affectedPlayers = Array.from(failedNode.players);
             if (affectedPlayers.length === 0) {
                 this._nodeStates.set(nodeId, { connected: false, failoverInProgress: false });
                 return;
@@ -200,14 +324,14 @@ class Aqua extends EventEmitter {
             }
 
             const failoverResults = await this._migratePlayersWithRetry(affectedPlayers, availableNodes);
-            
+
             const successful = failoverResults.filter(r => r.success).length;
             const failed = failoverResults.length - successful;
-            
+
             if (successful > 0) {
                 this.emit("nodeFailoverComplete", failedNode, successful, failed);
             }
-            
+
         } catch (error) {
             this.emit("error", null, new Error(`Failover failed for node ${nodeId}: ${error.message}`));
         } finally {
@@ -215,25 +339,9 @@ class Aqua extends EventEmitter {
         }
     }
 
-    _getPlayersForNode(node) {
-        const affectedPlayers = [];
-        for (const player of this.players.values()) {
-            if (player.nodes === node || player.nodes?.name === node.name) {
-                affectedPlayers.push(player);
-            }
-        }
-        return affectedPlayers;
-    }
-
-    _getAvailableNodesForFailover(failedNode) {
-        return this.leastUsedNodes.filter(node => 
-            node !== failedNode && node.name !== failedNode.name
-        );
-    }
-
     async _migratePlayersWithRetry(players, availableNodes) {
         const results = [];
-        
+
         const concurrency = 3;
         for (let i = 0; i < players.length; i += concurrency) {
             const batch = players.slice(i, i + concurrency);
@@ -246,11 +354,11 @@ class Aqua extends EventEmitter {
                     return { player, success: false, error };
                 }
             });
-            
+
             const batchResults = await Promise.allSettled(batchPromises);
             results.push(...batchResults.map(r => r.value || r.reason));
         }
-        
+
         return results;
     }
 
@@ -261,7 +369,7 @@ class Aqua extends EventEmitter {
 
         const guildId = player.guildId;
         let retryCount = 0;
-        
+
         while (retryCount < this.failoverOptions.maxRetries) {
             try {
                 const targetNode = this._selectBestNode(availableNodes, player);
@@ -274,15 +382,14 @@ class Aqua extends EventEmitter {
                 if (!newPlayer) throw new Error("Failed to create player on target node");
 
                 await this._restorePlayerState(newPlayer, playerState);
-                
-                newPlayer.destroy();
+
                 if (playerState.current) {
                     newPlayer.queue.add(playerState.current);
                 }
-                
+
                 this.emit("playerMigrated", player, newPlayer, targetNode);
                 return newPlayer;
-                
+
             } catch (error) {
                 retryCount++;
                 if (retryCount < this.failoverOptions.maxRetries) {
@@ -296,12 +403,12 @@ class Aqua extends EventEmitter {
 
     _selectBestNode(availableNodes, player) {
         if (player.region) {
-            const regionNode = availableNodes.find(node => 
+            const regionNode = availableNodes.find(node =>
                 node.regions?.includes(player.region.toLowerCase())
             );
             if (regionNode) return regionNode;
         }
-        
+
         return availableNodes[0];
     }
 
@@ -316,13 +423,12 @@ class Aqua extends EventEmitter {
                 position: player.position || 0,
                 current: player.current ? { ...player.current } : null,
                 queue: player.queue?.tracks ? [...player.queue.tracks] : [],
-                repeat: player.repeat,
+                repeat: player.loop,
                 shuffle: player.shuffle,
                 deaf: player.deaf || false,
                 mute: player.mute || false,
-                region: player.region,
-                requester: player.requester,
-                timestamp: Date.now()
+                timestamp: Date.now(),
+                connected: player.connected || false,
             };
         } catch (error) {
             return null;
@@ -347,40 +453,35 @@ class Aqua extends EventEmitter {
         if (!newPlayer || !playerState) return;
 
         try {
-            // Batch operations where possible
             const operations = [];
-            
+
             if (playerState.volume !== undefined) {
                 operations.push(newPlayer.setVolume(playerState.volume));
             }
 
-            // Restore queue efficiently
             if (playerState.queue?.length > 0) {
                 newPlayer.queue.add(...playerState.queue);
             }
 
-            // Wait for all operations
             await Promise.all(operations);
 
-            // Handle current track restoration
             if (playerState.current && this.failoverOptions.preservePosition) {
                 newPlayer.queue.unshift(playerState.current);
-                
+
                 if (this.failoverOptions.resumePlayback) {
                     await newPlayer.play();
-                    
+
                     if (playerState.position > 0) {
-                        await this._delay(300); // Reduced delay
+                        await this._delay(300);
                         await newPlayer.seek(playerState.position);
                     }
-                    
+
                     if (playerState.paused) {
                         await newPlayer.pause();
                     }
                 }
             }
 
-            // Restore other properties
             Object.assign(newPlayer, {
                 repeat: playerState.repeat,
                 shuffle: playerState.shuffle
@@ -395,7 +496,6 @@ class Aqua extends EventEmitter {
         return new Promise(resolve => setTimeout(resolve, ms));
     }
 
-    // Optimized cleanup
     async cleanupPlayer(player) {
         if (!player) return;
         try {
@@ -434,7 +534,6 @@ class Aqua extends EventEmitter {
             }
         }
 
-        // Optimized sorting with caching
         const loadCache = new Map();
         regionNodes.sort((a, b) => {
             const loadA = loadCache.get(a) ?? (loadCache.set(a, this._calculateLoad(a)), loadCache.get(a));
@@ -469,7 +568,6 @@ class Aqua extends EventEmitter {
         const player = new Player(this, node, options);
         this.players.set(options.guildId, player);
 
-        // Use pre-bound method for better performance
         player.once("destroy", this._boundHandlePlayerDestroy);
         player.connect(options);
         this.emit("playerCreate", player);
@@ -477,6 +575,10 @@ class Aqua extends EventEmitter {
     }
 
     _handlePlayerDestroy(player) {
+        const node = player.nodes;
+        if (node && node.players) {
+            node.players.delete(player);
+        }
         this.players.delete(player.guildId);
         this.emit("playerDestroy", player);
     }
@@ -557,7 +659,7 @@ class Aqua extends EventEmitter {
                     baseResponse.tracks.push(new Track(response.data, requester, requestNode));
                 }
                 break;
-                
+
             case "playlist": {
                 const info = response.data?.info;
                 if (info) {
@@ -604,42 +706,50 @@ class Aqua extends EventEmitter {
         }
     }
 
-    // Optimized save/load methods
     async savePlayer(filePath = "./AquaPlayers.json") {
-        const data = Array.from(this.players.values(), player => ({
-            g: player.guildId,
-            t: player.textChannel,
-            v: player.voiceChannel,
-            u: player.current?.uri || null,
-            p: player.position || 0,
-            ts: player.timestamp || 0,
-            q: player.queue?.tracks?.slice(0, 5).map(tr => tr.uri) || [],
-            r: player.requester || player.current?.requester,
-            vol: player.volume,
-            pa: player.paused,
-            n: player.nodes?.name || null
-        }));
-        
+        const data = Array.from(this.players.values()).map(player => {
+            const requester = player.requester || player.current?.requester;
+
+            return {
+                g: player.guildId,
+                t: player.textChannel,
+                v: player.voiceChannel,
+                u: player.current?.uri || null,
+                p: player.position || 0,
+                ts: player.timestamp || 0,
+                q: player.queue?.tracks?.map(tr => tr.uri).slice(0, 5) || [],
+                r: requester ? {
+                    id: requester.id,
+                    username: requester.username,
+                    globalName: requester.globalName,
+                    discriminator: requester.discriminator,
+                    avatar: requester.avatar
+                } : null,
+                vol: player.volume,
+                pa: player.paused,
+                isPlaying: !!player.current && !player.paused
+            };
+        });
+
         await fs.writeFile(filePath, JSON.stringify(data), "utf8");
+        this.emit("debug", "Aqua", `Saved ${data.length} players to ${filePath}`);
     }
 
     async loadPlayers(filePath = "./AquaPlayers.json") {
         try {
             await fs.access(filePath);
             await this._waitForFirstNode();
-            
+
             const data = JSON.parse(await fs.readFile(filePath, "utf8"));
-            
-            // Process in batches to avoid overwhelming
+
             const batchSize = 5;
             for (let i = 0; i < data.length; i += batchSize) {
                 const batch = data.slice(i, i + batchSize);
                 await Promise.all(batch.map(p => this._restorePlayer(p)));
             }
-            
+
             await fs.writeFile(filePath, "[]", "utf8");
         } catch (error) {
-            // Silent fail if file doesn't exist
         }
     }
 
@@ -647,11 +757,11 @@ class Aqua extends EventEmitter {
         try {
             let player = this.players.get(p.g);
             if (!player) {
-                const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ? 
+                const targetNode = (p.n && this.nodeMap.get(p.n)?.connected) ?
                     this.nodeMap.get(p.n) : this.leastUsedNodes[0];
-                
+
                 if (!targetNode) return;
-                
+
                 player = await this.createConnection({
                     guildId: p.g,
                     textChannel: p.t,
@@ -661,7 +771,6 @@ class Aqua extends EventEmitter {
                 });
             }
 
-            // Restore current track
             if (p.u && player) {
                 const resolved = await this.resolve({ query: p.u, requester: p.r });
                 if (resolved.tracks?.[0]) {
@@ -670,13 +779,12 @@ class Aqua extends EventEmitter {
                     if (typeof p.ts === "number") player.timestamp = p.ts;
                 }
             }
-            
-            // Restore queue
+
             if (p.q?.length && player) {
                 const queuePromises = p.q
                     .filter(uri => uri !== p.u)
                     .map(uri => this.resolve({ query: uri, requester: p.r }));
-                
+
                 const queueResults = await Promise.allSettled(queuePromises);
                 queueResults.forEach(result => {
                     if (result.status === 'fulfilled' && result.value.tracks?.[0]) {
@@ -684,21 +792,20 @@ class Aqua extends EventEmitter {
                     }
                 });
             }
-            
+
             if (player) {
                 player.paused = !!p.pa;
-                if (!player.playing && !player.paused && player.queue.size > 0) {
+                if ((p.isPlaying || (p.pa && p.u)) && player.queue.size > 0) {
                     player.play();
                 }
             }
         } catch (error) {
-            // Silent fail for individual player restoration
         }
     }
 
     async _waitForFirstNode() {
         if (this.leastUsedNodes.length > 0) return;
-        
+
         return new Promise(resolve => {
             const checkInterval = setInterval(() => {
                 if (this.leastUsedNodes.length > 0) {
@@ -709,6 +816,44 @@ class Aqua extends EventEmitter {
         });
     }
 
+    // Auto-resume utility methods
+    getBrokenPlayersCount() {
+        return this._brokenPlayers.size;
+    }
+
+    getBrokenPlayers() {
+        return Array.from(this._brokenPlayers.entries()).map(([guildId, state]) => ({
+            guildId,
+            originalNodeId: state.originalNodeId,
+            brokenAt: state.brokenAt,
+            hasCurrentTrack: !!state.current,
+            queueSize: state.queue?.length || 0
+        }));
+    }
+
+    clearBrokenPlayers() {
+        this._brokenPlayers.clear();
+    }
+
+    async forceBrokenPlayerRebuild(guildId) {
+        const brokenState = this._brokenPlayers.get(guildId);
+        if (!brokenState) return false;
+
+        try {
+            const targetNode = this.nodeMap.get(brokenState.originalNodeId) || this.leastUsedNodes[0];
+            if (!targetNode || !targetNode.connected) {
+                throw new Error("No available nodes for rebuild");
+            }
+
+            await this._rebuildPlayer(brokenState, targetNode);
+            this._brokenPlayers.delete(guildId);
+            return true;
+        } catch (error) {
+            this.emit("error", null, new Error(`Failed to force rebuild player for guild ${guildId}: ${error.message}`));
+            return false;
+        }
+    }
+
     // Utility methods
     resetFailoverAttempts(nodeId) {
         this._failoverQueue.delete(nodeId);
@@ -747,15 +892,15 @@ class Aqua extends EventEmitter {
         }
         return stats;
     }
-    
+
     async forceFailover(nodeIdentifier) {
         const node = this.nodeMap.get(nodeIdentifier);
         if (!node) return;
-        
+
         if (node.connected) {
             await node.destroy();
         }
-        
+
         this._cleanupNode(nodeIdentifier);
     }
 }

package/build/structures/Node.js

@@ -52,7 +52,11 @@ class Node {
         this.reconnectAttempted = 0;
         this.reconnectTimeoutId = null;
         this.isDestroyed = false;
-        this.lastHealthCheck = Date.now();
+
+        this._onOpen = this._onOpen.bind(this);
+        this._onError = this._onError.bind(this);
+        this._onMessage = this._onMessage.bind(this);
+        this._onClose = this._onClose.bind(this);
 
         this._headers = this._constructHeaders();
         this.initializeStats();
@@ -87,7 +91,6 @@ class Node {
     async _onOpen() {
         this.connected = true;
         this.reconnectAttempted = 0;
-        this.lastHealthCheck = Date.now();
         this.aqua.emit("debug", this.name, "WebSocket connection established");
 
         if (this.aqua.bypassChecks?.nodeFetchInfo) return;
@@ -118,30 +121,26 @@ class Node {
             return;
         }
 
-        const op = payload?.op;
+        const { op, guildId } = payload;
         if (!op) return;
 
-        this.lastHealthCheck = Date.now();
-
-        if (op === "stats") {
-            this._updateStats(payload);
-            return;
-        }
-        if (op === "ready") {
-            this._handleReadyOp(payload);
-            return;
-        }
 
-        if (op.startsWith("Lyrics")) {
-            const player = payload.guildId ? this.aqua.players.get(payload.guildId) : null;
-            const track = payload.track || null;
-            this.aqua.emit(op, player, track, payload);
-            return;
-        }
-
-        if (payload.guildId) {
-            const player = this.aqua.players.get(payload.guildId);
-            if (player) player.emit(op, payload);
+        switch (op) {
+            case "stats":
+                this._updateStats(payload);
+                break;
+            case "ready":
+                this._handleReadyOp(payload);
+                break;
+            default:
+                if (op.startsWith("Lyrics")) {
+                    const player = guildId ? this.aqua.players.get(guildId) : null;
+                    this.aqua.emit(op, player, payload.track || null, payload);
+                } else if (guildId) {
+                    const player = this.aqua.players.get(guildId);
+                    player?.emit(op, payload);
+                }
+                break;
         }
     }
 
@@ -202,7 +201,7 @@ class Node {
 
     async connect() {
         if (this.isDestroyed) return;
-        
+
         if (this.ws && this.ws.readyState === Node.WS_OPEN) {
             this.aqua.emit("debug", this.name, "WebSocket already connected");
             return;
@@ -215,10 +214,11 @@ class Node {
             perMessageDeflate: false
         });
 
-        this.ws.once("open", this._onOpen.bind(this));
-        this.ws.once("error", this._onError.bind(this));
-        this.ws.on("message", this._onMessage.bind(this));
-        this.ws.once("close", this._onClose.bind(this));
+        this.ws.once("open", this._onOpen);
+        this.ws.once("error", this._onError);
+        this.ws.on("message", this._onMessage);
+        this.ws.once("close", this._onClose);
+
     }
 
     cleanupExistingConnection() {
@@ -264,17 +264,17 @@ class Node {
                 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);
                 }

package/build/structures/Player.js

@@ -458,7 +458,7 @@ class Player extends EventEmitter {
             try {
                 await this.nowPlayingMessage.delete();
             } catch (error) {
-                console.error("Error deleting now playing message:", error);
+                // Ignore
             } finally {
                 this.nowPlayingMessage = null;
             }

package/package.json

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