aqualink 2.20.1 → 3.1.0

package/build/structures/Node.js

@@ -80,6 +80,16 @@ const _functions = {
 
   errMsg(err) {
     return err?.message || String(err)
+  },
+
+  statusCode(err) {
+    return (
+      err?.statusCode ||
+      err?.status ||
+      err?.response?.statusCode ||
+      err?.response?.status ||
+      null
+    )
   }
 }
 
@@ -102,10 +112,10 @@ class Node {
     this.host = connOptions.host || 'localhost'
     this.name = connOptions.name || this.host
     this.port = connOptions.port || 2333
-    this.auth = connOptions.auth || 'youshallnotpass'
+    this.auth = connOptions.auth || connOptions.password || 'youshallnotpass'
     this.sessionId = connOptions.sessionId || null
     this.regions = connOptions.regions || []
-    this.ssl = !!connOptions.ssl
+    this.ssl = !!connOptions.ssl || !!connOptions.secure || false
     this.wsUrl = _functions.buildWsUrl(this.host, this.port, this.ssl)
 
     this.rest = new Rest(aqua, this)
@@ -187,10 +197,12 @@ class Node {
     this._isConnecting = false
     this.reconnectAttempted = 0
     this._emitDebug('WebSocket connection established')
-    this.aqua?._trace?.('node.ws.open', {
-      node: this.name,
-      reconnectAttempted: this.reconnectAttempted
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('node.ws.open', {
+        node: this.name,
+        reconnectAttempted: this.reconnectAttempted
+      })
+    }
 
     if (!this.aqua?.bypassChecks?.nodeFetchInfo && !this.info) {
       const timeoutId = setTimeout(() => {
@@ -203,7 +215,15 @@ class Node {
         this.isNodelink = !!this.info?.isNodelink
       } catch (err) {
         this.info = null
-        this._emitError(`Failed to fetch node info: ${_functions.errMsg(err)}`)
+        if (_functions.statusCode(err) === 404) {
+          this._emitDebug(
+            'Node info endpoint unavailable (HTTP 404); continuing without remote info'
+          )
+        } else {
+          this._emitError(
+            `Failed to fetch node info: ${_functions.errMsg(err)}`
+          )
+        }
       } finally {
         clearTimeout(timeoutId)
       }
@@ -272,12 +292,14 @@ class Node {
       code,
       reason: _functions.reasonToString(reason)
     })
-    this.aqua?._trace?.('node.ws.close', {
-      node: this.name,
-      code,
-      reason: _functions.reasonToString(reason),
-      hasSessionId: !!this.sessionId
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('node.ws.close', {
+        node: this.name,
+        code,
+        reason: _functions.reasonToString(reason),
+        hasSessionId: !!this.sessionId
+      })
+    }
 
     if (this.isDestroyed) return
 
@@ -311,11 +333,13 @@ class Node {
     this._clearReconnectTimeout()
 
     const attempt = ++this.reconnectAttempted
-    this.aqua?._trace?.('node.ws.reconnect.scheduled', {
-      node: this.name,
-      attempt,
-      infinite: !!this.infiniteReconnects
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('node.ws.reconnect.scheduled', {
+        node: this.name,
+        attempt,
+        infinite: !!this.infiniteReconnects
+      })
+    }
 
     if (this.infiniteReconnects) {
       this.aqua.emit(AqualinkEvents.NodeReconnect, this, {
@@ -384,10 +408,12 @@ class Node {
     this._isConnecting = true
     this.state = NODE_STATE.CONNECTING
     this._cleanup()
-    this.aqua?._trace?.('node.ws.connect', {
-      node: this.name,
-      url: this.wsUrl
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('node.ws.connect', {
+        node: this.name,
+        url: this.wsUrl
+      })
+    }
 
     try {
       const h = this._boundHandlers
@@ -453,7 +479,7 @@ class Node {
 
       const ws = new WebSocketImpl(this.wsUrl, {
         headers: this._headers,
-        perMessageDeflate: true,
+        perMessageDeflate: false,
         handshakeTimeout: this.timeout,
         maxPayload: this.maxPayload,
         skipUTF8Validation: this.skipUTF8Validation
@@ -584,36 +610,66 @@ class Node {
     }
 
     const oldSessionId = this.sessionId
-    const sessionChanged =
-      oldSessionId && oldSessionId !== sessionId && !payload.resumed
+    const sessionInvalidated = !payload.resumed && !!oldSessionId
+    const sessionChanged = sessionInvalidated && oldSessionId !== sessionId
 
     this.sessionId = sessionId
-    this.aqua?._trace?.('node.ready.packet', {
-      node: this.name,
-      resumed: !!payload.resumed,
-      oldSessionId,
-      newSessionId: sessionId
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('node.ready.packet', {
+        node: this.name,
+        resumed: !!payload.resumed,
+        oldSessionId,
+        newSessionId: sessionId
+      })
+    }
     this.rest.setSessionId(sessionId)
     this._headers['Session-Id'] = sessionId
 
-    if (sessionChanged && this.aqua?.players) {
+    if (sessionInvalidated && this.aqua?.players) {
       this._emitDebug(
-        `Session changed from ${oldSessionId} to ${sessionId}, invalidating stale players`
+        `Session invalidated (resumed=${!!payload.resumed}, old=${oldSessionId}, new=${sessionId}), invalidating stale players`
       )
+      try {
+        await this.aqua._storeBrokenPlayers?.(this)
+      } catch (e) {
+        this._emitDebug(
+          `Failed to snapshot stale players before invalidation: ${e?.message || e}`
+        )
+      }
+      for (const [, player] of this.aqua.players) {
+        if (player?.nodes === this || player?.nodes?.name === this.name) {
+          if (player.connection) {
+            player.connection._lastEndpoint = null
+            player.connection._stateFlags |= 512
+          }
+        }
+      }
+
       const playersToDestroy = []
       for (const [guildId, player] of this.aqua.players) {
         if (player?.nodes === this || player?.nodes?.name === this.name) {
-          playersToDestroy.push(guildId)
+          playersToDestroy.push({ guildId, player })
         }
       }
-      for (const guildId of playersToDestroy) {
+      for (const { guildId, player } of playersToDestroy) {
         try {
-          this._emitDebug(`Destroying stale player for guild ${guildId}`)
-          await this.aqua.destroyPlayer(guildId)
+          this._emitDebug(
+            `Invalidating stale player for guild ${guildId} without voice disconnect`
+          )
+          player?.destroy?.({
+            preserveClient: true,
+            skipRemote: true,
+            preserveMessage: true,
+            preserveTracks: true,
+            preserveReconnecting: true
+          })
+          if (this.aqua.players.get(String(guildId)) === player) {
+            this.aqua.players.delete(String(guildId))
+          }
+          this.players?.delete?.(player)
         } catch (e) {
           this._emitDebug(
-            `Failed to destroy stale player ${guildId}: ${e?.message || e}`
+            `Failed to invalidate stale player ${guildId}: ${e?.message || e}`
           )
         }
       }
@@ -621,7 +677,8 @@ class Node {
 
     this.aqua.emit(AqualinkEvents.NodeReady, this, {
       resumed: !!payload.resumed,
-      sessionChanged
+      sessionChanged,
+      sessionInvalidated
     })
 
     if (this.autoResume) {
@@ -635,55 +692,101 @@ class Node {
 
   async _resumePlayers() {
     if (!this.sessionId) return
-    this.aqua?._trace?.('node.resume.begin', {
-      node: this.name,
-      sessionId: this.sessionId,
-      players: this.aqua?.players?.size || 0
-    })
+    if (this.aqua?.debugTrace) {
+      this.aqua._trace('node.resume.begin', {
+        node: this.name,
+        sessionId: this.sessionId,
+        players: this.aqua?.players?.size || 0
+      })
+    }
 
+    let resumeSupported = true
     try {
       await this.rest.makeRequest('PATCH', `/v4/sessions/${this.sessionId}`, {
         resuming: true,
         timeout: this.resumeTimeout
       })
+    } catch (err) {
+      if (_functions.statusCode(err) === 404) {
+        resumeSupported = false
+        this._emitDebug(
+          'Session resume endpoint unavailable (HTTP 404); falling back without server-side session resume'
+        )
+      } else {
+        if (this.aqua?.debugTrace) {
+          this.aqua._trace('node.resume.error', {
+            node: this.name,
+            error: _functions.errMsg(err)
+          })
+        }
+        this._emitError(`Failed to resume session: ${_functions.errMsg(err)}`)
+        throw err
+      }
+    }
 
-      if (this.aqua?.players) {
-        for (const [guildId, player] of this.aqua.players) {
-          if (
-            (player?.nodes === this || player?.nodes?.name === this.name) &&
-            player.voiceChannel
-          ) {
+    if (!resumeSupported) {
+      try {
+        const existingPlayers = await this.rest.getPlayers()
+        if (Array.isArray(existingPlayers) && existingPlayers.length === 0) {
+          this._emitDebug(
+            'No players found on Lavalink for this session; will rejoin voice only'
+          )
+        }
+      } catch (_) {
+        // getPlayers may also 404 — that's fine, we already know session is invalid
+      }
+    }
+
+    if (this.aqua?.players) {
+      const PLAYER_BATCH_SIZE = 20
+      const playersToResume = []
+      for (const [guildId, player] of this.aqua.players) {
+        if (
+          (player?.nodes === this || player?.nodes?.name === this.name) &&
+          player.voiceChannel &&
+          !player.destroyed
+        ) {
+          playersToResume.push({ guildId, player })
+        }
+      }
+
+      for (let i = 0; i < playersToResume.length; i += PLAYER_BATCH_SIZE) {
+        const batch = playersToResume.slice(i, i + PLAYER_BATCH_SIZE)
+        await Promise.allSettled(
+          batch.map(async ({ guildId, player }) => {
             try {
+              const recoveryToken = player._claimVoiceRecovery?.(
+                resumeSupported
+                  ? 'node_resume_rejoin'
+                  : 'node_rejoin_after_resume_404'
+              )
               this._emitDebug(`Rejoining voice for guild ${guildId} on resume`)
-              this.aqua?._trace?.('node.resume.rejoin', {
-                node: this.name,
-                guildId,
-                voiceChannel: player.voiceChannel
-              })
-              player.connect({
-                voiceChannel: player.voiceChannel,
-                deaf: player.deaf,
-                mute: player.mute
-              })
+              if (this.aqua?.debugTrace) {
+                this.aqua._trace('node.resume.rejoin', {
+                  node: this.name,
+                  guildId,
+                  voiceChannel: player.voiceChannel,
+                  resumeSupported
+                })
+              }
+              if (player._isVoiceRecoveryActive?.(recoveryToken))
+                player.connect({
+                  voiceChannel: player.voiceChannel,
+                  deaf: player.deaf,
+                  mute: player.mute
+                })
             } catch (e) {
               this._emitDebug(
                 `Failed to rejoin voice for ${guildId}: ${e?.message || e}`
               )
             }
-          }
-        }
+          })
+        )
       }
+    }
 
-      if (this.aqua.loadPlayers && this.aqua.players.size === 0) {
-        await this.aqua.loadPlayers()
-      }
-    } catch (err) {
-      this.aqua?._trace?.('node.resume.error', {
-        node: this.name,
-        error: _functions.errMsg(err)
-      })
-      this._emitError(`Failed to resume session: ${_functions.errMsg(err)}`)
-      throw err
+    if (this.aqua.loadPlayers && this.aqua.players.size === 0) {
+      await this.aqua.loadPlayers()
     }
   }