aqualink 2.20.0 → 3.0.0

package/build/structures/ConnectionRecovery.js

@@ -0,0 +1,398 @@
+const { AqualinkEvents } = require('./AqualinkEvents')
+const { reportSuppressedError } = require('./Reporting')
+
+class ConnectionRecovery {
+  constructor(connection, deps) {
+    this.connection = connection
+    this._functions = deps._functions
+    this.STATE = deps.STATE
+    this.RECONNECT_DELAY = deps.RECONNECT_DELAY
+    this.MAX_RECONNECT_ATTEMPTS = deps.MAX_RECONNECT_ATTEMPTS
+    this.RESUME_BACKOFF_MAX = deps.RESUME_BACKOFF_MAX
+  }
+
+  setServerUpdate(data) {
+    const conn = this.connection
+    if (conn._destroyed || !data?.token) return
+
+    const endpoint =
+      typeof data.endpoint === 'string' ? data.endpoint.trim() : ''
+    if (!endpoint) return
+
+    if (conn._lastEndpoint === endpoint && conn.token === data.token) return
+    if (data.txId && data.txId < conn.txId) return
+
+    conn._stateGeneration++
+
+    if (conn._lastEndpoint !== endpoint) {
+      conn.sequence = 0
+      conn._lastEndpoint = endpoint
+      conn._reconnectAttempts = 0
+      conn._consecutiveFailures = 0
+      conn._regionMigrationAttempted = false
+    }
+
+    conn.endpoint = endpoint
+    conn.region = this._functions.extractRegion(endpoint)
+    conn.token = data.token
+    conn.channelId = data.channel_id || conn.channelId || conn.voiceChannel
+    conn._lastVoiceDataUpdate = Date.now()
+    if (conn._aqua?.debugTrace) {
+      conn._aqua._trace('connection.serverUpdate', {
+        guildId: conn._guildId,
+        endpoint: conn.endpoint,
+        region: conn.region,
+        txId: data.txId || null
+      })
+    }
+    conn._stateFlags &= ~this.STATE.VOICE_DATA_STALE
+
+    const migrated = this.checkRegionMigration()
+    if (migrated) return
+    conn._scheduleVoiceUpdate()
+    conn._player?._flushDeferredPlay?.()
+  }
+
+  checkRegionMigration() {
+    const conn = this.connection
+    if (conn._destroyed || conn._regionMigrationAttempted) return false
+    if (
+      !conn._aqua?.autoRegionMigrate ||
+      !conn.region ||
+      conn.region === 'unknown'
+    )
+      return false
+
+    const player = conn._player
+    if (!player || player.destroyed || player._resuming || player._reconnecting)
+      return false
+
+    const currentNode = player.nodes
+    if (!currentNode) return false
+
+    const currentRegions = Array.isArray(currentNode.regions)
+      ? currentNode.regions
+      : []
+    const alreadyMatching = currentRegions.some((r) =>
+      conn._aqua._regionMatches?.(r, conn.region)
+    )
+    if (alreadyMatching) {
+      conn._regionMigrationAttempted = true
+      return false
+    }
+
+    const targetNode = conn._aqua._findBestNodeForRegion?.(conn.region)
+    if (!targetNode || targetNode === currentNode) return false
+
+    conn._regionMigrationAttempted = true
+    if (conn._aqua?.debugTrace) {
+      conn._aqua._trace('connection.region.migrate', {
+        guildId: conn._guildId,
+        region: conn.region,
+        from: currentNode?.name || currentNode?.host,
+        to: targetNode?.name || targetNode?.host
+      })
+    }
+
+    queueMicrotask(() => {
+      conn._aqua
+        .movePlayerToNode?.(conn._guildId, targetNode, 'region')
+        .catch((error) => {
+          conn._regionMigrationAttempted = false
+          reportSuppressedError(
+            conn._aqua,
+            'connection.region.migrate',
+            error,
+            {
+              guildId: conn._guildId,
+              region: conn.region
+            }
+          )
+        })
+    })
+    return true
+  }
+
+  async attemptResume() {
+    const conn = this.connection
+    if (!conn._canAttemptResumeCore()) return false
+    if (conn._aqua?.debugTrace) {
+      conn._aqua._trace('connection.resume.attempt', {
+        guildId: conn._guildId,
+        reconnectAttempts: conn._reconnectAttempts,
+        hasSessionId: !!conn.sessionId,
+        hasEndpoint: !!conn.endpoint,
+        hasToken: !!conn.token
+      })
+    }
+
+    const currentGen = conn._stateGeneration
+    if (
+      !conn.sessionId ||
+      !conn.endpoint ||
+      !conn.token ||
+      conn._stateFlags & this.STATE.VOICE_DATA_STALE
+    ) {
+      const now = Date.now()
+      if (now - (conn._lastResumeBlockedLogAt || 0) >= 5000) {
+        conn._lastResumeBlockedLogAt = now
+        conn._aqua.emit(
+          AqualinkEvents.Debug,
+          `Resume blocked: missing voice data for guild ${conn._guildId}, requesting voice state`
+        )
+      }
+      conn._requestVoiceState()
+      return false
+    }
+
+    conn.txId = conn._player.txId || conn.txId
+    conn._stateFlags |= this.STATE.ATTEMPTING_RESUME
+    conn._reconnectAttempts++
+    conn._aqua.emit(
+      AqualinkEvents.Debug,
+      `Attempt resume: guild=${conn._guildId} endpoint=${conn.endpoint} session=${conn.sessionId}`
+    )
+
+    const payload = sharedPool.acquire()
+    try {
+      this._functions.fillVoicePayload(
+        payload,
+        conn._guildId,
+        conn,
+        conn._player,
+        true
+      )
+
+      if (conn._stateGeneration !== currentGen) {
+        conn._aqua.emit(
+          AqualinkEvents.Debug,
+          `Resume aborted: State changed during attempt for guild ${conn._guildId}`
+        )
+        return false
+      }
+
+      await this.sendUpdate(payload)
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.resume.success', {
+          guildId: conn._guildId
+        })
+      }
+
+      conn._reconnectAttempts = 0
+      conn._consecutiveFailures = 0
+      if (conn._player) conn._player._resuming = false
+
+      conn._aqua.emit(
+        AqualinkEvents.Debug,
+        `Resume PATCH sent for guild ${conn._guildId}`
+      )
+      return true
+    } catch (error) {
+      if (conn._destroyed || !conn._aqua) throw error
+      conn._consecutiveFailures++
+      conn._aqua.emit(
+        AqualinkEvents.Debug,
+        `Resume failed for guild ${conn._guildId}: ${error?.message || error}`
+      )
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.resume.error', {
+          guildId: conn._guildId,
+          error: error?.message || String(error)
+        })
+      }
+
+      if (
+        conn._reconnectAttempts < this.MAX_RECONNECT_ATTEMPTS &&
+        !conn._destroyed &&
+        conn._consecutiveFailures < 5
+      ) {
+        const delay = Math.min(
+          this.RECONNECT_DELAY * (1 << (conn._reconnectAttempts - 1)),
+          this.RESUME_BACKOFF_MAX
+        )
+        conn._setReconnectTimer(delay)
+      } else {
+        conn._aqua.emit(
+          AqualinkEvents.Debug,
+          `Max reconnect attempts/failures reached for guild ${conn._guildId}`
+        )
+        if (conn._player) conn._player._resuming = false
+        conn._handleDisconnect()
+      }
+      return false
+    } finally {
+      conn._stateFlags &= ~this.STATE.ATTEMPTING_RESUME
+      sharedPool.release(payload)
+    }
+  }
+
+  async recoverMissingPlayer(isSessionError) {
+    const conn = this.connection
+    if (conn._destroyed || !conn._player || conn._missingPlayerRecovering)
+      return false
+
+    const now = Date.now()
+    if (now - conn._lastMissingPlayerRecoverAt < 5000) return false
+
+    conn._missingPlayerRecovering = true
+    conn._lastMissingPlayerRecoverAt = now
+    if (conn._aqua?.debugTrace) {
+      conn._aqua._trace('connection.playerMissing.recover.start', {
+        guildId: conn._guildId,
+        isSessionError: !!isSessionError
+      })
+    }
+
+    try {
+      const recoveryToken = conn._player._claimVoiceRecovery?.(
+        'missing_player_recover'
+      )
+      if (isSessionError && conn._player?.nodes?._clearSession) {
+        conn._player.nodes._clearSession()
+      }
+
+      if (conn._player?._isVoiceRecoveryActive?.(recoveryToken))
+        conn._requestVoiceState()
+      const resumed = await this.attemptResume().catch((error) => {
+        reportSuppressedError(
+          conn._aqua,
+          'connection.playerMissing.resume',
+          error,
+          {
+            guildId: conn._guildId
+          }
+        )
+        return false
+      })
+      if (resumed) {
+        conn._player?._clearVoiceRecovery?.(recoveryToken, 'missing_player_resumed')
+      } else if (conn._player?._isVoiceRecoveryActive?.(recoveryToken)) {
+        conn.resendVoiceUpdate(true)
+      }
+
+      if (conn._player.playing && conn._player.current?.track) {
+        const data = {
+          track: { encoded: conn._player.current.track },
+          paused: !!conn._player.paused
+        }
+        if (conn._player.position > 0) data.position = conn._player.position
+        await conn._rest.updatePlayer({
+          guildId: conn._guildId,
+          data,
+          noReplace: false
+        })
+      }
+
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.playerMissing.recover.ok', {
+          guildId: conn._guildId,
+          resumed: !!resumed,
+          playing: !!conn._player.playing
+        })
+      }
+      return true
+    } catch (error) {
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.playerMissing.recover.error', {
+          guildId: conn._guildId,
+          error: error?.message || String(error)
+        })
+      }
+      return false
+    } finally {
+      conn._missingPlayerRecovering = false
+    }
+  }
+
+  async sendUpdate(payload) {
+    const conn = this.connection
+    if (conn._destroyed) throw new Error('Connection destroyed')
+    if (!conn._rest) throw new Error('REST interface unavailable')
+
+    try {
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.update.send', {
+          guildId: conn._guildId,
+          hasSessionId: !!conn._rest?.sessionId,
+          hasVoice:
+            !!payload?.data?.voice?.sessionId &&
+            !!payload?.data?.voice?.endpoint
+        })
+      }
+      await conn._rest.updatePlayer(payload)
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.update.ok', {
+          guildId: conn._guildId
+        })
+      }
+    } catch (error) {
+      if (conn._aqua?.debugTrace) {
+        conn._aqua._trace('connection.update.error', {
+          guildId: conn._guildId,
+          statusCode: error?.statusCode || error?.response?.statusCode || null,
+          error: error?.message || String(error)
+        })
+      }
+      if (error.statusCode === 404 || error.response?.statusCode === 404) {
+        const isSessionError =
+          error.body?.message?.includes('sessionId') || false
+        const recovered = await this.recoverMissingPlayer(isSessionError)
+        if (recovered) return
+
+        if (conn._aqua) {
+          conn._aqua.emit(
+            AqualinkEvents.Debug,
+            `[Aqua/Connection] Player ${conn._guildId} not found (404)${isSessionError ? ' - Session invalid' : ''}. Recovery failed, destroying.`
+          )
+          await conn._aqua.destroyPlayer(conn._guildId)
+        }
+        throw error
+      }
+      if (!this._functions.isNetworkError(error)) {
+        conn._aqua.emit(
+          AqualinkEvents.Debug,
+          new Error(`Voice update failed: ${error?.message || error}`)
+        )
+      }
+      throw error
+    }
+  }
+}
+
+class PayloadPool {
+  constructor() {
+    this._pool = []
+    this._size = 0
+  }
+
+  _create() {
+    return {
+      guildId: null,
+      data: {
+        voice: {
+          token: null,
+          endpoint: null,
+          sessionId: null
+        },
+        volume: null
+      }
+    }
+  }
+
+  acquire() {
+    return this._size > 0 ? this._pool[--this._size] : this._create()
+  }
+
+  release(payload) {
+    if (!payload || this._size >= 12) return
+    payload.guildId = null
+    const v = payload.data.voice
+    v.token = v.endpoint = v.sessionId = null
+    payload.data.volume = null
+    this._pool[this._size++] = payload
+  }
+}
+
+const sharedPool = new PayloadPool()
+
+module.exports = ConnectionRecovery

