yukimu 1.0.0 → 1.2.0

package/src/Constants.ts

@@ -0,0 +1,101 @@
+/** Lavalink v3/v4 supported ops and constants */
+
+export const VERSION = "2.0.0";
+export const CLIENT_NAME = `Yukimu/${VERSION}`;
+
+export enum State {
+  CONNECTING = 0,
+  NEARLY = 1,
+  CONNECTED = 2,
+  DISCONNECTING = 3,
+  DISCONNECTED = 4,
+  RECONNECTING = 5,
+}
+
+export enum PlayerState {
+  CONNECTING = 0,
+  CONNECTED = 1,
+  DISCONNECTING = 2,
+  DISCONNECTED = 3,
+}
+
+export enum OpCodes {
+  // v3 WebSocket ops
+  PLAY = "play",
+  STOP = "stop",
+  PAUSE = "pause",
+  SEEK = "seek",
+  VOLUME = "volume",
+  FILTERS = "filters",
+  DESTROY = "destroy",
+  VOICE_UPDATE = "voiceUpdate",
+  EQUALIZER = "equalizer",
+  // Incoming
+  STATS = "stats",
+  PLAYER_UPDATE = "playerUpdate",
+  EVENT = "event",
+  READY = "ready",
+}
+
+export enum LoadType {
+  TRACK = "track",
+  PLAYLIST = "playlist",
+  SEARCH = "search",
+  EMPTY = "empty",
+  ERROR = "error",
+  // v3 equivalents (normalized internally)
+  TRACK_LOADED = "track_loaded",
+  PLAYLIST_LOADED = "playlist_loaded",
+  SEARCH_RESULT = "search_result",
+  NO_MATCHES = "no_matches",
+  LOAD_FAILED = "load_failed",
+}
+
+export enum EventType {
+  TRACK_START = "TrackStartEvent",
+  TRACK_END = "TrackEndEvent",
+  TRACK_EXCEPTION = "TrackExceptionEvent",
+  TRACK_STUCK = "TrackStuckEvent",
+  WS_CLOSED = "WebSocketClosedEvent",
+}
+
+export enum TrackEndReason {
+  FINISHED = "finished",
+  LOAD_FAILED = "loadFailed",
+  STOPPED = "stopped",
+  REPLACED = "replaced",
+  CLEANUP = "cleanup",
+  // v3
+  FINISHED_V3 = "FINISHED",
+  STOPPED_V3 = "STOPPED",
+  REPLACED_V3 = "REPLACED",
+  CLEANUP_V3 = "CLEANUP",
+}
+
+export const STOPPED_REASONS = new Set([
+  "replaced", "stopped", "REPLACED", "STOPPED",
+]);
+
+export const SOURCE_PREFIXES: Record<string, string> = {
+  youtube: "ytsearch",
+  youtubemusic: "ytmsearch",
+  spotify: "spsearch",
+  deezer: "dzsearch",
+  applemusic: "amsearch",
+  soundcloud: "scsearch",
+  tidal: "tdsearch",
+  jiosaavn: "jssearch",
+  yandexmusic: "ymsearch",
+  flowery: "ftts",
+};
+
+export const URL_PATTERNS: Record<string, RegExp[]> = {
+  youtube: [/^https?:\/\/(www\.)?(youtube\.com|youtu\.be)\/.+/, /^https?:\/\/music\.youtube\.com\/.+/],
+  spotify: [/^https?:\/\/open\.spotify\.com\/(track|album|playlist|artist)\/.+/],
+  soundcloud: [/^https?:\/\/(www\.)?soundcloud\.com\/.+/],
+  deezer: [/^https?:\/\/(www\.)?deezer\.com\/(track|album|playlist)\/.+/],
+  applemusic: [/^https?:\/\/music\.apple\.com\/.+/],
+  tidal: [/^https?:\/\/(www\.)?tidal\.com\/(browse\/)?(track|album|playlist)\/.+/],
+  jiosaavn: [/^https?:\/\/(www\.)?jiosaavn\.com\/.+/],
+  yandexmusic: [/^https?:\/\/music\.yandex\.(ru|com)\/.+/],
+};

package/src/Node.ts

@@ -1,119 +1,138 @@
 import WebSocket from "ws";
-import { NodeOptions, NodeStats, Track, SearchResult, LavalinkException } from "./types";
+import { Rest } from "./Rest";
+import { WsQueue } from "./WsQueue";
+import { State } from "./Constants";
+import { NodeError } from "./errors/YukimuError";
 import type { Yukimu } from "./Yukimu";
