aqualink 1.9.0 → 2.0.0

package/README.md

@@ -4,7 +4,7 @@ An Stable, performant, Recourse friendly and fast lavalink wrapper
 This code is based in riffy, but its an 100% Rewrite made from scratch...
 
 # Why use AquaLink
-- Uses my modified fork of @performanc/pwsl-mini, for an way faster WebSocket
+- Dependecy-free (0 dependencys), may change in future
 - Very Low memory comsuption
 - Built in Queue manager
 - Lots of features to use
@@ -13,86 +13,24 @@ This code is based in riffy, but its an 100% Rewrite made from scratch...
 - 1 Player created = ~1 - 0,5 mb per player
 - Auto clean Up memory when song finishes / bot leave the vc (Now Options supported!)
 - Plugin system
-- Lavalink v4 support (din't test v3)
+- Lavalink v4.0.8 | v4.1.0 Support (Nodelink works, but only with play etc, more support soon)
 - Youtube and Spotify support (Soundcloud, deezer, vimeo, etc also works...)
 - Minimal Requests to the lavalink server (helps the lavalink recourses!)
-- Easy player, node, aqua manager
-- Fast responses from rest and node
 - Playlist support (My mix playlists, youtube playlists, spotify playlists, etc)
 - Lyrics Support by Lavalink
   - https://github.com/topi314/LavaLyrics (RECOMMENDED)
   - https://github.com/DRSchlaubi/lyrics.kt (?)
   - https://github.com/DuncteBot/java-timed-lyrics (RECOMMENDED)
   
-# Tralalero Tralala 1.9.0 Released  
-**Whoa, lots of stuff to write here 😭**
-
----
-
-### **Small changes on the `fetchImage` Handler**
-- Improves the overall speed, less memory overhead.
-
----
-
-### **Remade some stuff on `AQUA` module**
-- This fixes some bugs related to destroying players.
-- Faster node connection speeds.
-- Uses an Array for getting the region instead (testing).
-- Small change on the Voice Handler.
-- Improved Error handling.
-- Use `node.destroy()` method directly.
-
----
-
-### **Remade `Connection` module**
-- Removed lots of useless code.
-- Improved joining voice channel speed.
-- Improved configuration set/get speed.
-- Improved overall checking.
-- Improved debug messages.
-
----
-
-### **Remade `Node` module (this one is good)**
-- Fixed the `autoResume` system (now will actually work, for 60 seconds).
-- New WebSocket System.
-- Improved the events handling speed.
-- Now does recalculation of the backoff time (for more efficiency on reconnect).
-- Now avoids reconnecting if the WebSocket is already open (sorry, I forgot to add this before).
-- Better cleaning system (improved, now removes listeners instead of setting to `null`).
-- Avoids re-binding the functions every time `connect` is called (yay).
-- This update also improves long-process running.
-
----
-
-### **Remade the `Player` module (also a good one)**
-- Remade every method.
-- Fixed destroy system.
-- Better event handling, I think.
-- Made the events async.
-- Removed `trackChange` (does not exist in Lavalink API, use `trackStart` instead).
-- Uses a new listener system (way more efficient for creating/destroying players).
-- Faster shuffle in V8 Engine (Math stuff).
-- Improved overall configs (more precise).
-- Use `pop()` instead of disabling the track 50 on the length.
-- Improved overall speed on the check-ins and some stuff I forgot.
-
----
-
-### **Remade the `Rest` module**
-- Better speed (removed useless `buildEndpoint`).
-- More compact code.
-- Removed `stats/all` in the stats (correct by using the Lavalink API).
-- Better `makeRequest`.
-
----
-
-### **Small changes in `Track` module**
-- More efficient final result (`author` + `track`).
-
+# Tralalero Tralala 2.0.0 Released  
 ---
 
-That’s all for **1.9.0** atm. I’m a lazy dev. 😴
+### Now aqualink is 100% depedency free!
+  - Rewrite the rest to use https / http 
+  - Removed undici usage
+  - Rewrite NODE to use built-in WebSocket (no need to upgrade to node 20 or more!)
+  - Uses my own made websocket system, so please report any bugs (i beg)
+  - more stuff soon, now bye
 
 # Docs (Wiki)
 - https://github.com/ToddyTheNoobDud/AquaLink/wiki

package/build/handlers/WebSocket.js

@@ -0,0 +1,259 @@
+const https = require('node:https');
+const http = require('node:http');
+const crypto = require('node:crypto');
+const { EventEmitter } = require('node:events');
+const { URL } = require('node:url');
+const { Buffer } = require('node:buffer');
+
+let nativeWs = null;
+if (process.isBun) nativeWs = require('ws');
+const frameHeaderPool = Buffer.alloc(10);
+
+
+class BufferPool {
+  constructor(initialSize = 8192) {
+    this.buffer = Buffer.allocUnsafe(initialSize);
+    this.used = 0;
+  }
+
+  append(data) {
+    const dataLength = data.length;
+    if (this.used + dataLength > this.buffer.length) {
+      const newSize = Math.max(this.buffer.length * 2, this.used + dataLength);
+      const newBuffer = Buffer.allocUnsafe(newSize);
+      this.buffer.copy(newBuffer, 0, 0, this.used);
+      this.buffer = newBuffer;
+    }
+    data.copy(this.buffer, this.used);
+    this.used += dataLength;
+  }
+
+  consume(bytes) {
+    if (bytes === this.used) {
+      this.used = 0;
+      return;
+    }
+    
+    this.buffer.copy(this.buffer, 0, bytes, this.used);
+    this.used -= bytes;
+  }
+
+  get data() {
+    return this.buffer.subarray(0, this.used);
+  }
+}
+
+class WebSocket extends EventEmitter {
+  constructor(url, options = {}) {
+    super();
+    this.url = url;
+    this.options = options;
+    this.socket = null;
+    this.bufferPool = new BufferPool();
+    this.frameInfo = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = options.maxReconnectAttempts || 10;
+    this.baseReconnectDelay = options.baseReconnectDelay || 1000; // 1 second
+    this.connect();
+  }
+
+  connect() {
+    const { hostname, protocol, port, pathname, search } = new URL(this.url);
+    const isSecure = protocol === 'wss:';
+    const agent = isSecure ? https : http;
+    const key = crypto.randomBytes(16).toString('base64');
+
+    const request = agent.request({
+      hostname,
+      port: port || (isSecure ? 443 : 80),
+      path: pathname + search,
+      timeout: this.options.timeout || 30000,
+      headers: {
+        'Sec-WebSocket-Key': key,
+        'Sec-WebSocket-Version': 13,
+        'Upgrade': 'websocket',
+        'Connection': 'Upgrade',
+        ...this.options.headers
+      },
+      method: 'GET'
+    });
+
+    request.once('error', (err) => this._handleError(err));
+    request.once('upgrade', (res, socket, head) => this._handleUpgrade(res, socket, head, key));
+    request.end();
+  }
+
+  _handleUpgrade(res, socket, head, key) {
+    if (res.headers.upgrade.toLowerCase() !== 'websocket') {
+      return socket.destroy();
+    }
+
+    const expectedAccept = crypto.createHash('sha1')
+      .update(key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+      .digest('base64');
+
+    if (res.headers['sec-websocket-accept'] !== expectedAccept) {
+      return socket.destroy();
+    }
+
+    this.reconnectAttempts = 0;
+    
+    this.socket = socket;
+    this.socket.setNoDelay(true);
+    this.socket.setKeepAlive(true);
+    this.socket.on('data', (data) => this._processData(data));
+    this.socket.once('close', () => this._handleClose(1006));
+    this.socket.once('error', (err) => this._handleError(err));
+    if (head.length) this._processData(head);
+    this.emit('open');
+  }
+
+  _processData(data) {
+    this.bufferPool.append(data);
+    
+    while (this.bufferPool.used >= 2) {
+      const bufferData = this.bufferPool.data;
+      const lengthByte = bufferData[1] & 127;
+      let headerSize = 2 + ((bufferData[1] & 128) ? 4 : 0);
+      if (lengthByte === 126) headerSize += 2;
+      else if (lengthByte === 127) headerSize += 8;
+      if (this.bufferPool.used < headerSize) return;
+      
+      const frame = this._parseFrame();
+      if (!frame) return;
+      this._handleFrame(frame);
+    }
+  }
+
+  _parseFrame() {
+    const bufferData = this.bufferPool.data;
+    if (bufferData.length < 2) return null;
+  
+    const fin = (bufferData[0] & 128) !== 0;
+    const opcode = bufferData[0] & 15;
+    let payloadLength = bufferData[1] & 127;
+    let offset = 2;
+  
+    if (payloadLength === 126) {
+      if (bufferData.length < offset + 2) return null;
+      payloadLength = bufferData.readUInt16BE(offset);
+      offset += 2;
+    } else if (payloadLength === 127) {
+      if (bufferData.length < offset + 8) return null;
+      payloadLength = Number(bufferData.readBigUInt64BE(offset));
+      offset += 8;
+    }
+  
+    const hasMask = (bufferData[1] & 128) !== 0;
+    const mask = hasMask ? bufferData.subarray(offset, offset + 4) : null;
+    offset += hasMask ? 4 : 0;
+  
+    if (bufferData.length < offset + payloadLength) return null;
+  
+    let payload = Buffer.from(bufferData.subarray(offset, offset + payloadLength));
+  
+    if (mask) {
+      for (let i = 0; i < payload.length; i++) {
+        payload[i] = payload[i] ^ mask[i % 4];
+      }
+    }
+  
+    const totalFrameSize = offset + payloadLength;
+    this.bufferPool.consume(totalFrameSize);
+  
+    return { fin, opcode, payload };
+  }
+
+  _handleFrame({ fin, opcode, payload }) {
+    if (opcode === 0x8) return this._handleClose(payload.length >= 2 ? payload.readUInt16BE(0) : 1006);
+    if (opcode === 0x9) return this._sendFrame(0xA, payload);
+    if (opcode === 0xA) return this.emit('pong', payload);
+    if (!fin) return;
+    
+    if (opcode === 0x1) {
+      this.emit('message', payload.toString('utf-8'));
+    } else {
+      this.emit('message', payload);
+    }
+  }
+
+  _sendFrame(opcode, payload = Buffer.alloc(0)) {
+    if (!this.socket || this.socket.destroyed) return;
+    const length = payload.length;
+    let headerSize = length < 126 ? 2 : length < 65536 ? 4 : 10;
+  
+    frameHeaderPool[0] = 0x80 | opcode;
+    if (length < 126) {
+      frameHeaderPool[1] = length;
+    } else if (length < 65536) {
+      frameHeaderPool[1] = 126;
+      frameHeaderPool.writeUInt16BE(length, 2);
+    } else {
+      frameHeaderPool[1] = 127;
+      frameHeaderPool.writeBigUInt64BE(BigInt(length), 2);
+    }
+  
+    this.socket.write(frameHeaderPool.subarray(0, headerSize));
+    this.socket.write(payload);
+  }
+
+  send(data) {
+    if (typeof data === 'string') {
+      data = Buffer.from(data, 'utf-8');
+    } else if (!Buffer.isBuffer(data)) {
+      throw new Error('Data must be a string or Buffer');
+    }
+    this._sendFrame(0x1, data);
+  }
+
+  ping(data = '') {
+    const pingData = typeof data === 'string' ? Buffer.from(data, 'utf-8') : data;
+    this._sendFrame(0x9, pingData);
+  }
+
+  close(code = 1000) {
+    const codeBuffer = Buffer.allocUnsafe(2);
+    codeBuffer.writeUInt16BE(code, 0);
+    this._sendFrame(0x8, codeBuffer);
+    setTimeout(() => this._handleClose(code), 100);
+  }
+
+  _handleClose(code) {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+    this.bufferPool = new BufferPool();
+    this.emit('close', code);
+  }
+
+  _handleError(err) {
+    if (err.code === 'ECONNRESET' || err.code === 'ETIMEDOUT') {
+      if (this.reconnectAttempts < this.maxReconnectAttempts) {
+        this.reconnectAttempts++;
+        const delay = Math.min(
+          this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
+          30000
+        );
+        
+        const jitter = Math.random() * 0.3 * delay;
+        const reconnectDelay = delay + jitter;
+        
+        setTimeout(() => this.connect(), reconnectDelay);
+        this.emit('reconnecting', { 
+          attempt: this.reconnectAttempts, 
+          delay: reconnectDelay,
+          error: err
+        });
+      } else {
+        this.emit('error', new Error(`Maximum reconnection attempts (${this.maxReconnectAttempts}) exceeded: ${err.message}`));
+        this._handleClose(1006);
+      }
+    } else {
+      this.emit('error', err);
+      this._handleClose(1006);
+    }
+  }
+}
+
+module.exports = nativeWs || WebSocket; 

package/build/structures/Node.js

@@ -1,5 +1,5 @@
 "use strict";
-const WebSocket = require("@toddynnn/pwsl-mini");
+const WebSocket = require('../handlers/WebSocket');
 const Rest = require("./Rest");
 
 class Node {
@@ -58,8 +58,6 @@ class Node {
     }
 
     async connect() {
-        if (this.#ws && this.#ws.readyState === WebSocket.OPEN) return;
-        
         this.#ws = new WebSocket(this.wsUrl.href, {
             headers: this.#constructHeaders(),
             perMessageDeflate: false,
@@ -100,7 +98,9 @@ class Node {
 
     async getStats() {
         const stats = await this.rest.getStats();
-        this.stats = { ...this.defaultStats, ...stats };
+        if (JSON.stringify(this.stats) !== JSON.stringify({ ...this.defaultStats, ...stats })) {
+            this.stats = { ...this.defaultStats, ...stats };
+        }
         return this.stats;
     }
 
@@ -109,7 +109,7 @@ class Node {
         try {
             payload = JSON.parse(msg);
         } catch {
-            return; // Invalid JSON, ignore the message
+            return;
         }
 
         const op = payload?.op;
@@ -141,13 +141,16 @@ class Node {
 
     #updateStats(payload) {
         if (!payload) return;
-        this.stats = {
+        const newStats = {
             ...this.stats,
             ...payload,
             memory: this.#updateMemoryStats(payload.memory),
             cpu: this.#updateCpuStats(payload.cpu),
             frameStats: this.#updateFrameStats(payload.frameStats)
-        }; 
+        };
+        if (JSON.stringify(this.stats) !== JSON.stringify(newStats)) {
+            this.stats = newStats;
+        }
     }
 
     #updateMemoryStats(memory = {}) {
@@ -192,7 +195,6 @@ class Node {
         this.sessionId = payload.sessionId;
         this.rest.setSessionId(payload.sessionId);
 
-        // Don't resume here - we'll handle resuming in the #onOpen method if autoResume is enabled
         this.aqua.emit("nodeConnect", this);
     }
 
@@ -213,9 +215,11 @@ class Node {
     }
 
     #reconnect() {
+        clearTimeout(this.#reconnectTimeoutId);
+        
         if (this.infiniteReconnects) {
-            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying non-stop...");
-            setTimeout(() => this.connect(), 10000);
+            this.aqua.emit("nodeReconnect", this, "Infinite reconnects enabled, trying again in 10 seconds");
+            this.#reconnectTimeoutId = setTimeout(() => this.connect(), 10000);
             return;
         }
 
@@ -226,19 +230,17 @@ class Node {
             return;
         }
 
-        clearTimeout(this.#reconnectTimeoutId);
-        const jitter = Math.random() * 10000;
-        const backoffTime = Math.min(
-            this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.#reconnectAttempted) + jitter,
-            Node.MAX_BACKOFF
-        );
+        const baseBackoff = this.reconnectTimeout * Math.pow(Node.BACKOFF_MULTIPLIER, this.#reconnectAttempted);
+        const jitter = Math.random() * Math.min(2000, baseBackoff * 0.2);
+        const backoffTime = Math.min(baseBackoff + jitter, Node.MAX_BACKOFF);
 
+        this.#reconnectAttempted++;
+        this.aqua.emit("nodeReconnect", this, {
+            attempt: this.#reconnectAttempted,
+            backoffTime
+        });
+        
         this.#reconnectTimeoutId = setTimeout(() => {
-            this.#reconnectAttempted++;
-            this.aqua.emit("nodeReconnect", this, {
-                attempt: this.#reconnectAttempted,
-                backoffTime
-            });
             this.connect();
         }, backoffTime);
     }
@@ -275,4 +277,4 @@ class Node {
     }
 }
 
-module.exports = Node;
+module.exports = Node;

package/build/structures/Rest.js

@@ -1,17 +1,18 @@
 "use strict";
-const { Pool } = require("undici");
+const https = require("https");
+const http = require("http");
 
 class Rest {
     constructor(aqua, { secure, host, port, sessionId, password }) {
         this.aqua = aqua;
         this.sessionId = sessionId;
         this.version = "v4";
-        this.baseUrl = `http${secure ? "s" : ""}://${host}:${port}`;
+        this.baseUrl = `${secure ? "https" : "http"}://${host}:${port}`;
         this.headers = {
             "Content-Type": "application/json",
             Authorization: password,
         };
-        this.client = new Pool(this.baseUrl, { pipelining: 1 });
+        this.client = secure ? https : http;
     }
 
     setSessionId(sessionId) {
@@ -19,18 +20,33 @@ class Rest {
     }
 
     async makeRequest(method, endpoint, body = null) {
-        try {
-            const response = await this.client.request({
-                path: endpoint,
-                method,
-                headers: this.headers,
-                body: body ? JSON.stringify(body) : undefined,
+        const options = {
+            method,
+            headers: this.headers,
+        };
+
+        return new Promise((resolve, reject) => {
+            const req = this.client.request(`${this.baseUrl}${endpoint}`, options, (res) => {
+                let data = "";
+                res.setEncoding("utf8");
+
+                res.on("data", (chunk) => (data += chunk));
+                res.on("end", () => {
+                    if (res.statusCode >= 200 && res.statusCode < 300) {
+                        resolve(data ? JSON.parse(data) : null);
+                    } else {
+                        reject(new Error(`Request failed with status ${res.statusCode}: ${res.statusMessage}`));
+                    }
+                });
             });
 
-            return response.statusCode === 204 ? null : await response.body.json();
-        } catch (error) {
-            throw new Error(`Request failed (${method} ${endpoint}): ${error.message}`);
-        }
+            req.on("error", (error) => reject(new Error(`Request failed (${method} ${endpoint}): ${error.message}`)));
+
+            if (body) {
+                req.write(JSON.stringify(body));
+            }
+            req.end();
+        });
     }
 
     validateSessionId() {
@@ -38,59 +54,63 @@ class Rest {
     }
 
     async updatePlayer({ guildId, data }) {
-        if ((data.track?.encoded && data.track?.identifier) || (data.encodedTrack && data.identifier)) {
+        if (data.track?.encoded && data.track?.identifier) {
             throw new Error("Cannot provide both 'encoded' and 'identifier' for track");
         }
         this.validateSessionId();
         return this.makeRequest("PATCH", `/${this.version}/sessions/${this.sessionId}/players/${guildId}?noReplace=false`, data);
     }
 
-    async getPlayers() {
+    getPlayers() {
         this.validateSessionId();
         return this.makeRequest("GET", `/${this.version}/sessions/${this.sessionId}/players`);
     }
 
-    async destroyPlayer(guildId) {
+    destroyPlayer(guildId) {
         this.validateSessionId();
         return this.makeRequest("DELETE", `/${this.version}/sessions/${this.sessionId}/players/${guildId}`);
     }
 
-    async getTracks(identifier) {
+    getTracks(identifier) {
         return this.makeRequest("GET", `/${this.version}/loadtracks?identifier=${encodeURIComponent(identifier)}`);
     }
 
-    async decodeTrack(track) {
+    decodeTrack(track) {
         return this.makeRequest("GET", `/${this.version}/decodetrack?encodedTrack=${encodeURIComponent(track)}`);
     }
 
-    async decodeTracks(tracks) {
+    decodeTracks(tracks) {
         return this.makeRequest("POST", `/${this.version}/decodetracks`, tracks);
     }
 
-    async getStats() {
+    getStats() {
         return this.makeRequest("GET", `/${this.version}/stats`);
     }
 
-    async getInfo() {
+    getInfo() {
         return this.makeRequest("GET", `/${this.version}/info`);
     }
 
-    async getRoutePlannerStatus() {
+    getRoutePlannerStatus() {
         return this.makeRequest("GET", `/${this.version}/routeplanner/status`);
     }
 
-    async getRoutePlannerAddress(address) {
+    getRoutePlannerAddress(address) {
         return this.makeRequest("POST", `/${this.version}/routeplanner/free/address`, { address });
     }
 
     async getLyrics({ track }) {
         if (track.search) {
-            const res = await this.makeRequest("GET", `/${this.version}/lyrics/search?query=${encodeURIComponent(track.encoded.info.title)}&source=genius`);
-            if (res) return res;
+            try {
+                const res = await this.makeRequest("GET", `/${this.version}/lyrics/search?query=${encodeURIComponent(track.encoded.info.title)}&source=genius`);
+                if (res) return res;
+            } catch (error) {
+                console.error("Failed to fetch lyrics:", error.message);
+            }
         }
         this.validateSessionId();
         return this.makeRequest("GET", `/${this.version}/sessions/${this.sessionId}/players/${track.guild_id}/track/lyrics?skipTrackSource=false`);
     }
 }
 
-module.exports = Rest;
+module.exports = Rest;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aqualink",
-  "version": "1.9.0",
-  "description": "An Lavalink wrapper, focused in speed, performance, and features, Based in Riffy!",
+  "version": "2.0.0",
+  "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",
   "scripts": {
@@ -36,10 +36,6 @@
   ],
   "author": "mushroom0162 (https://github.com/ToddyTheNoobDud)",
   "license": "ISC",
-  "dependencies": {
-    "undici": "^7.4.0",
-		"@toddynnn/pwsl-mini": "github:ToddyTheNoobDud/websocket"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/ToddyTheNoobDud/AquaLink"