yukimu 1.0.0

package/src/Node.ts

@@ -0,0 +1,326 @@
+import WebSocket from "ws";
+import { NodeOptions, NodeStats, Track, SearchResult, LavalinkException } from "./types";
+import type { Yukimu } from "./Yukimu";
+
+export class Node {
+  public readonly manager: Yukimu;
+  public readonly options: NodeOptions;
+  public ws: WebSocket | null = null;
+  public connected: boolean = false;
+  public stats: NodeStats | null = null;
+  public sessionId: string | null = null;
+
+  /** Lavalink version this node runs (3 or 4) */
+  public readonly version: 3 | 4;
+
+  private reconnectAttempts: number = 0;
+  private reconnectTimeout?: ReturnType<typeof setTimeout>;
+
+  constructor(manager: Yukimu, options: NodeOptions) {
+    this.manager = manager;
+    this.options = {
+      secure: false,
+      retries: 5,
+      version: 4,
+      ...options,
+    };
+    this.version = this.options.version ?? 4;
+  }
+
+  // ─── URL Helpers ──────────────────────────────────────────────────
+
+  /** 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> {
+    const h: Record<string, string> = {
+      Authorization: this.options.password,
+      "User-Id": this.manager.options.clientId,
+      "Client-Name": "Yukimu/1.0.0",
+    };
+    // v3 uses Num-Shards header
+    if (this.version === 3) {
+      h["Num-Shards"] = "1";
+    }
+    return h;
+  }
+
+  // ─── Connection ───────────────────────────────────────────────────
+
+  public connect(): void {
+    if (this.ws?.readyState === WebSocket.OPEN) return;
+    this.ws = new WebSocket(this.wsUrl, { headers: this.headers });
+    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));
+  }
+
+  public destroy(): void {
+    if (this.reconnectTimeout) clearTimeout(this.reconnectTimeout);
+    this.ws?.removeAllListeners();
+    this.ws?.close();
+    this.ws = null;
+    this.connected = false;
+  }
+
+  // ─── WebSocket Events ─────────────────────────────────────────────
+
+  private onOpen(): void {
+    this.connected = true;
+    this.reconnectAttempts = 0;
+    this.manager.emit("nodeConnect", this);
+    console.log(`[Yukimu] Node "${this.options.name}" connected (Lavalink v${this.version})`);
+
+    // v3 doesn't send a "ready" op — mark ready immediately on open
+    if (this.version === 3) {
+      this.sessionId = "v3-no-session";
+      this.manager.emit("nodeReady", this);
+    }
+  }
+
+  private onMessage(raw: WebSocket.RawData): void {
+    let payload: Record<string, unknown>;
+    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.sessionId = payload.sessionId as string;
+          this.manager.emit("nodeReady", this);
+          console.log(`[Yukimu] Node "${this.options.name}" ready | session: ${this.sessionId}`);
+          break;
+        case "stats":
+          this.stats = payload as unknown as NodeStats;
+          break;
+        case "playerUpdate":
+          this.handlePlayerUpdate(payload);
+          break;
+        case "event":
+          this.handleEvent(payload);
+          break;
+      }
+      return;
+    }
+
+    // ── v3 ops ──
+    switch (op) {
+      case "stats":
+        this.stats = payload as unknown as NodeStats;
+        break;
+      case "playerUpdate":
+        this.handlePlayerUpdate(payload);
+        break;
+      case "event":
+        this.handleEvent(payload);
+        break;
+    }
+  }
+
+  private onClose(code: number, reason: string): void {
+    this.connected = false;
+    this.manager.emit("nodeDisconnect", this, code, reason);
+    console.warn(`[Yukimu] Node "${this.options.name}" disconnected (${code}): ${reason}`);
+    this.scheduleReconnect();
+  }
+
+  private onError(error: Error): void {
+    this.manager.emit("nodeError", this, error);
+    console.error(`[Yukimu] Node "${this.options.name}" error:`, error.message);
+  }
+
+  // ─── Reconnect ────────────────────────────────────────────────────
+
+  private scheduleReconnect(): void {
+    const maxRetries = this.options.retries ?? 5;
+    if (this.reconnectAttempts >= maxRetries) {
+      console.error(`[Yukimu] Node "${this.options.name}" max reconnect attempts reached`);
+      return;
+    }
+    const delay = Math.min(1000 * 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);
+  }
+
+  // ─── Event Handlers ───────────────────────────────────────────────
+
+  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;
+    this.manager.emit("playerUpdate", player);
+  }
+
+  private handleEvent(payload: Record<string, unknown>): void {
+    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"],
+      };
+    } else {
+      track = payload.track as Track;
+    }
+
+    switch (payload.type) {
+      case "TrackStartEvent":
+        player.playing = true;
+        this.manager.emit("trackStart", player, track);
+        break;
+
+      case "TrackEndEvent":
+        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);
+          } else {
+            this.manager.emit("queueEnd", player);
+          }
+        }
+        break;
+
+      case "TrackExceptionEvent":
+        this.manager.emit("trackError", player, track, payload.exception as LavalinkException);
+        break;
+
+      case "TrackStuckEvent":
+        this.manager.emit("trackStuck", player, track, payload.thresholdMs as number);
+        break;
+
+      case "WebSocketClosedEvent":
+        this.manager.emit("socketClosed", player, payload.code as number, payload.reason as string);
+        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>;
+  }
+
+  /** 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;
+  }
+
+  /**
+   * 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: [] };
+    }
+  }
+
+  /** 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}`;
+  }
+}

package/src/Player.ts

@@ -0,0 +1,245 @@
+import { Queue } from "./Queue";
+import { Track, PlayerOptions, VoiceState } from "./types";
+import type { Yukimu } from "./Yukimu";
+import type { Node } from "./Node";
+
+export class Player {
+  public readonly manager: Yukimu;
+  public readonly node: Node;
+  public readonly queue: Queue;
+
+  // IDs
+  public readonly guildId: string;
+  public voiceChannelId: string | null;
+  public textChannelId?: string;
+
+  // State
+  public playing: boolean = false;
+  public paused: boolean = false;
+  public connected: boolean = false;
+  public position: number = 0;
+  public ping: number = -1;
+  public volume: number;
+
+  // Voice connection
+  public sessionId: string | null = null;
+  public voiceToken: string | null = null;
+  public voiceEndpoint: string | null = null;
+
+  // Filters
+  public filters: Record<string, unknown> = {};
+
+  // Loop mode
+  public loop: "none" | "track" | "queue" = "none";
+
+  constructor(manager: Yukimu, node: Node, options: PlayerOptions) {
+    this.manager = manager;
+    this.node = node;
+    this.queue = new Queue();
+
+    this.guildId = options.guildId;
+    this.voiceChannelId = options.voiceChannelId;
+    this.textChannelId = options.textChannelId;
+    this.volume = options.volume ?? 100;
+
+    // Send voice channel join payload to Discord
+    this.sendVoicePayload(options.voiceChannelId, options.selfDeaf ?? true, options.selfMute ?? false);
+  }
+
+  // ─── Voice ───────────────────────────────────────────────────────
+
+  private sendVoicePayload(channelId: string | null, selfDeaf: boolean, selfMute: boolean): void {
+    this.manager.sendPayload(this.guildId, {
+      op: 4,
+      d: {
+        guild_id: this.guildId,
+        channel_id: channelId,
+        self_deaf: selfDeaf,
+        self_mute: selfMute,
+      },
+    });
+  }
+
+  /** Called when both sessionId and voiceToken/endpoint are available */
+  public checkVoiceReady(): void {
+    if (!this.sessionId || !this.voiceToken || !this.voiceEndpoint) return;
+
+    const voiceState: VoiceState = {
+      token: this.voiceToken,
+      endpoint: this.voiceEndpoint,
+      sessionId: this.sessionId,
+    };
+
+    this.node
+      .request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+        voice: voiceState,
+      })
+      .catch(console.error);
+  }
+
+  // ─── Playback ─────────────────────────────────────────────────────
+
+  /** Play a track */
+  public async play(track: Track, options?: { startTime?: number; endTime?: number }): Promise<void> {
+    this.queue.current = track;
+
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}?noReplace=false`, {
+      track: { encoded: track.encoded },
+      volume: this.volume,
+      ...(options?.startTime && { position: options.startTime }),
+      ...(options?.endTime && { endTime: options.endTime }),
+    });
+
+    this.playing = true;
+    this.paused = false;
+  }
+
+  /** Pause or resume playback */
+  public async pause(state: boolean = true): Promise<void> {
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+      paused: state,
+    });
+    this.paused = state;
+    this.playing = !state;
+  }
+
+  /** Resume playback */
+  public async resume(): Promise<void> {
+    return this.pause(false);
+  }
+
+  /** Stop playback */
+  public async stop(): Promise<void> {
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+      track: { encoded: null },
+    });
+    this.playing = false;
+    this.paused = false;
+    this.position = 0;
+    this.queue.current = null;
+  }
+
+  /** Skip to next track */
+  public async skip(): Promise<Track | null> {
+    const next = this.queue.next();
+    if (next) {
+      await this.play(next);
+    } else {
+      await this.stop();
+      this.manager.emit("queueEnd", this);
+    }
+    return next;
+  }
+
+  /** Seek to position in milliseconds */
+  public async seek(position: number): Promise<void> {
+    if (!this.queue.current?.info.isSeekable) throw new Error("Current track is not seekable");
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+      position,
+    });
+    this.position = position;
+  }
+
+  /** Set volume (0–1000, Lavalink default 100) */
+  public async setVolume(volume: number): Promise<void> {
+    if (volume < 0 || volume > 1000) throw new Error("Volume must be between 0 and 1000");
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+      volume,
+    });
+    this.volume = volume;
+  }
+
+  // ─── Filters ──────────────────────────────────────────────────────
+
+  /** Apply audio filters (bass boost, nightcore, 8D, etc.) */
+  public async setFilters(filters: Record<string, unknown>): Promise<void> {
+    this.filters = filters;
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+      filters,
+    });
+  }
+
+  /** Enable bass boost */
+  public async setBassBoost(level: "low" | "medium" | "high" | "off"): Promise<void> {
+    const bands: { band: number; gain: number }[] = [];
+    const gains = {
+      off: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      low: [0.2, 0.15, 0.1, 0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      medium: [0.4, 0.3, 0.2, 0.1, 0.05, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+      high: [0.6, 0.5, 0.4, 0.25, 0.1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+    };
+
+    for (let i = 0; i < 15; i++) {
+      bands.push({ band: i, gain: gains[level][i] });
+    }
+
+    await this.setFilters({ ...this.filters, equalizer: bands });
+  }
+
+  /** Enable nightcore effect */
+  public async setNightcore(enabled: boolean): Promise<void> {
+    await this.setFilters({
+      ...this.filters,
+      timescale: enabled ? { speed: 1.2, pitch: 1.2, rate: 1.0 } : {},
+    });
+  }
+
+  /** Enable 8D audio */
+  public async set8D(enabled: boolean): Promise<void> {
+    await this.setFilters({
+      ...this.filters,
+      rotation: enabled ? { rotationHz: 0.2 } : {},
+    });
+  }
+
+  /** Clear all filters */
+  public async clearFilters(): Promise<void> {
+    this.filters = {};
+    await this.node.request("PATCH", `/sessions/${this.node.sessionId}/players/${this.guildId}`, {
+      filters: {},
+    });
+  }
+
+  // ─── Queue Helpers ────────────────────────────────────────────────
+
+  /** Add track(s) to queue and optionally start playing */
+  public async add(tracks: Track | Track[], playNow: boolean = false): Promise<void> {
+    const arr = Array.isArray(tracks) ? tracks : [tracks];
+
+    if (!this.queue.current && arr.length > 0) {
+      const first = arr.shift()!;
+      this.queue.current = first;
+      this.queue.add(arr);
+      await this.play(first);
+    } else {
+      this.queue.add(arr);
+      if (playNow && arr.length > 0) {
+        await this.play(arr[0]);
+      }
+    }
+  }
+
+  /** Set loop mode */
+  public setLoop(mode: "none" | "track" | "queue"): void {
+    this.loop = mode;
+  }
+
+  // ─── Disconnect ───────────────────────────────────────────────────
+
+  /** Disconnect from voice and clean up */
+  public async destroy(): Promise<void> {
+    this.sendVoicePayload(null, false, false);
+    await this.node
+      .request("DELETE", `/sessions/${this.node.sessionId}/players/${this.guildId}`)
+      .catch(() => {});
+    this.playing = false;
+    this.connected = false;
+    this.queue.clear();
+  }
+
+  /** Move to a different voice channel */
+  public async move(channelId: string, selfDeaf: boolean = true): Promise<void> {
+    this.voiceChannelId = channelId;
+    this.sendVoicePayload(channelId, selfDeaf, false);
+  }
+}

package/src/Queue.ts

@@ -0,0 +1,82 @@
+import { Track } from "./types";
+
+export class Queue {
+  public current: Track | null = null;
+  public previous: Track | null = null;
+  private tracks: Track[] = [];
+
+  // ─── Basic Operations ─────────────────────────────────────────────
+
+  /** Add tracks to the end of the queue */
+  public add(tracks: Track | Track[]): void {
+    const arr = Array.isArray(tracks) ? tracks : [tracks];
+    this.tracks.push(...arr);
+  }
+
+  /** Remove and return the next track */
+  public next(): Track | null {
+    if (this.current) this.previous = this.current;
+    this.current = this.tracks.shift() ?? null;
+    return this.current;
+  }
+
+  /** Peek at upcoming tracks without modifying queue */
+  public peek(count: number = 5): Track[] {
+    return this.tracks.slice(0, count);
+  }
+
+  /** Remove a track at a specific index */
+  public remove(index: number): Track | null {
+    if (index < 0 || index >= this.tracks.length) return null;
+    const [removed] = this.tracks.splice(index, 1);
+    return removed;
+  }
+
+  /** Clear all queued tracks (does not affect current) */
+  public clear(): void {
+    this.tracks = [];
+    this.current = null;
+    this.previous = null;
+  }
+
+  // ─── Shuffle ──────────────────────────────────────────────────────
+
+  /** Fisher-Yates shuffle */
+  public shuffle(): void {
+    for (let i = this.tracks.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
+    }
+  }
+
+  // ─── Move / Reorder ───────────────────────────────────────────────
+
+  /** Move a track from one position to another */
+  public move(from: number, to: number): void {
+    if (from < 0 || to < 0 || from >= this.tracks.length || to >= this.tracks.length) return;
+    const [track] = this.tracks.splice(from, 1);
+    this.tracks.splice(to, 0, track);
+  }
+
+  // ─── Getters ──────────────────────────────────────────────────────
+
+  /** Total tracks in queue (not including current) */
+  get size(): number {
+    return this.tracks.length;
+  }
+
+  /** Total duration of all queued tracks in ms */
+  get totalDuration(): number {
+    return this.tracks.reduce((acc, t) => acc + (t.info.length ?? 0), 0);
+  }
+
+  /** Whether the queue is empty */
+  get isEmpty(): boolean {
+    return this.tracks.length === 0;
+  }
+
+  /** All tracks as array (read-only view) */
+  get list(): ReadonlyArray<Track> {
+    return this.tracks;
+  }
+}