aqualink 3.1.0 → 3.2.0

package/build/index.js

@@ -51,9 +51,9 @@ const VoiceRegion = Object.freeze({
   CanadaToronto: 'yyz',
   CanadaMontreal: 'ymq',
 
-  Brazil: 'gru' || 'brazil', // i only know this endpoint lol.
-  Chile: 'scl' || 'chile',
-  Argentina: 'eze' || 'argentina'
+  Brazil: 'gru', // i only know this endpoint lol.
+  Chile: 'scl',
+  Argentina: 'eze'
 })
 
 module.exports = {

package/build/structures/Aqua.js

@@ -1,4 +1,4 @@
-const fs = require('node:fs')
+const fs = require('node:fs')
 const path = require('node:path')
 const _readline = require('node:readline')
 const { EventEmitter } = require('node:events')
@@ -7,7 +7,7 @@ const AquaRecovery = require('./AquaRecovery')
 const Node = require('./Node')
 const Player = require('./Player')
 const Track = require('./Track')
-const { reportSuppressedError } = require('./Reporting')
+const { emitOperationalError, reportSuppressedError } = require('./Reporting')
 const { version: pkgVersion } = require('../../package.json')
 
 const SEARCH_PREFIX = ':'
@@ -73,10 +73,12 @@ const _functions = {
   isUrl: (query) => {
     if (typeof query !== 'string' || query.length <= 8) return false
     const q = query.trimStart()
-    return q.startsWith('http://') || q.startsWith('https://')
+    return (
+      q.startsWith('http://') || q.startsWith('https://') || q.includes(':')
+    )
   },
   formatQuery(query, source) {
-    return this.isUrl(query) ? query : `${source}${SEARCH_PREFIX}${query}`
+    return _functions.isUrl(query) ? query : `${source}${SEARCH_PREFIX}${query}`
   },
   makeTrack: (t, requester, node) => new Track(t, requester, node),
   safeCall(fn) {
@@ -492,12 +494,7 @@ class Aqua extends EventEmitter {
       (stats.memory ? stats.memory.used / reservable : 0) * 40 +
       (node.rest?.calls || 0) * 0.001
     if (this._nodeLoadCache.size >= MAX_CACHE_SIZE) {
-      const iterator = this._nodeLoadCache.keys()
-      while (this._nodeLoadCache.size >= MAX_CACHE_SIZE) {
-        const oldest = iterator.next().value
-        if (!oldest) break
-        this._nodeLoadCache.delete(oldest)
-      }
+      this._nodeLoadCache.delete(this._nodeLoadCache.keys().next().value)
     }
     this._nodeLoadCache.set(id, { load, time: now })
     return load
@@ -549,17 +546,12 @@ class Aqua extends EventEmitter {
       attempts: 0,
       lastAttempt: 0
     }
-    try {
-      await node.connect()
-      this._failoverState[id].connected = true
-      this._failoverState[id].failoverInProgress = false
-      this._invalidateCache()
-      this.emit(AqualinkEvents.NodeCreate, node)
-      return node
-    } catch (error) {
-      this._cleanupNode(id)
-      throw error
-    }
+    await node.connect()
+    this._failoverState[id].connected = true
+    this._failoverState[id].failoverInProgress = false
+    this._invalidateCache()
+    this.emit(AqualinkEvents.NodeCreate, node)
+    return node
   }
 
   _destroyNode(id) {
@@ -762,9 +754,8 @@ class Aqua extends EventEmitter {
       query,
       source || this.defaultSearchPlatform
     )
-    const endpoint = `/${this.restVersion}/loadtracks?identifier=${encodeURIComponent(formatted)}`
     try {
-      const response = await node.rest.makeRequest('GET', endpoint)
+      const response = await node.rest.loadTracks(formatted)
       if (
         !response ||
         response.loadType === 'empty' ||
@@ -773,11 +764,13 @@ class Aqua extends EventEmitter {
         return EMPTY_TRACKS_RESPONSE
       return this._constructResponse(response, requester, node)
     } catch (error) {
-      throw new Error(
-        error?.name === 'AbortError'
-          ? 'Request timeout'
-          : `Resolve failed: ${error?.message || error}`
-      )
+      if (error?.name === 'AbortError') throw new Error('Request timeout')
+      const err = new Error(`Resolve failed: ${error?.message || error}`)
+      if (error?.statusCode != null) err.statusCode = error.statusCode
+      if (error?.body) err.body = error.body
+      if (error?.url) err.url = error.url
+      err.cause = error
+      throw err
     }
   }
 
@@ -882,11 +875,35 @@ class Aqua extends EventEmitter {
     const lockFile = `${filePath}.lock`
     const tempFile = `${filePath}.tmp`
     let ws = null
+    let lockAcquired = false
     try {
       await fs.promises.writeFile(lockFile, String(process.pid), { flag: 'wx' })
+      lockAcquired = true
       ws = fs.createWriteStream(tempFile, { encoding: 'utf8', flags: 'w' })
+      let streamError = null
+      ws.on('error', (error) => {
+        streamError = error
+      })
       const buffer = []
-      let drainPromise = Promise.resolve()
+      const write = (chunk) => {
+        if (ws.write(chunk)) return Promise.resolve()
+        return new Promise((resolve, reject) => {
+          const onDrain = () => {
+            cleanup()
+            resolve()
+          }
+          const onError = (error) => {
+            cleanup()
+            reject(error)
+          }
+          const cleanup = () => {
+            ws.off('drain', onDrain)
+            ws.off('error', onError)
+          }
+          ws.once('drain', onDrain)
+          ws.once('error', onError)
+        })
+      }
 
       const nodeSessions = {}
       for (const node of this.nodeMap.values()) {
@@ -918,29 +935,36 @@ class Aqua extends EventEmitter {
         if (buffer.length >= WRITE_BUFFER_SIZE) {
           const chunk = `${buffer.join('\n')}\n`
           buffer.length = 0
-          if (!ws.write(chunk)) {
-            drainPromise = drainPromise.then(
-              () => new Promise((r) => ws.once('drain', r))
-            )
-          }
+          await write(chunk)
         }
       }
 
-      if (buffer.length) ws.write(`${buffer.join('\n')}\n`)
-      await drainPromise
-      await new Promise((resolve, reject) =>
-        ws.end((err) => (err ? reject(err) : resolve()))
-      )
+      if (buffer.length) await write(`${buffer.join('\n')}\n`)
+      if (streamError) throw streamError
+      await new Promise((resolve, reject) => {
+        const onError = (error) => {
+          ws.off('finish', onFinish)
+          reject(error)
+        }
+        const onFinish = () => {
+          ws.off('error', onError)
+          resolve()
+        }
+        ws.once('error', onError)
+        ws.once('finish', onFinish)
+        ws.end()
+      })
       ws = null
       await fs.promises.rename(tempFile, filePath)
     } catch (error) {
       console.error(`[Aqua/Autoresume]Error saving players:`, error)
-      this.emit(AqualinkEvents.Error, null, error)
+      emitOperationalError(this, null, error)
       if (ws) _functions.safeCall(() => ws.destroy())
       await fs.promises.unlink(tempFile).catch(_functions.noop)
     } finally {
       if (ws) _functions.safeCall(() => ws.destroy())
-      await fs.promises.unlink(lockFile).catch(_functions.noop)
+      if (lockAcquired)
+        await fs.promises.unlink(lockFile).catch(_functions.noop)
     }
   }
 

package/build/structures/AquaRecovery.js

@@ -2,7 +2,7 @@ const fs = require('node:fs')
 const path = require('node:path')
 const readline = require('node:readline')
 const { AqualinkEvents } = require('./AqualinkEvents')
-const { reportSuppressedError } = require('./Reporting')
+const { emitOperationalError, reportSuppressedError } = require('./Reporting')
 
 class AquaRecovery {
   constructor(aqua, deps) {
@@ -221,7 +221,7 @@ class AquaRecovery {
         this.performCleanup()
       }
     } catch (error) {
-      this.aqua.emit(AqualinkEvents.Error, null, error)
+      emitOperationalError(this.aqua, null, error)
     } finally {
       state.failoverInProgress = false
     }
@@ -267,12 +267,32 @@ class AquaRecovery {
       async () => {
         const state = this.capturePlayerState(player)
         if (!state) throw new Error('Failed to capture state')
+        const oldMessage = player.nowPlayingMessage || null
+        const oldVoice = player.connection
+          ? {
+              sid: player.connection.sessionId,
+              ep: player.connection.endpoint,
+              tok: player.connection.token,
+              reg: player.connection.region,
+              cid: player.connection.channelId
+            }
+          : null
+        player.destroy({
+          preserveClient: true,
+          skipRemote: true,
+          preserveMessage: true,
+          preserveTracks: true,
+          preserveReconnecting: true
+        })
         const { maxRetries, retryDelay } = this.aqua.failoverOptions
         for (let retry = 0; retry < maxRetries; retry++) {
+          let newPlayer = null
           try {
             const targetNode = pickNode()
-            const newPlayer = this.createPlayerOnNode(targetNode, state)
+            newPlayer = this.createPlayerOnNode(targetNode, state)
+            this._applyVoiceBootstrap(newPlayer, oldVoice)
             await this.restorePlayerState(newPlayer, state)
+            if (oldMessage) newPlayer.nowPlayingMessage = oldMessage
             this.aqua.emit(
               AqualinkEvents.PlayerMigrated,
               player,
@@ -281,6 +301,13 @@ class AquaRecovery {
             )
             return newPlayer
           } catch (error) {
+            newPlayer?.destroy?.({
+              preserveClient: true,
+              skipRemote: true,
+              preserveMessage: true,
+              preserveTracks: true,
+              preserveReconnecting: true
+            })
             if (retry === maxRetries - 1) throw error
             await this._functions.delay(retryDelay * 1.5 ** retry)
           }
@@ -446,12 +473,13 @@ class AquaRecovery {
     if (!player || !guildId || !(position > 0)) return
     const seekOnce = (startedPlayer) => {
       if (startedPlayer.guildId !== guildId) return
+      this.aqua.off(AqualinkEvents.TrackStart, seekOnce)
+      player.removeListener('destroy', cleanup)
       this._functions.unrefTimeout(() => player.seek?.(position), delay)
     }
-    this.aqua.once(AqualinkEvents.TrackStart, seekOnce)
-    player.once('destroy', () =>
-      this.aqua.off(AqualinkEvents.TrackStart, seekOnce)
-    )
+    const cleanup = () => this.aqua.off(AqualinkEvents.TrackStart, seekOnce)
+    this.aqua.on(AqualinkEvents.TrackStart, seekOnce)
+    player.once('destroy', cleanup)
   }
 
   async restorePlayerState(newPlayer, state) {
@@ -487,10 +515,12 @@ class AquaRecovery {
     this.aqua._loading = true
     const lockFile = `${filePath}.lock`
     let stream = null,
-      rl = null
+      rl = null,
+      lockAcquired = false
     try {
       await fs.promises.access(filePath)
       await fs.promises.writeFile(lockFile, String(process.pid), { flag: 'wx' })
+      lockAcquired = true
       await this.waitForFirstNode()
 
       stream = fs.createReadStream(filePath, { encoding: 'utf8' })
@@ -536,13 +566,14 @@ class AquaRecovery {
     } catch (error) {
       if (error.code !== 'ENOENT') {
         console.error(`[Aqua/Autoresume]Error loading players:`, error)
-        this.aqua.emit(AqualinkEvents.Error, null, error)
+        emitOperationalError(this.aqua, null, error)
       }
     } finally {
       this.aqua._loading = false
       if (rl) this._functions.safeCall(() => rl.close())
       if (stream) this._functions.safeCall(() => stream.destroy())
-      await fs.promises.unlink(lockFile).catch(this._functions.noop)
+      if (lockAcquired)
+        await fs.promises.unlink(lockFile).catch(this._functions.noop)
     }
   }
 

package/build/structures/AqualinkEvents.js

@@ -36,6 +36,8 @@ const AqualinkEvents = {
   PlayerDestroyed: 'playerDestroy',
   PlayerMigrated: 'playerMigrated',
   PauseEvent: 'pauseEvent',
+  PlayerReconnectingEvent: 'PlayerReconnectingEvent',
+  PlayerReconnect: 'playerReconnect',
   MixStarted: 'mixStarted',
   MixEnded: 'mixEnded'
 }

package/build/structures/Connection.js

@@ -76,6 +76,7 @@ const _functions = {
     v.endpoint = conn.endpoint
     v.sessionId = conn.sessionId
     v.channelId = player.voiceChannel
+    v.resuming = player?._resuming ?? false
     payload.data.volume = player?.volume ?? 100
     return payload
   }
@@ -168,7 +169,8 @@ class Connection {
       STATE,
       RECONNECT_DELAY,
       MAX_RECONNECT_ATTEMPTS,
-      RESUME_BACKOFF_MAX
+      RESUME_BACKOFF_MAX,
+      sharedPool
     })
   }
 
@@ -240,6 +242,12 @@ class Connection {
         })
       }
       this.isWaitingForDisconnect = true
+      if (this.voiceChannel !== null) {
+        const oldChannel = this.voiceChannel
+        this.voiceChannel = null
+        if (p) p.voiceChannel = null
+        this._aqua.emit(AqualinkEvents.PlayerMove, p, oldChannel, null)
+      }
       if (!this._nullChannelTimer) {
         this._nullChannelTimer = setTimeout(() => {
           this._nullChannelTimer = null

package/build/structures/ConnectionRecovery.js

@@ -9,6 +9,7 @@ class ConnectionRecovery {
     this.RECONNECT_DELAY = deps.RECONNECT_DELAY
     this.MAX_RECONNECT_ATTEMPTS = deps.MAX_RECONNECT_ATTEMPTS
     this.RESUME_BACKOFF_MAX = deps.RESUME_BACKOFF_MAX
+    this.sharedPool = deps.sharedPool
   }
 
   setServerUpdate(data) {
@@ -153,7 +154,7 @@ class ConnectionRecovery {
       `Attempt resume: guild=${conn._guildId} endpoint=${conn.endpoint} session=${conn.sessionId}`
     )
 
-    const payload = sharedPool.acquire()
+    const payload = this.sharedPool.acquire()
     try {
       this._functions.fillVoicePayload(
         payload,
@@ -242,7 +243,7 @@ class ConnectionRecovery {
       return false
     } finally {
       conn._stateFlags &= ~this.STATE.ATTEMPTING_RESUME
-      sharedPool.release(payload)
+      this.sharedPool.release(payload)
     }
   }
 
@@ -386,40 +387,4 @@ class ConnectionRecovery {
   }
 }
 
-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