package/build/structures/Filters.js

@@ -27,6 +27,7 @@ const FILTER_DEFAULTS = Object.freeze({
   }),
   lowPass: Object.freeze({ smoothing: 20 })
 })
+const { reportSuppressedError } = require('./Reporting')
 
 const FILTER_KEYS = Object.freeze(
   Object.fromEntries(
@@ -38,6 +39,7 @@ const FILTER_KEYS = Object.freeze(
 )
 
 const EMPTY_ARRAY = Object.freeze([])
+const EMPTY_OBJECT = Object.freeze({})
 
 const FILTER_POOL_SIZE = 16
 const filterPool = {
@@ -88,6 +90,27 @@ const _utils = Object.freeze({
     return !arr || arr.length === 0
   },
 
+  objectEqual(a, b) {
+    if (a === b) return true
+    const keysA = a ? Object.keys(a) : EMPTY_ARRAY
+    const keysB = b ? Object.keys(b) : EMPTY_ARRAY
+    if (keysA.length !== keysB.length) return false
+    for (let i = 0; i < keysA.length; i++) {
+      const key = keysA[i]
+      if (!(key in b) || a[key] !== b[key]) return false
+    }
+    return true
+  },
+
+  normalizePluginFilters(filters) {
+    if (!filters || typeof filters !== 'object') return null
+    const entries = Object.entries(filters).filter(
+      ([key, value]) => key && value && typeof value === 'object'
+    )
+    if (!entries.length) return null
+    return Object.fromEntries(entries)
+  },
+
   makeEqArray(len, gain) {
     const out = new Array(len)
     for (let i = 0; i < len; i++) out[i] = { band: i, gain }
@@ -125,7 +148,8 @@ class Filters {
       rotation: options.rotation ?? null,
       distortion: options.distortion ?? null,
       channelMix: options.channelMix ?? null,
-      lowPass: options.lowPass ?? null
+      lowPass: options.lowPass ?? null,
+      pluginFilters: _utils.normalizePluginFilters(options.pluginFilters)
     }
 
     this.presets = {
@@ -140,6 +164,7 @@ class Filters {
   destroy() {
     for (const [key, value] of Object.entries(this.filters)) {
       if (value && typeof value === 'object' && key !== 'equalizer') {
+        if (key === 'pluginFilters') continue
         filterPool.release(key, value)
       }
     }
@@ -182,7 +207,11 @@ class Filters {
     queueMicrotask(() => {
       this._pendingUpdate = false
       if (this.player) {
-        this.updateFilters().catch(() => {})
+        this.updateFilters().catch((error) =>
+          reportSuppressedError(this.player, 'filters.update', error, {
+            guildId: this.player.guildId
+          })
+        )
       }
     })
     return this
@@ -221,6 +250,37 @@ class Filters {
     return this._setFilter('lowPass', enabled, options)
   }
 
+  setPluginFilters(filters) {
+    const next = _utils.normalizePluginFilters(filters)
+    if (_utils.objectEqual(this.filters.pluginFilters, next)) return this
+    this.filters.pluginFilters = next
+    this._dirty.add('pluginFilters')
+    return this._scheduleUpdate()
+  }
+
+  setPluginFilter(name, config) {
+    if (!name || typeof name !== 'string')
+      throw new TypeError('Plugin filter name is required')
+
+    if (!config || typeof config !== 'object') {
+      if (!this.filters.pluginFilters?.[name]) return this
+      const next = { ...this.filters.pluginFilters }
+      delete next[name]
+      return this.setPluginFilters(next)
+    }
+
+    const current = this.filters.pluginFilters || EMPTY_OBJECT
+    if (current[name] === config) return this
+    return this.setPluginFilters({ ...current, [name]: config })
+  }
+
+  clearPluginFilters() {
+    if (!this.filters.pluginFilters) return this
+    this.filters.pluginFilters = null
+    this._dirty.add('pluginFilters')
+    return this._scheduleUpdate()
+  }
+
   setBassboost(enabled, options = {}) {
     if (!enabled) {
       if (
@@ -317,12 +377,19 @@ class Filters {
     for (let i = 0; i < filterNames.length; i++) {
       const key = filterNames[i]
       if (f[key] !== null) {
+        if (key !== 'pluginFilters') filterPool.release(key, f[key])
         f[key] = null
         this._dirty.add(key)
         changed = true
       }
     }
 
+    if (f.pluginFilters !== null) {
+      f.pluginFilters = null
+      this._dirty.add('pluginFilters')
+      changed = true
+    }
+
     for (const key in this.presets) {
       if (this.presets[key] !== null) this.presets[key] = null
     }
@@ -333,17 +400,31 @@ class Filters {
   async updateFilters() {
     if (!this.player || !this._dirty.size) return this
 
-    const payload = {}
-    for (const key of this._dirty) {
-      payload[key] = this.filters[key]
+    const dirtyKeys = [...this._dirty]
+    const dirtySet = new Set(dirtyKeys)
+    const payload = {
+      volume: this.filters.volume,
+      equalizer: this.filters.equalizer
+    }
+    const filterNames = Object.keys(FILTER_DEFAULTS)
+    for (let i = 0; i < filterNames.length; i++) {
+      const key = filterNames[i]
+      if (this.filters[key] !== null) payload[key] = this.filters[key]
+      else if (dirtySet.has(key)) payload[key] = null
+    }
+    payload.pluginFilters = this.filters.pluginFilters || {}
+
+    for (const key of dirtyKeys) this._dirty.delete(key)
+
+    try {
+      await this.player.nodes.rest.updatePlayer({
+        guildId: this.player.guildId,
+        data: { filters: payload }
+      })
+    } catch (error) {
+      for (const key of dirtyKeys) this._dirty.add(key)
+      throw error
     }
-
-    this._dirty.clear()
-
-    await this.player.nodes.rest.updatePlayer({
-      guildId: this.player.guildId,
-      data: { filters: payload }
-    })
     return this
   }
 }