aqualink 3.1.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}`
@@ -138,6 +141,7 @@ class Node {
     this.reconnectTimeoutId = null
     this.isDestroyed = false
     this._isConnecting = false
+    this._connectPromise = null
     this.isNodelink = false
 
     this._wsIsBun = !!process.isBun
@@ -162,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(() => {})
       }
     })
   }
@@ -307,7 +311,7 @@ class Node {
     if (
       code !== Node.WS_CLOSE_NORMAL &&
       code !== 1001 &&
-      !isFatal &&
+      isFatal &&
       this.sessionId
     ) {
       this._clearSession()
@@ -393,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
@@ -415,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?.()
@@ -511,6 +586,7 @@ class Node {
       this._bunCleanup = null
     } else {
       ws.removeAllListeners?.()
+      ws.on?.('error', _functions.noop)
     }
 
     try {
@@ -531,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?.()
@@ -792,7 +870,7 @@ class Node {
 
   _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) {

package/build/structures/Player.js

@@ -35,6 +35,7 @@ const EVENT_HANDLERS = Object.freeze({
   PlayerDestroyedEvent: 'playerDestroyed',
   LyricsNotFoundEvent: 'lyricsNotFound',
   MixStartedEvent: 'mixStarted',
+  PlayerReconnectingEvent: 'PlayerReconnectingEvent',
   MixEndedEvent: 'mixEnded'
 })
 
@@ -957,22 +958,24 @@ class Player extends EventEmitter {
     const prev = this.previous
     const info = prev?.info
     if (!info?.sourceName || !info.identifier) return this
-    const { sourceName, identifier, uri, author } = info
+    const { sourceName, identifier, uri, author, title } = info
     this.isAutoplay = true
 
-    if (sourceName === 'spotify' && info.identifier) {
-      this.previousIdentifiers.add(info.identifier)
-      if (this.previousIdentifiers.size > PREVIOUS_IDS_MAX) {
-        this.previousIdentifiers.delete(
-          this.previousIdentifiers.values().next().value
-        )
-      }
-      if (!this.autoplaySeed) {
-        this.autoplaySeed = {
-          trackId: identifier,
-          artistIds: Array.isArray(author) ? author.join(',') : author
+    if (sourceName === 'spotify') {
+      if (info.identifier && info.identifier !== 'local') {
+        this.previousIdentifiers.add(info.identifier)
+        if (this.previousIdentifiers.size > PREVIOUS_IDS_MAX) {
+          this.previousIdentifiers.delete(
+            this.previousIdentifiers.values().next().value
+          )
         }
       }
+      this.autoplaySeed = {
+        trackId: identifier,
+        isrc: prev.isrc || null,
+        title: title || null,
+        author: author || null
+      }
     }
 
     for (
@@ -1020,27 +1023,45 @@ class Player extends EventEmitter {
   }
 
   async _getAutoplayTrack(sourceName, identifier, uri, requester) {
+    const seen = new Set(this.previousIdentifiers)
+    const prevId = this.current?.identifier
+    if (prevId) seen.add(prevId)
+
     if (sourceName === 'youtube' || sourceName === 'ytmusic') {
       const res = await this.aqua.resolve({
         query: `https://www.youtube.com/watch?v=${identifier}&list=RD${identifier}`,
         source: 'ytmsearch',
         requester
       })
-      return _functions.isInvalidLoad(res)
-        ? null
+      if (_functions.isInvalidLoad(res) || !res.tracks?.length) return null
+      const candidates = res.tracks.filter(
+        (t) => t.identifier && !seen.has(t.identifier)
+      )
+      return candidates.length
+        ? candidates[_functions.randIdx(candidates.length)]
         : res.tracks[_functions.randIdx(res.tracks.length)]
     }
     if (sourceName === 'soundcloud') {
-      const scRes = await scAutoPlay(uri)
+      const scRes = await scAutoPlay(uri, this.nodes?.rest?._autoplayAgent)
       if (!scRes?.length) return null
-      const res = await this.aqua.resolve({
-        query: scRes[0],
-        source: 'scsearch',
-        requester
-      })
-      return _functions.isInvalidLoad(res)
-        ? null
-        : res.tracks[_functions.randIdx(res.tracks.length)]
+
+      let anyValid = null
+      for (const link of scRes) {
+        const res = await this.aqua.resolve({
+          query: link,
+          source: 'scsearch',
+          requester
+        })
+        if (_functions.isInvalidLoad(res) || !res.tracks?.length) continue
+        if (!anyValid)
+          anyValid = res.tracks[_functions.randIdx(res.tracks.length)]
+        const candidates = res.tracks.filter(
+          (t) => t.identifier && !seen.has(t.identifier)
+        )
+        if (candidates.length)
+          return candidates[_functions.randIdx(candidates.length)]
+      }
+      return anyValid
     }
     if (sourceName === 'spotify') {
       const res = await spAutoPlay(
@@ -1171,6 +1192,16 @@ class Player extends EventEmitter {
   mixEnded(_p, t, payload) {
     _functions.emitIfActive(this, AqualinkEvents.MixEnded, t, payload)
   }
+  PlayerReconnectingEvent(_p, _t, payload) {
+    this._resuming = true
+    _functions.emitIfActive(
+      this,
+      AqualinkEvents.PlayerReconnectingEvent,
+      payload
+    )
+    this.connection?.resendVoiceUpdate?.(true)
+    this.aqua.emit(AqualinkEvents.PlayerReconnect, this, { resuming: true })
+  }
 
   async _attemptVoiceResume(abortSignal) {
     return this._lifecycleController.attemptVoiceResume(abortSignal)

package/build/structures/PlayerLifecycle.js

@@ -241,6 +241,11 @@ class PlayerLifecycle {
     }
 
     const code = payload?.code
+    if (code === 4014) {
+      await player._delay(150)
+      if (player.destroyed) return
+    }
+
     if (code === 4006 && player._resuming) {
       if (player.aqua?.debugTrace) {
         player.aqua._trace('player.socketClosed.ignored', {
@@ -253,7 +258,10 @@ class PlayerLifecycle {
     }
 
     let isRecoverable = [4015, 4009, 4006, 4014, 4022].includes(code)
-    if (code === 4014 && player.connection?.isWaitingForDisconnect)
+    if (
+      code === 4014 &&
+      (player.connection?.isWaitingForDisconnect || !player.voiceChannel)
+    )
       isRecoverable = false
 
     if (code === 4015 && !player.nodes?.info?.isNodelink) {
@@ -452,6 +460,7 @@ class PlayerLifecycle {
         if (
           latestActivePlayer &&
           latestActivePlayer !== player &&
+          latestActivePlayer !== np &&
           !latestActivePlayer.destroyed
         ) {
           try {

package/build/structures/Reporting.js

@@ -26,7 +26,19 @@ function reportSuppressedError(target, scope, error, data = null) {
   return err
 }
 
+function emitOperationalError(target, source, error) {
+  const aqua = getAqua(target)
+  const err = normalizeError(error)
+  if (aqua?.listenerCount?.(AqualinkEvents.Error) > 0) {
+    aqua.emit(AqualinkEvents.Error, source, err)
+  } else if (aqua?.debugTrace) {
+    aqua._trace('aqua.error.unhandled', { error: err.message })
+  }
+  return err
+}
+
 module.exports = {
+  emitOperationalError,
   normalizeError,
   reportSuppressedError
 }