aqualink 2.6.1-fix → 2.6.1-fix3

package/build/handlers/autoplay.js

@@ -1,142 +1,114 @@
 const https = require('https');
 const crypto = require('crypto');
 
-const agent = new https.Agent({ keepAlive: true, maxSockets: 10 });
+const agent = new https.Agent({
+    keepAlive: true,
+    maxSockets: 5,
+    maxFreeSockets: 2,
+    timeout: 8000,
+    freeSocketTimeout: 4000
+});
 
 const TOTP_SECRET = Buffer.from("5507145853487499592248630329347", 'utf8');
 
-async function quickFetch(url, options = {}, redirectCount = 0) {
-    const maxRedirects = 5;
-    
-    try {
-        return await new Promise((resolve, reject) => {
-            const req = https.get(url, { ...options, agent }, async (res) => {
-                if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-                    if (redirectCount >= maxRedirects) {
-                        return reject(new Error('Too many redirects'));
-                    }
-                    
-                    res.resume();
-                    try {
-                        const resolved = await quickFetch(
-                            new URL(res.headers.location, url).toString(),
-                            options,
-                            redirectCount + 1
-                        );
-                        resolve(resolved);
-                    } catch (err) {
-                        reject(err);
-                    }
-                    return;
-                }
-
-                if (res.statusCode !== 200) {
-                    res.resume();
-                    return reject(new Error(`Request failed. Status code: ${res.statusCode}`));
-                }
-
-                const chunks = [];
-                let length = 0;
-                
-                res.on('data', (chunk) => {
-                    chunks.push(chunk);
-                    length += chunk.length;
-                });
-
-                res.on('end', () => {
-                    resolve(Buffer.concat(chunks, length).toString());
-                });
-            });
-
-            req.on('error', reject);
-            req.setTimeout(10000, () => {
-                req.destroy(new Error('Request timeout'));
-            });
-        });
-    } catch (err) {
-        throw err;
+const SOUNDCLOUD_REGEX = /<a\s+itemprop="url"\s+href="(\/[^"]+)"/g;
+
+const shuffleArray = (arr) => {
+    for (let i = arr.length - 1; i > 0; i--) {
+        const j = Math.random() * (i + 1) | 0;
+        [arr[i], arr[j]] = [arr[j], arr[i]];
     }
-}
+    return arr;
+};
+
+const fastFetch = (url, options = {}) => {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { ...options, agent }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                return fastFetch(new URL(res.headers.location, url).href, options)
+                    .then(resolve, reject);
+            }
+
+            if (res.statusCode !== 200) {
+                res.resume();
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+
+            const chunks = [];
+            res.on('data', chunk => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        });
+
+        req.on('error', reject);
+        req.setTimeout(8000, () => req.destroy(new Error('Timeout')));
+    });
+};
 
-async function soundAutoPlay(baseUrl) {
+const soundAutoPlay = async (baseUrl) => {
     try {
-        const html = await quickFetch(`${baseUrl}/recommended`);
-        const links = new Set();
-        const regex = /<a\s+itemprop="url"\s+href="(\/[^"]+)"/g;
+        const html = await fastFetch(`${baseUrl}/recommended`);
         
+        const links = [];
         let match;
-        while ((match = regex.exec(html)) !== null) {
-            links.add(`https://soundcloud.com${match[1]}`);
-        }
-
-        if (!links.size) {
-            throw new Error("No recommended tracks found on SoundCloud.");
+        while ((match = SOUNDCLOUD_REGEX.exec(html)) && links.length < 50) {
+            links.push(`https://soundcloud.com${match[1]}`);
         }
 
-        const urls = Array.from(links);
-        for (let i = urls.length - 1; i > 0; i--) {
-            const j = Math.random() * (i + 1) | 0;
-            [urls[i], urls[j]] = [urls[j], urls[i]];
-        }
+        if (!links.length) throw new Error("No tracks found");
 
-        return urls;
+        return shuffleArray(links);
     } catch (err) {
-        console.error("Error in SoundCloud autoplay:", err);
+        console.error("SoundCloud error:", err.message);
         return [];
     }
-}
+};
 
