aqualink 3.0.0 → 3.2.0

package/build/structures/Node.js

@@ -5,6 +5,7 @@ const WebSocketImpl = process.isBun ? globalThis.WebSocket : require('ws')
 
 const Rest = require('./Rest')
 const { AqualinkEvents } = require('./AqualinkEvents')
+const { emitOperationalError } = require('./Reporting')
 
 const privateData = new WeakMap()
 
@@ -36,6 +37,8 @@ const unrefTimer = (t) => {
 }
 
 const _functions = {
+  noop() {},
+
   buildWsUrl(host, port, ssl) {
     const needsBrackets = host.includes(':') && !host.startsWith('[')
     return `ws${ssl ? 's' : ''}://${needsBrackets ? `[${host}]` : host}:${port}${WS_PATH}`
@@ -80,6 +83,16 @@ const _functions = {
 
   errMsg(err) {
     return err?.message || String(err)
+  },
+
+  statusCode(err) {
+    return (
+      err?.statusCode ||
+      err?.status ||
+      err?.response?.statusCode ||
+      err?.response?.status ||
+      null
+    )
   }
 }
 
@@ -128,6 +141,7 @@ class Node {
     this.reconnectTimeoutId = null
     this.isDestroyed = false
     this._isConnecting = false
+    this._connectPromise = null
     this.isNodelink = false
 
     this._wsIsBun = !!process.isBun
@@ -152,7 +166,7 @@ class Node {
         error: this._handleError.bind(this),
         message: this._handleMessage.bind(this),
         close: this._handleClose.bind(this),
-        connect: this.connect.bind(this)
+        connect: () => this.connect().catch(() => {})
       }
     })
   }
@@ -205,7 +219,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)
       }
