enerthya.dev-audio-server 1.0.2 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "enerthya.dev-audio-server",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Enerthya Audio Server — Lavalink-compatible WebSocket audio server in Node.js. Uses enerthya.dev-audio-core for stream processing. Runs on port 80 (Shardcloud compatible).",
   "main": "src/index.js",
   "license": "MIT",
@@ -15,7 +15,7 @@
     "websocket"
   ],
   "dependencies": {
-    "enerthya.dev-audio-core": "1.0.8",
+    "enerthya.dev-audio-core": "1.3.0",
     "ws": "^8.18.0"
   },
   "scripts": {

package/src/server/AudioServer.js

@@ -1,14 +1,9 @@
 /**
  * server/AudioServer.js — Servidor WebSocket de áudio
- *
- * Equivalente ao servidor Lavalink em Java, mas em Node.js.
- * Aceita conexões WebSocket de bots Discord autenticados por senha.
- * Cada conexão representa um bot (identificado pelo userId do bot).
- *
- * Protocolo:
- *   - Autenticação via header "Authorization" na abertura do WS
- *   - Mensagens JSON com campo "op" definindo a operação
- *   - Compatível com o protocolo do Lavalink v4
+ * 
+ * Protocolo binário para audio frames:
+ *   [4 bytes uint32BE = tamanho do guildId] [N bytes guildId UTF-8] [resto = Ogg/Opus]
+ * Isso garante que o bot saiba de qual guild é cada chunk, com múltiplas guilds simultâneas.
  */
 
 const { WebSocketServer, WebSocket } = require("ws");
@@ -18,66 +13,36 @@ const { Op, TrackEvent, EndReason, PlayerState, Defaults } = require("../constan
 const { loadItem } = require("enerthya.dev-audio-core");
 
 class AudioServer {
-  /**
-   * @param {object} opts
-   * @param {string}        [opts.password]       — senha de autenticação (padrão: "enerthya")
-   * @param {http.Server}   [opts.httpServer]      — servidor HTTP existente para attach (porta 80)
-   * @param {number}        [opts.port]            — porta standalone (padrão: 2333)
-   * @param {Function}      [opts.logger]          — função de log (padrão: console.log)
-   */
   constructor(opts = {}) {
-    this.password  = opts.password || process.env.AUDIO_PASSWORD || Defaults.PASSWORD;
-    this.logger    = opts.logger   || console.log;
+    this.password = opts.password || process.env.AUDIO_PASSWORD || Defaults.PASSWORD;
+    this.logger   = opts.logger   || console.log;
+    this.sessions = new Map();
 
-    // sessions: sessionId → { ws, userId, players: Map<guildId, GuildPlayer> }
-    this.sessions  = new Map();
-
-    // Cria o WebSocket server
     if (opts.httpServer) {
-      // Attach no servidor HTTP existente (porta 80 da dashboard)
       this.wss = new WebSocketServer({ server: opts.httpServer, path: "/audio" });
     } else {
-      // Standalone
       const port = opts.port || Defaults.PORT;
       this.wss = new WebSocketServer({ port, path: "/audio" });
-      this.logger(`[AudioServer] Rodando standalone na porta ${port}`);
+      this.logger(`[AudioServer] Rodando na porta ${port}`);
     }
 
     this._setupWss();
     this._startStatsInterval();
   }
 
-  // ── Setup WebSocket ────────────────────────────────────────────────────────
-
   _setupWss() {
     this.wss.on("connection", (ws, req) => {
-      // Autenticação via header Authorization
       const auth = req.headers["authorization"];
-      if (auth !== this.password) {
-        ws.close(4001, "Unauthorized");
-        return;
-      }
+      if (auth !== this.password) { ws.close(4001, "Unauthorized"); return; }
 
       const userId    = req.headers["user-id"] || "unknown";
       const sessionId = crypto.randomBytes(8).toString("hex");
-
-      const session = {
-        ws,
-        userId,
-        sessionId,
-        players: new Map(),
-        connectedAt: Date.now(),
-      };
+      const session   = { ws, userId, sessionId, players: new Map(), connectedAt: Date.now() };
 
       this.sessions.set(sessionId, session);
-      this.logger(`[AudioServer] Conexão estabelecida — userId: ${userId} sessionId: ${sessionId}`);
+      this.logger(`[AudioServer] Conexão — userId: ${userId} session: ${sessionId}`);
 
-      // Envia READY
-      this._send(ws, {
-        op:        Op.READY,
-        resumed:   false,
-        sessionId,
-      });
+      this._send(ws, { op: Op.READY, resumed: false, sessionId });
 
       ws.on("message", (data) => {
         try {
@@ -89,65 +54,44 @@ class AudioServer {
       });
 
       ws.on("close", () => {
-        this.logger(`[AudioServer] Conexão encerrada — sessionId: ${sessionId}`);
-        // Destroi todos os players desta sessão
-        for (const player of session.players.values()) {
-          player.destroy();
-        }
+        this.logger(`[AudioServer] Encerrado — session: ${sessionId}`);
+        for (const player of session.players.values()) player.destroy();
         this.sessions.delete(sessionId);
       });
 
-      ws.on("error", (err) => {
-        this.logger(`[AudioServer] Erro WS — ${err.message}`);
-      });
+      ws.on("error", (err) => this.logger(`[AudioServer] Erro WS: ${err.message}`));
     });
   }
 
-  // ── Handler de mensagens ───────────────────────────────────────────────────
-
   async _handleMessage(session, msg) {
     const { op, guildId } = msg;
     if (!op) return;
 
     switch (op) {
-
       case Op.LOAD: {
-        const result = await loadItem(msg.query, {
-          limit:        msg.limit || 1,
-          requesterId:  session.userId,
-        }).catch((err) => ({ loadType: "error", tracks: [], error: err.message }));
+        const result = await loadItem(msg.query, { limit: msg.limit || 1, requesterId: session.userId })
+          .catch((err) => ({ loadType: "error", tracks: [], error: err.message }));
         this._send(session.ws, { op: "loadResult", guildId, result });
         break;
       }
-
       case Op.SEARCH: {
-        const result = await loadItem(msg.query, {
-          limit: msg.limit || 5,
-          requesterId: session.userId,
-        }).catch(() => ({ loadType: "empty", tracks: [] }));
+        const result = await loadItem(msg.query, { limit: msg.limit || 5, requesterId: session.userId })
+          .catch(() => ({ loadType: "empty", tracks: [] }));
         this._send(session.ws, { op: "searchResult", guildId, result });
         break;
       }
-
       case Op.PLAY: {
         if (!guildId || !msg.track) return;
         const player = this._getOrCreatePlayer(session, guildId);
-
-        if (msg.noReplace && player.state === PlayerState.PLAYING) return;
-
-        // Adiciona à fila ou toca imediatamente
         if (msg.addToQueue && (player.state === PlayerState.PLAYING || player.queue.length > 0)) {
           player.addToQueue(msg.track);
           this._send(session.ws, { op: "queueUpdated", guildId, queue: player.queue });
         } else {
-          if (msg.track) {
-            player.clearQueue();
-            await player.play(msg.track, { startTime: msg.startTime || 0 });
-          }
+          player.clearQueue();
+          await player.play(msg.track, { startTime: msg.startTime || 0 });
         }
         break;
       }
-
       case Op.QUEUE_ADD: {
         if (!guildId || !msg.track) return;
         const player = this._getOrCreatePlayer(session, guildId);
@@ -155,42 +99,33 @@ class AudioServer {
         this._send(session.ws, { op: "queueUpdated", guildId, queue: player.queue });
         break;
       }
-
       case Op.STOP: {
         const player = session.players.get(guildId);
         if (player) player.stop();
         break;
       }
-
       case Op.PAUSE: {
         const player = session.players.get(guildId);
         if (!player) return;
         msg.pause ? player.pause() : player.resume();
-        this._send(session.ws, {
-          op: Op.PLAYER_UPDATE, guildId,
-          state: { position: player.getPosition(), paused: player.paused },
-        });
+        this._send(session.ws, { op: Op.PLAYER_UPDATE, guildId, state: { position: player.getPosition(), paused: player.paused } });
         break;
       }
-
       case Op.SEEK: {
         const player = session.players.get(guildId);
         if (player && msg.position !== undefined) player.seek(msg.position);
         break;
       }
-
       case Op.VOLUME: {
         const player = session.players.get(guildId);
         if (player && msg.volume !== undefined) player.setVolume(msg.volume);
         break;
       }
-
       case Op.SKIP: {
         const player = session.players.get(guildId);
         if (player) player.skip();
         break;
       }
-
       case Op.QUEUE_REMOVE: {
         const player = session.players.get(guildId);
         if (player && msg.index !== undefined) {
@@ -199,145 +134,84 @@ class AudioServer {
         }
         break;
       }
-
       case Op.QUEUE_CLEAR: {
         const player = session.players.get(guildId);
-        if (player) {
-          player.clearQueue();
-          this._send(session.ws, { op: "queueUpdated", guildId, queue: [] });
-        }
+        if (player) { player.clearQueue(); this._send(session.ws, { op: "queueUpdated", guildId, queue: [] }); }
         break;
       }
-
       case Op.QUEUE_SHUFFLE: {
         const player = session.players.get(guildId);
-        if (player) {
-          player.shuffleQueue();
-          this._send(session.ws, { op: "queueUpdated", guildId, queue: player.queue });
-        }
+        if (player) { player.shuffleQueue(); this._send(session.ws, { op: "queueUpdated", guildId, queue: player.queue }); }
         break;
       }
-
       case Op.QUEUE_GET: {
         const player = session.players.get(guildId);
-        this._send(session.ws, {
-          op: "queueResult",
-          guildId,
-          player: player ? player.toJSON() : null,
-        });
+        this._send(session.ws, { op: "queueResult", guildId, player: player ? player.toJSON() : null });
+        break;
+      }
+      case "repeat": {
+        const player = session.players.get(guildId);
+        if (player && msg.mode) player.setRepeat(msg.mode);
         break;
       }
-
       case Op.DESTROY: {
         const player = session.players.get(guildId);
-        if (player) {
-          player.destroy();
-          session.players.delete(guildId);
-        }
+        if (player) { player.destroy(); session.players.delete(guildId); }
         break;
       }
     }
   }
 
-  // ── Player helpers ─────────────────────────────────────────────────────────
-
   _getOrCreatePlayer(session, guildId) {
     if (session.players.has(guildId)) return session.players.get(guildId);
 
     const player = new GuildPlayer(guildId, this);
 
-    // Eventos do player → mensagens WS para o client
-    player.on("trackStart", (track) => {
-      this._send(session.ws, {
-        op:    Op.EVENT,
-        type:  TrackEvent.START,
-        guildId,
-        track,
-      });
-    });
-
-    player.on("trackEnd", (track, reason) => {
-      this._send(session.ws, {
-        op:    Op.EVENT,
-        type:  TrackEvent.END,
-        guildId,
-        track,
-        reason,
-      });
-    });
+    player.on("trackStart",     (track)         => this._send(session.ws, { op: Op.EVENT, type: TrackEvent.START, guildId, track }));
+    player.on("trackEnd",       (track, reason)  => this._send(session.ws, { op: Op.EVENT, type: TrackEvent.END, guildId, track, reason }));
+    player.on("trackException", (track, error)   => this._send(session.ws, { op: Op.EVENT, type: TrackEvent.EXCEPTION, guildId, track, exception: { message: error } }));
+    player.on("playerUpdate",   ({ position })   => this._send(session.ws, { op: Op.PLAYER_UPDATE, guildId, state: { time: Date.now(), position, connected: true } }));
 
-    player.on("trackException", (track, error) => {
-      this._send(session.ws, {
-        op:    Op.EVENT,
-        type:  TrackEvent.EXCEPTION,
-        guildId,
-        track,
-        exception: { message: error, severity: "common" },
-      });
-    });
-
-    player.on("playerUpdate", ({ position }) => {
-      this._send(session.ws, {
-        op:    Op.PLAYER_UPDATE,
-        guildId,
-        state: { time: Date.now(), position, connected: true },
-      });
-    });
-
-    // Stream de áudio PCM → enviado via WS para o bot tocar com @discordjs/voice
+    // ── Protocolo binário: [4 bytes guildId len] [guildId UTF-8] [Ogg/Opus data] ──
     player.on("audioData", (chunk) => {
-      if (session.ws.readyState === WebSocket.OPEN) {
-        session.ws.send(chunk); // Buffer binário — bot identifica pelo guildId atual
-      }
+      if (session.ws.readyState !== WebSocket.OPEN) return;
+      const guildBuf = Buffer.from(guildId, "utf8");
+      const header   = Buffer.allocUnsafe(4);
+      header.writeUInt32BE(guildBuf.length, 0);
+      session.ws.send(Buffer.concat([header, guildBuf, chunk]));
     });
 
     session.players.set(guildId, player);
     return player;
   }
 
-  // ── Stats ──────────────────────────────────────────────────────────────────
-
   _startStatsInterval() {
-    const interval = setInterval(() => {
+    const iv = setInterval(() => {
       const stats = this._getStats();
-      for (const { ws } of this.sessions.values()) {
-        this._send(ws, { op: Op.STATS, ...stats });
-      }
+      for (const { ws } of this.sessions.values()) this._send(ws, { op: Op.STATS, ...stats });
     }, Defaults.STATS_INTERVAL_MS);
-    if (interval.unref) interval.unref();
+    if (iv.unref) iv.unref();
   }
 
   _getStats() {
     const mem = process.memoryUsage();
     let players = 0, playingPlayers = 0;
-    for (const session of this.sessions.values()) {
-      players += session.players.size;
-      for (const p of session.players.values()) {
-        if (p.state === PlayerState.PLAYING) playingPlayers++;
-      }
+    for (const s of this.sessions.values()) {
+      players += s.players.size;
+      for (const p of s.players.values()) if (p.state === PlayerState.PLAYING) playingPlayers++;
     }
     return {
       players, playingPlayers,
-      memory: {
-        free:         Math.round((require("os").freemem())  / 1024 / 1024),
-        used:         Math.round(mem.heapUsed               / 1024 / 1024),
-        allocated:    Math.round(mem.heapTotal              / 1024 / 1024),
-        reservable:   Math.round(require("os").totalmem()   / 1024 / 1024),
-      },
+      memory: { used: Math.round(mem.heapUsed/1024/1024), allocated: Math.round(mem.heapTotal/1024/1024) },
       cpu: { cores: require("os").cpus().length, systemLoad: require("os").loadavg()[0] },
       uptime: Math.floor(process.uptime()),
     };
   }
 
-  // ── Utils ──────────────────────────────────────────────────────────────────
-
   _send(ws, payload) {
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(payload));
-    }
+    if (ws?.readyState === WebSocket.OPEN) ws.send(JSON.stringify(payload));
   }
 
-  /** Retorna estatísticas do servidor para uso externo */
   getStats() { return this._getStats(); }
 }