-function generateToken() {
-    const timeStep = Math.floor(Date.now() / 30000);
-    const counter = Buffer.alloc(8);
-    counter.writeBigInt64BE(BigInt(timeStep));
+const generateToken = () => {
+    const timeStep = (Date.now() / 30000) | 0;
+    const counter = Buffer.allocUnsafe(8);
+    counter.writeBigUInt64BE(BigInt(timeStep), 0);
 
-    const hmac = crypto.createHmac('sha1', TOTP_SECRET);
-    hmac.update(counter);
-    const hash = hmac.digest();
-    const offset = hash[hash.length - 1] & 0x0f;
+    const hash = crypto.createHmac('sha1', TOTP_SECRET).update(counter).digest();
+    const offset = hash[19] & 0x0f;
     
     const binCode = (
-        (hash[offset] << 24) |
-        (hash[offset + 1] << 16) |
-        (hash[offset + 2] << 8) |
+        (hash[offset] & 0x7f) << 24 |
+        hash[offset + 1] << 16 |
+        hash[offset + 2] << 8 |
         hash[offset + 3]
-    ) & 0x7fffffff;
+    );
 
-    const token = (binCode % 1000000).toString().padStart(6, '0');
-    return [token, timeStep * 30000];
-}
+    return [
+        (binCode % 1000000).toString().padStart(6, '0'),
+        timeStep * 30000
+    ];
+};
 
-async function spotifyAutoPlay(seedTrackId) {
+const spotifyAutoPlay = async (seedTrackId) => {
     const [totp, ts] = generateToken();
-    const params = new URLSearchParams({
-        reason: "transport",
-        productType: "embed",
-        totp,
-        totpVer: "5",
-        ts: ts.toString()
-    });
-
+    
     try {
-        const tokenData = await quickFetch(`https://open.spotify.com/get_access_token?${params}`);
-        const { accessToken } = JSON.parse(tokenData);
+        const tokenUrl = `https://open.spotify.com/api/token?reason=init&productType=embed&totp=${totp}&totpVer=5&ts=${ts}`;
+        const tokenResponse = await fastFetch(tokenUrl);
+        const { accessToken } = JSON.parse(tokenResponse);
         
-        if (!accessToken) throw new Error("Invalid access token");
+        if (!accessToken) throw new Error("No access token");
 
-        const recData = await quickFetch(
-            `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${seedTrackId}`,
-            { headers: { Authorization: `Bearer ${accessToken}` } }
-        );
+        const recUrl = `https://api.spotify.com/v1/recommendations?limit=10&seed_tracks=${seedTrackId}`;
+        const recResponse = await fastFetch(recUrl, {
+            headers: { Authorization: `Bearer ${accessToken}` }
+        });
 
-        const { tracks } = JSON.parse(recData);
-        if (!tracks?.length) throw new Error("No tracks found");
+        const { tracks } = JSON.parse(recResponse);
+        if (!tracks?.length) throw new Error("No tracks");
 
         return tracks[Math.random() * tracks.length | 0].id;
     } catch (err) {
-        console.error("Spotify autoplay error:", err);
+        console.error("Spotify error:", err.message);
         throw err;
     }
-}
+};
 
 module.exports = {
     scAutoPlay: soundAutoPlay,

package/build/structures/Player.js

@@ -58,13 +58,12 @@ class Player extends EventEmitter {
         this._updateTimeout = null;
         this._dataStore = new Map();
 
-        this.on("playerUpdate", (state) => {
-            if (state) {
-                this.position = state.position ?? this.position;
-                this.timestamp = state.timestamp ?? this.timestamp;
-                this.ping = state.ping ?? this.ping;
-                this.aqua.emit("playerUpdate", this, { state });
-            }
+        this.on("playerUpdate", (packet) => {
+            this.position = packet.state.position;
+            this.connected = packet.state.connected;
+            this.ping = packet.state.ping;
+
+            this.aqua.emit("playerUpdate", this, packet);
         });
 
         this.on("event", async (payload) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aqualink",
-  "version": "2.6.1-fix",
+  "version": "2.6.1-fix3",
   "description": "An Lavalink client, focused in pure performance and features",
   "main": "build/index.js",
   "types": "index.d.ts",