@@ -289,7 +311,7 @@ class Node {
     if (
       code !== Node.WS_CLOSE_NORMAL &&
       code !== 1001 &&
-      !isFatal &&
+      isFatal &&
       this.sessionId
     ) {
       this._clearSession()
@@ -375,16 +397,17 @@ class Node {
   }
 
   connect() {
-    if (this.isDestroyed || this._isConnecting) return
+    if (this.isDestroyed) return Promise.reject(new Error('Node is destroyed'))
+    if (this._connectPromise) return this._connectPromise
 
     const state = this.ws?.readyState
     if (state === WS_STATES.OPEN) {
       this._emitDebug('WebSocket already connected')
-      return
+      return Promise.resolve()
     }
     if (state === WS_STATES.CONNECTING || state === WS_STATES.CLOSING) {
       this._emitDebug('WebSocket is connecting/closing; skipping new connect')
-      return
+      return Promise.reject(new Error('WebSocket is closing'))
     }
 
     this._isConnecting = true
@@ -397,95 +420,165 @@ class Node {
       })
     }
 
-    try {
-      const h = this._boundHandlers
-
-      if (this._wsIsBun) {
-        const ws = new WebSocketImpl(this.wsUrl, { headers: this._headers })
-        ws.binaryType = 'arraybuffer'
-
-        const offs = []
-        const add = (type, fn, once = false) => {
-          const wrapped = once
-            ? (ev) => {
-                try {
-                  ws.removeEventListener(type, wrapped)
-                } catch {}
-                fn(ev)
-              }
-            : fn
-          ws.addEventListener(type, wrapped)
-          offs.push(() => {
-            try {
-              ws.removeEventListener(type, wrapped)
-            } catch {}
-          })
+    let connectPromise
+    connectPromise = new Promise((resolve, reject) => {
+      let settled = false
+      let opened = false
+      let timer = null
+      const settle = (ok, error) => {
+        if (settled) return
+        settled = true
+        if (timer) clearTimeout(timer)
+        queueMicrotask(() => {
+          if (this._connectPromise === connectPromise)
+            this._connectPromise = null
+        })
+        this._rejectConnect = null
+        ok ? resolve() : reject(error)
+      }
+      timer = setTimeout(() => {
+        const error = new Error(`WebSocket open timeout: ${this.timeout}ms`)
+        this._isConnecting = false
+        this._cleanup()
+        settle(false, error)
+        this._scheduleReconnect()
+      }, this.timeout)
+      unrefTimer(timer)
+      this._rejectConnect = (error) => settle(false, error)
+
+      try {
+        const h = this._boundHandlers
+        const onOpen = () => {
+          opened = true
+          h.open()
+          settle(true)
+        }
+        const onError = (error) => {
+          h.error(error)
+          if (!opened) {
+            this._isConnecting = false
+            this._cleanup()
+            settle(false, error)
+            this._scheduleReconnect()
+          }
+        }
+        const onClose = (code, reason) => {
+          if (!opened) {
+            settle(
+              false,
+              new Error(
+                `WebSocket closed before open (code ${code}): ${_functions.reasonToString(reason)}`
+              )
+            )
+          }
+          h.close(code, reason)
         }
 
-        add('open', () => h.open(), true)
+        if (this._wsIsBun) {
+          const ws = new WebSocketImpl(this.wsUrl, { headers: this._headers })
+          ws.binaryType = 'arraybuffer'
+
+          const offs = []
+          const add = (type, fn, once = false) => {
+            const wrapped = once
+              ? (ev) => {
+                  try {
+                    ws.removeEventListener(type, wrapped)
+                  } catch {}
+                  fn(ev)
+                }
+              : fn
+            ws.addEventListener(type, wrapped)
+            offs.push(() => {
+              try {
+                ws.removeEventListener(type, wrapped)
+              } catch {}
+            })
+          }
 
-        add(
-          'error',
-          (event) => {
-            const err = event?.error
-            h.error(err instanceof Error ? err : new Error('WebSocket error'))
-          },
-          true
-        )
+          add('open', onOpen, true)
 
-        add('message', (event) => {
-          const data = event?.data
-          if (typeof data === 'string') h.message(data, false)
-          else h.message(data, true)
-        })
+          add(
+            'error',
+            (event) => {
+              const err = event?.error
+              onError(err instanceof Error ? err : new Error('WebSocket error'))
+            },
+            false
+          )
 
-        add(
-          'close',
-          (event) => {
-            h.close(
-              typeof event?.code === 'number'
-                ? event.code
-                : Node.WS_CLOSE_NORMAL,
-              typeof event?.reason === 'string' ? event.reason : ''
-            )
-          },
-          true
-        )
+          add('message', (event) => {
+            const data = event?.data
+            if (typeof data === 'string') h.message(data, false)
+            else h.message(data, true)
+          })
 
-        this._bunCleanup = () => {
-          for (let i = 0; i < offs.length; i++) offs[i]()
-        }
-        this.ws = ws
-        return
-      }
+          add(
+            'close',
+            (event) => {
+              onClose(
+                typeof event?.code === 'number'
+                  ? event.code
+                  : Node.WS_CLOSE_NORMAL,
+                typeof event?.reason === 'string' ? event.reason : ''
+              )
+            },
+            true
+          )
 
-      const ws = new WebSocketImpl(this.wsUrl, {
-        headers: this._headers,
-        perMessageDeflate: false,
-        handshakeTimeout: this.timeout,
-        maxPayload: this.maxPayload,
-        skipUTF8Validation: this.skipUTF8Validation
-      })
+          this._bunCleanup = () => {
+            for (let i = 0; i < offs.length; i++) offs[i]()
+          }
+          this.ws = ws
+          return
+        }
 
-      ws.binaryType = 'nodebuffer'
+        const ws = new WebSocketImpl(this.wsUrl, {
+          headers: this._headers,
+          perMessageDeflate: false,
+          handshakeTimeout: this.timeout,
+          maxPayload: this.maxPayload,
+          skipUTF8Validation: this.skipUTF8Validation
+        })
 
-      ws.once('open', h.open)
-      ws.once('error', h.error)
-      ws.on('message', h.message)
-      ws.once('close', h.close)
+        ws.once('open', () => {
+          onOpen()
+          this._wsPingInterval = setInterval(() => {
+            if (ws.readyState === WS_STATES.OPEN) ws.ping?.()
+          }, 30000)
+          this._wsPingInterval.unref?.()
+        })
+        ws.on('error', onError)
+        ws.on('message', h.message)
+        ws.once('close', (...args) => {
+          if (this._wsPingInterval) {
+            clearInterval(this._wsPingInterval)
+            this._wsPingInterval = null
+          }
+          onClose(...args)
+        })
 
-      this.ws = ws
-    } catch (err) {
-      this._isConnecting = false
-      this._emitError(`Failed to create WebSocket: ${_functions.errMsg(err)}`)
-      this._scheduleReconnect()
-    }
+        this.ws = ws
+      } catch (err) {
+        this._isConnecting = false
+        this._emitError(`Failed to create WebSocket: ${_functions.errMsg(err)}`)
+        settle(false, err)
+        this._scheduleReconnect()
+      }
+    })
+    this._connectPromise = connectPromise
+    return connectPromise
   }
 
   _cleanup() {
     const ws = this.ws
     if (!ws) return
 
+    if (this._wsPingInterval) {
+      clearInterval(this._wsPingInterval)
+      this._wsPingInterval = null
+    }
+
     if (this._wsIsBun) {
       try {
         this._bunCleanup?.()
@@ -493,6 +586,7 @@ class Node {
       this._bunCleanup = null
     } else {
       ws.removeAllListeners?.()
+      ws.on?.('error', _functions.noop)
     }
 
     try {
@@ -513,15 +607,17 @@ class Node {
     if (this.isDestroyed) return
 
     this.isDestroyed = true
+    this._rejectConnect?.(new Error('Node destroyed while connecting'))
     this.state = NODE_STATE.IDLE
     this._isConnecting = false
+    this._connectPromise = null
     this._clearReconnectTimeout()
     this._cleanup()
 
     if (!clean) this.aqua.handleNodeFailover?.(this)
 
     this.connected = false
-    this.aqua.destroyNode?.(this.name)
+    this.aqua._destroyNode?.(this.name)
     this.aqua.emit(AqualinkEvents.NodeDestroy, this)
 
     this.rest?.destroy?.()
@@ -592,8 +688,8 @@ 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
     if (this.aqua?.debugTrace) {
@@ -607,9 +703,9 @@ class Node {
     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)
@@ -618,6 +714,15 @@ class Node {
           `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) {
@@ -650,7 +755,8 @@ class Node {
 
     this.aqua.emit(AqualinkEvents.NodeReady, this, {
       resumed: !!payload.resumed,
-      sessionChanged
+      sessionChanged,
+      sessionInvalidated
     })
 
     if (this.autoResume) {
@@ -672,63 +778,99 @@ class Node {
       })
     }
 
+    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
-          ) {
-              try {
-                const recoveryToken = player._claimVoiceRecovery?.(
-                  'node_resume_rejoin'
-                )
-                this._emitDebug(`Rejoining voice for guild ${guildId} on resume`)
-                if (this.aqua?.debugTrace) {
-                  this.aqua._trace('node.resume.rejoin', {
-                    node: this.name,
-                    guildId,
-                    voiceChannel: player.voiceChannel
-                  })
-                }
-                if (player._isVoiceRecoveryActive?.(recoveryToken))
-                  player.connect({
-                    voiceChannel: player.voiceChannel,
-                    deaf: player.deaf,
-                    mute: player.mute
-                  })
+    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`)
+              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) {
-      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.loadPlayers && this.aqua.players.size === 0) {
+      await this.aqua.loadPlayers()
     }
   }
 
   _emitError(error) {
     const errorObj = error instanceof Error ? error : new Error(String(error))
-    this.aqua.emit(AqualinkEvents.Error, this, errorObj)
+    emitOperationalError(this.aqua, this, errorObj)
   }
 
   _emitDebug(message) {