+import type { NodeOptions, NodeStats, NodeInfo, Track, SearchResult, LavalinkException } from "./types";
+
+const WS_CLOSE_NORMAL = 1000;
+const HEARTBEAT_INTERVAL = 30000;
 
 export class Node {
   public readonly manager: Yukimu;
   public readonly options: NodeOptions;
+  public readonly rest: Rest;
+  public readonly wsQueue: WsQueue;
+  public readonly version: 3 | 4;
+
   public ws: WebSocket | null = null;
-  public connected: boolean = false;
+  public state: State = State.DISCONNECTED;
   public stats: NodeStats | null = null;
+  public info: NodeInfo | null = null;
   public sessionId: string | null = null;
+  public resumed: boolean = false;
+  public penalties: number = 0;
+  public ping: number = -1;
 
-  /** Lavalink version this node runs (3 or 4) */
-  public readonly version: 3 | 4;
-
-  private reconnectAttempts: number = 0;
+  private restQueue: Promise<unknown> = Promise.resolve();
+  private reconnectAttempts = 0;
   private reconnectTimeout?: ReturnType<typeof setTimeout>;
+  private heartbeatInterval?: ReturnType<typeof setInterval>;
+  private lastHeartbeatAt = 0;
 
   constructor(manager: Yukimu, options: NodeOptions) {
     this.manager = manager;
-    this.options = {
-      secure: false,
-      retries: 5,
-      version: 4,
-      ...options,
-    };
-    this.version = this.options.version ?? 4;
+    this.options = { secure: false, retries: 5, version: 4, resumeTimeout: 60, ...options };
+    this.version = (this.options.version ?? 4) as 3 | 4;
+    this.rest = new Rest(this);
+    this.wsQueue = new WsQueue();
   }
 
-  // ─── URL Helpers ──────────────────────────────────────────────────
+  get connected(): boolean {
+    return this.state === State.CONNECTED || this.state === State.NEARLY;
+  }
 
-  /** WebSocket URL differs between v3 and v4 */
   get wsUrl(): string {
     const protocol = this.options.secure ? "wss" : "ws";
     const base = `${protocol}://${this.options.host}:${this.options.port}`;
     return this.version === 4 ? `${base}/v4/websocket` : base;
   }
 
-  /** REST base URL */
-  get restUrl(): string {
-    const protocol = this.options.secure ? "https" : "http";
-    return `${protocol}://${this.options.host}:${this.options.port}`;
-  }
-
-  /** API prefix — v4 uses /v4, v3 uses nothing */
-  get apiPrefix(): string {
-    return this.version === 4 ? "/v4" : "";
-  }
-
-  get headers(): Record<string, string> {
+  get wsHeaders(): Record<string, string> {
     const h: Record<string, string> = {
       Authorization: this.options.password,
       "User-Id": this.manager.options.clientId,
-      "Client-Name": "Yukimu/1.0.0",
+      "Client-Name": "Yukimu/1.2.0",
     };
-    // v3 uses Num-Shards header
-    if (this.version === 3) {
-      h["Num-Shards"] = "1";
-    }
+    if (this.version === 3) h["Num-Shards"] = "1";
+    if (this.options.resumeKey) h["Resume-Key"] = this.options.resumeKey;
     return h;
   }
 
-  // ─── Connection ───────────────────────────────────────────────────
+  public calculatePenalties(): number {
+    if (!this.stats) return Infinity;
+    const cpu = Math.pow(1.05, 100 * this.stats.cpu.systemLoad) * 10 - 10;
+    const fs = this.stats.frameStats;
+    const deficit = fs ? Math.pow(1.03, 500 * fs.deficit / 3000) * 600 - 600 : 0;
+    const nulled = fs ? Math.pow(1.03, 500 * fs.nulled / 3000) * 300 - 300 : 0;
+    this.penalties = ~~(cpu + deficit + nulled + this.stats.playingPlayers);
+    return this.penalties;
+  }
 
   public connect(): void {
     if (this.ws?.readyState === WebSocket.OPEN) return;
-    this.ws = new WebSocket(this.wsUrl, { headers: this.headers });
+    this.state = State.CONNECTING;
+    this.manager.emit("nodeConnecting", this);
+    this.ws = new WebSocket(this.wsUrl, { headers: this.wsHeaders });
+    this.wsQueue.setSocket(this.ws);
     this.ws.on("open", () => this.onOpen());
-    this.ws.on("message", (data) => this.onMessage(data));
-    this.ws.on("close", (code, reason) => this.onClose(code, reason.toString()));
-    this.ws.on("error", (err) => this.onError(err));
+    this.ws.on("message", (d: WebSocket.RawData) => this.onMessage(d));
+    this.ws.on("close", (code: number, reason: Buffer) => this.onClose(code, reason.toString()));
+    this.ws.on("error", (err: Error) => this.onError(err));
   }
 
-  public destroy(): void {
+  public destroy(reconnect = false): void {
     if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+    this.wsQueue.clear();
+    this.wsQueue.setSocket(null);
     this.ws?.removeAllListeners();
-    this.ws?.close();
+    this.ws?.close(WS_CLOSE_NORMAL, "destroy");
     this.ws = null;
-    this.connected = false;
+    this.state = State.DISCONNECTED;
+    if (!reconnect) this.sessionId = null;
   }
 
-  // ─── WebSocket Events ─────────────────────────────────────────────
-
-  private onOpen(): void {
-    this.connected = true;
+  private async onOpen(): Promise<void> {
+    this.state = State.NEARLY;
     this.reconnectAttempts = 0;
     this.manager.emit("nodeConnect", this);
-    console.log(`[Yukimu] Node "${this.options.name}" connected (Lavalink v${this.version})`);
+    console.log(`[Yukimu] Node "${this.options.name}" connected (v${this.version})`);
+
+    try { this.info = await this.rest.getInfo(); } catch {}
+
+    if (this.version === 4 && this.options.resumeKey) {
+      await this.rest.updateSession({ resuming: true, timeout: this.options.resumeTimeout ?? 60 }).catch(() => {});
+    }
 
-    // v3 doesn't send a "ready" op — mark ready immediately on open
     if (this.version === 3) {
-      this.sessionId = "v3-no-session";
+      this.state = State.CONNECTED;
+      this.sessionId = this.options.resumeKey ?? `v3-${Date.now()}`;
       this.manager.emit("nodeReady", this);
     }
+
+    this.startHeartbeat();
   }
 
   private onMessage(raw: WebSocket.RawData): void {
     let payload: Record<string, unknown>;
-    try {
-      payload = JSON.parse(raw.toString());
-    } catch {
-      return;
-    }
-
+    try { payload = JSON.parse(raw.toString()); } catch { return; }
     const op = payload.op as string;
 
-    // ── v4 ops ──
     if (this.version === 4) {
       switch (op) {
         case "ready":
+          this.state = State.CONNECTED;
           this.sessionId = payload.sessionId as string;
+          this.resumed = (payload.resumed as boolean) ?? false;
           this.manager.emit("nodeReady", this);
-          console.log(`[Yukimu] Node "${this.options.name}" ready | session: ${this.sessionId}`);
+          console.log(`[Yukimu] Node "${this.options.name}" ready | session: ${this.sessionId} | resumed: ${this.resumed}`);
+          if (this.resumed) this.reconnectPlayers();
           break;
         case "stats":
           this.stats = payload as unknown as NodeStats;
+          this.calculatePenalties();
           break;
         case "playerUpdate":
           this.handlePlayerUpdate(payload);
@@ -125,10 +144,10 @@ export class Node {
       return;
     }
 
-    // ── v3 ops ──
     switch (op) {
       case "stats":
         this.stats = payload as unknown as NodeStats;
+        this.calculatePenalties();
         break;
       case "playerUpdate":
         this.handlePlayerUpdate(payload);
@@ -140,10 +159,12 @@ export class Node {
   }
 
   private onClose(code: number, reason: string): void {
-    this.connected = false;
+    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+    this.state = State.DISCONNECTED;
     this.manager.emit("nodeDisconnect", this, code, reason);
-    console.warn(`[Yukimu] Node "${this.options.name}" disconnected (${code}): ${reason}`);
-    this.scheduleReconnect();
+    console.warn(`[Yukimu] Node "${this.options.name}" disconnected (${code}): ${reason || "No reason"}`);
+    if (code !== WS_CLOSE_NORMAL) this.scheduleReconnect();
+    else this.movePlayers();
   }
 
   private onError(error: Error): void {
@@ -151,28 +172,56 @@ export class Node {
     console.error(`[Yukimu] Node "${this.options.name}" error:`, error.message);
   }
 
-  // ─── Reconnect ────────────────────────────────────────────────────
+  private startHeartbeat(): void {
+    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+    this.heartbeatInterval = setInterval(async () => {
+      if (!this.connected) return;
+      this.lastHeartbeatAt = Date.now();
+      try {
+        this.stats = await this.rest.getStats();
+        this.ping = Date.now() - this.lastHeartbeatAt;
+        this.calculatePenalties();
+      } catch {}
+    }, HEARTBEAT_INTERVAL);
+  }
 
   private scheduleReconnect(): void {
-    const maxRetries = this.options.retries ?? 5;
-    if (this.reconnectAttempts >= maxRetries) {
-      console.error(`[Yukimu] Node "${this.options.name}" max reconnect attempts reached`);
+    const max = this.options.retries ?? 5;
+    if (this.reconnectAttempts >= max) {
+      this.manager.emit("nodeError", this, new NodeError(`Node "${this.options.name}" max retries reached`));
+      this.movePlayers();
       return;
     }
-    const delay = Math.min(1000 * 2 ** this.reconnectAttempts, 30000);
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
     this.reconnectAttempts++;
-    console.log(`[Yukimu] Reconnecting node "${this.options.name}" in ${delay}ms (attempt ${this.reconnectAttempts})`);
-    this.reconnectTimeout = setTimeout(() => this.connect(), delay);
+    this.state = State.RECONNECTING;
+    console.log(`[Yukimu] Reconnecting "${this.options.name}" in ${delay}ms (${this.reconnectAttempts}/${max})`);
+    this.reconnectTimeout = setTimeout(() => { this.destroy(true); this.connect(); }, delay);
+  }
+
+  private movePlayers(): void {
+    const players = [...this.manager.players.values()].filter(p => p.node === this);
+    if (!players.length) return;
+    let best: Node;
+    try { best = this.manager.getBestNode(); } catch { return; }
+    if (best === this) return;
+    console.log(`[Yukimu] Moving ${players.length} players to "${best.options.name}"`);
+    for (const player of players) player.moveToNode(best).catch(console.error);
   }
 
-  // ─── Event Handlers ───────────────────────────────────────────────
+  private reconnectPlayers(): void {
+    for (const player of this.manager.players.values()) {
+      if (player.node === this) player.checkVoiceReady();
+    }
+  }
 
   private handlePlayerUpdate(payload: Record<string, unknown>): void {
     const player = this.manager.players.get(payload.guildId as string);
     if (!player) return;
-    const state = payload.state as { position?: number; connected?: boolean; ping?: number };
-    player.position = state.position ?? 0;
-    player.ping = state.ping ?? -1;
+    const state = payload.state as { position?: number; ping?: number; time?: number };
+    player.position = state.position ?? player.position;
+    player.ping = state.ping ?? player.ping;
+    player.lastUpdated = state.time ?? Date.now();
     this.manager.emit("playerUpdate", player);
   }
 
@@ -180,36 +229,48 @@ export class Node {
     const player = this.manager.players.get(payload.guildId as string);
     if (!player) return;
 
-    // Normalize track — v3 uses { track: "encoded_string" }, v4 uses { track: { encoded, info } }
     let track: Track;
     if (this.version === 3) {
-      track = {
-        encoded: payload.track as string,
-        info: {} as Track["info"],
-      };
+      track = { encoded: payload.track as string, info: {} as Track["info"], pluginInfo: {} };
     } else {
       track = payload.track as Track;
+      if (track?.encoded) this.manager.trackCache.set(track.encoded, track);
     }
 
     switch (payload.type) {
       case "TrackStartEvent":
         player.playing = true;
+        player.paused = false;
+        player.lastUpdated = Date.now();
         this.manager.emit("trackStart", player, track);
         break;
 
-      case "TrackEndEvent":
+      case "TrackEndEvent": {
+        const reason = payload.reason as string;
         player.playing = false;
         player.position = 0;
-        this.manager.emit("trackEnd", player, track, payload.reason as string);
-        if (payload.reason !== "replaced" && payload.reason !== "stopped" && payload.reason !== "REPLACED" && payload.reason !== "STOPPED") {
-          player.queue.next();
-          if (player.queue.current) {
-            player.play(player.queue.current);
+        this.manager.emit("trackEnd", player, track, reason);
+        const stopped = ["replaced", "stopped", "REPLACED", "STOPPED"].includes(reason);
+        if (!stopped) {
+          if (player.loop === "track" && player.queue.current) {
+            player.play(player.queue.current).catch(() => {});
           } else {
-            this.manager.emit("queueEnd", player);
+            if (player.loop === "queue" && player.queue.current) {
+              player.queue.add(player.queue.current);
+            }
+            const next = player.queue.next();
+            if (next) {
+              player.play(next).catch(() => {});
+            } else {
+              this.manager.emit("queueEnd", player);
+              if (player.autoplay && track.info?.uri) {
+                this.manager.emit("autoplayRequest", player, track);
+              }
+            }
           }
         }
         break;
+      }
 
       case "TrackExceptionEvent":
         this.manager.emit("trackError", player, track, payload.exception as LavalinkException);
@@ -217,110 +278,32 @@ export class Node {
 
       case "TrackStuckEvent":
         this.manager.emit("trackStuck", player, track, payload.thresholdMs as number);
+        player.skip().catch(() => {});
         break;
 
       case "WebSocketClosedEvent":
-        this.manager.emit("socketClosed", player, payload.code as number, payload.reason as string);
+        this.manager.emit("socketClosed", player, payload.code as number, payload.reason as string, payload.byRemote as boolean);
         break;
     }
   }
 
-  // ─── REST API ─────────────────────────────────────────────────────
-
-  public async request<T = unknown>(
-    method: string,
-    path: string,
-    body?: unknown
-  ): Promise<T> {
-    const url = `${this.restUrl}${this.apiPrefix}${path}`;
-    const res = await fetch(url, {
-      method,
-      headers: {
-        ...this.headers,
-        "Content-Type": "application/json",
-      },
-      body: body ? JSON.stringify(body) : undefined,
-    });
-
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`[Yukimu] REST error ${res.status} on ${method} ${path}: ${text}`);
-    }
-
-    if (res.status === 204) return undefined as T;
-    return res.json() as Promise<T>;
+  public send(data: Record<string, unknown>): Promise<void> {
+    return this.wsQueue.send(data);
   }
 
-  /** Load tracks — works for both v3 and v4 */
-  public async loadTracks(identifier: string): Promise<SearchResult> {
-    const raw = await this.request<Record<string, unknown>>(
-      "GET",
-      `/loadtracks?identifier=${encodeURIComponent(identifier)}`
-    );
-
-    // Normalize v3 response to v4 format
-    if (this.version === 3) {
-      return this.normalizeV3Response(raw);
-    }
-
-    return raw as unknown as SearchResult;
+  public enqueueRest<T>(fn: () => Promise<T>): Promise<T> {
+    const result = this.restQueue.then(() => fn());
+    this.restQueue = result.catch(() => {});
+    return result;
   }
 
-  /**
-   * Convert v3 loadtracks response to v4 format so the rest
-   * of the codebase only needs to handle one format
-   */
-  private normalizeV3Response(raw: Record<string, unknown>): SearchResult {
-    const loadType = (raw.loadType as string).toLowerCase();
-
-    // v3 tracks are { track: "encoded", info: {...} }
-    // v4 tracks are { encoded: "...", info: {...} }
-    const normalizeTracks = (tracks: unknown[]): Track[] =>
-      tracks.map((t: unknown) => {
-        const track = t as Record<string, unknown>;
-        return {
-          encoded: (track.track ?? track.encoded) as string,
-          info: track.info as Track["info"],
-          pluginInfo: track.pluginInfo as Record<string, unknown> | undefined,
-        };
-      });
-
-    switch (loadType) {
-      case "track_loaded":
-        return {
-          loadType: "track",
-          tracks: normalizeTracks(raw.tracks as unknown[]),
-        };
-      case "playlist_loaded":
-        return {
-          loadType: "playlist",
-          tracks: normalizeTracks(raw.tracks as unknown[]),
-          playlistInfo: raw.playlistInfo as SearchResult["playlistInfo"],
-        };
-      case "search_result":
-        return {
-          loadType: "search",
-          tracks: normalizeTracks(raw.tracks as unknown[]),
-        };
-      case "no_matches":
-        return { loadType: "empty", tracks: [] };
-      case "load_failed":
-        return {
-          loadType: "error",
-          tracks: [],
-          exception: raw.exception as SearchResult["exception"],
-        };
-      default:
-        return { loadType: "empty", tracks: [] };
-    }
+  public async loadTracks(identifier: string): Promise<SearchResult> {
+    return this.rest.loadTracks(identifier);
   }
 
-  /** Get player endpoint path — differs between v3 and v4 */
   public playerPath(guildId: string): string {
-    if (this.version === 4) {
-      return `/sessions/${this.sessionId}/players/${guildId}`;
-    }
-    // v3 uses /players/{guildId}
-    return `/players/${guildId}`;
+    return this.version === 4
+      ? `/sessions/${this.sessionId}/players/${guildId}`
+      : `/players/${guildId}`;
   }
-}
+}