yukimu 1.2.0 → 2.0.0

package/.local/state/workflow-logs/7zVU0iVo-fBL1ccMCmELy/configure_your_app.packager.installForAll.0

@@ -1,9 +0,0 @@
---> npm install
-⠙⠹⠸⠼⠴
-up to date, audited 28 packages in 657ms
-⠴
-⠴7 packages are looking for funding
-⠴  run `npm fund` for details
-⠴
-found 0 vulnerabilities
-⠴

package/.local/state/workflow-logs/7zVU0iVo-fBL1ccMCmELy/configure_your_app.shell.exec.1

@@ -1 +0,0 @@
-Please use the Workflows pane to configure your app. For more info, see: https://docs.replit.com/replit-workspace/workflows#creating-workflows

package/.local/state/workflow-logs/KRgHXizaECjWI5nWtS7Dj/configure_your_app.packager.installForAll.0

@@ -1 +0,0 @@
-

package/.local/state/workflow-logs/KRgHXizaECjWI5nWtS7Dj/configure_your_app.shell.exec.1

@@ -1 +0,0 @@
-Please use the Workflows pane to configure your app. For more info, see: https://docs.replit.com/replit-workspace/workflows#creating-workflows

package/.local/state/workflow-logs/U0AinJQVHonnwGjj0RXLn/configure_your_app.packager.installForAll.0

@@ -1,2 +0,0 @@
---> npm install
-⠙⠹

package/.local/state/workflow-logs/jVavLOnv1MqxUvxhMmqER/configure_your_app.packager.installForAll.0

@@ -1 +0,0 @@
-

package/.local/state/workflow-logs/jVavLOnv1MqxUvxhMmqER/configure_your_app.shell.exec.1

@@ -1 +0,0 @@
-Please use the Workflows pane to configure your app. For more info, see: https://docs.replit.com/replit-workspace/workflows#creating-workflows

package/.replit

@@ -1,7 +0,0 @@
-modules = ["nodejs-20", "python-3.11"]
-
-[agent]
-expertMode = true
-
-[nix]
-packages = ["zip"]

package/.upm/store.json

@@ -1 +0,0 @@
-{"version":2,"languages":{"nodejs-npm":{},"python3-uv":{}}}

package/src/ConnectionPool.ts

@@ -1,131 +0,0 @@
-import type { Yukimu } from "./Yukimu";
-
-export interface VoiceConnection {
-  guildId: string;
-  channelId: string;
-  sessionId: string | null;
-  token: string | null;
-  endpoint: string | null;
-  timeout: ReturnType<typeof setTimeout> | null;
-  retryTimeout: ReturnType<typeof setTimeout> | null;
-  connected: boolean;
-  retries: number;
-}
-
-const MAX_VOICE_RETRIES = 3;
-const VOICE_RETRY_DELAY = 5000;
-
-export class ConnectionPool {
-  private readonly manager: Yukimu;
-  private readonly connections: Map<string, VoiceConnection> = new Map();
-
-  constructor(manager: Yukimu) {
-    this.manager = manager;
-  }
-
-  public add(guildId: string, channelId: string): VoiceConnection {
-    const existing = this.connections.get(guildId);
-    if (existing) { existing.channelId = channelId; return existing; }
-
-    const conn: VoiceConnection = {
-      guildId, channelId,
-      sessionId: null, token: null, endpoint: null,
-      timeout: null, retryTimeout: null,
-      connected: false, retries: 0,
-    };
-    this.connections.set(guildId, conn);
-    this.startTimeout(conn);
-    return conn;
-  }
-
-  public get(guildId: string): VoiceConnection | undefined {
-    return this.connections.get(guildId);
-  }
-
-  public remove(guildId: string): void {
-    const conn = this.connections.get(guildId);
-    if (!conn) return;
-    if (conn.timeout) clearTimeout(conn.timeout);
-    if (conn.retryTimeout) clearTimeout(conn.retryTimeout);
-    this.connections.delete(guildId);
-  }
-
-  public has(guildId: string): boolean {
-    return this.connections.has(guildId);
-  }
-
-  public updateSession(guildId: string, sessionId: string, channelId?: string): void {
-    const conn = this.connections.get(guildId);
-    if (!conn) return;
-    conn.sessionId = sessionId;
-    if (channelId) conn.channelId = channelId;
-  }
-
-  public updateServer(guildId: string, token: string, endpoint: string): void {
-    const conn = this.connections.get(guildId);
-    if (!conn) return;
-    conn.token = token;
-    conn.endpoint = endpoint;
-  }
-
-  public markConnected(guildId: string): void {
-    const conn = this.connections.get(guildId);
-    if (!conn) return;
-    conn.connected = true;
-    conn.retries = 0;
-    if (conn.timeout) { clearTimeout(conn.timeout); conn.timeout = null; }
-    if (conn.retryTimeout) { clearTimeout(conn.retryTimeout); conn.retryTimeout = null; }
-  }
-
-  public isReady(guildId: string): boolean {
-    const conn = this.connections.get(guildId);
-    return !!(conn?.sessionId && conn?.token && conn?.endpoint);
-  }
-
-  public getVoiceState(guildId: string): { token: string; endpoint: string; sessionId: string } | null {
-    const conn = this.connections.get(guildId);
-    if (!conn?.sessionId || !conn?.token || !conn?.endpoint) return null;
-    return { token: conn.token, endpoint: conn.endpoint, sessionId: conn.sessionId };
-  }
-
-  private startTimeout(conn: VoiceConnection): void {
-    const timeoutMs = (this.manager.options as { voiceConnectionTimeout?: number }).voiceConnectionTimeout ?? 15000;
-    if (conn.timeout) clearTimeout(conn.timeout);
-    conn.timeout = setTimeout(() => {
-      if (!conn.connected) this.handleConnectionFailure(conn);
-    }, timeoutMs);
-  }
-
-  private handleConnectionFailure(conn: VoiceConnection): void {
-    if (conn.retries >= MAX_VOICE_RETRIES) {
-      const player = this.manager.players.get(conn.guildId);
-      if (player) {
-        (this.manager as any).emit("playerError", player, new Error(`Voice connection failed after ${MAX_VOICE_RETRIES} retries`));
-        this.manager.destroyPlayer(conn.guildId).catch(() => {});
-      }
-      this.remove(conn.guildId);
-      return;
-    }
-
-    conn.retries++;
-    const player = this.manager.players.get(conn.guildId);
-    if (player) {
-      console.warn(`[Yukimu] 🔄 Voice retry ${conn.retries}/${MAX_VOICE_RETRIES} for guild ${conn.guildId}`);
-      conn.retryTimeout = setTimeout(() => {
-        // Re-send join payload via connector
-        this.manager.connector.sendPayload(conn.guildId, {
-          op: 4,
-          d: {
-            guild_id: conn.guildId,
-            channel_id: conn.channelId,
-            self_deaf: true,
-            self_mute: false,
-          },
-        });
-        this.startTimeout(conn);
-      }, VOICE_RETRY_DELAY * conn.retries);
-    }
-  }
-
-  get size(): number { return this.connections.size; }
-}

package/src/Constants.ts

@@ -1,101 +0,0 @@
-/** 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,309 +0,0 @@
-import WebSocket from "ws";
-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 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;
-
-  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, resumeTimeout: 60, ...options };
-    this.version = (this.options.version ?? 4) as 3 | 4;
-    this.rest = new Rest(this);
-    this.wsQueue = new WsQueue();
-  }
-
-  get connected(): boolean {
-    return this.state === State.CONNECTED || this.state === State.NEARLY;
-  }
-
-  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;
-  }
-
-  get wsHeaders(): Record<string, string> {
-    const h: Record<string, string> = {
-      Authorization: this.options.password,
-      "User-Id": this.manager.options.clientId,
-      "Client-Name": "Yukimu/1.2.0",
-    };
-    if (this.version === 3) h["Num-Shards"] = "1";
-    if (this.options.resumeKey) h["Resume-Key"] = this.options.resumeKey;
-    return h;
-  }
-
-  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.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", (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(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(WS_CLOSE_NORMAL, "destroy");
-    this.ws = null;
-    this.state = State.DISCONNECTED;
-    if (!reconnect) this.sessionId = null;
-  }
-
-  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 (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(() => {});
-    }
-
-    if (this.version === 3) {
-      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; }
-    const op = payload.op as string;
-
-    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} | 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);
-          break;
-        case "event":
-          this.handleEvent(payload);
-          break;
-      }
-      return;
-    }
-
-    switch (op) {
-      case "stats":
-        this.stats = payload as unknown as NodeStats;
-        this.calculatePenalties();
-        break;
-      case "playerUpdate":
-        this.handlePlayerUpdate(payload);
-        break;
-      case "event":
-        this.handleEvent(payload);
-        break;
-    }
-  }
-
-  private onClose(code: number, reason: string): void {
-    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 || "No reason"}`);
-    if (code !== WS_CLOSE_NORMAL) this.scheduleReconnect();
-    else this.movePlayers();
-  }
-
-  private onError(error: Error): void {
-    this.manager.emit("nodeError", this, error);
-    console.error(`[Yukimu] Node "${this.options.name}" error:`, error.message);
-  }
-
-  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 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 * Math.pow(2, this.reconnectAttempts), 30000);
-    this.reconnectAttempts++;
-    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);
-  }
-
-  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; 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);
-  }
-
-  private handleEvent(payload: Record<string, unknown>): void {
-    const player = this.manager.players.get(payload.guildId as string);
-    if (!player) return;
-
-    let track: Track;
-    if (this.version === 3) {
-      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": {
-        const reason = payload.reason as string;
-        player.playing = false;
-        player.position = 0;
-        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 {
-            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);
-        break;
-
-      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, payload.byRemote as boolean);
-        break;
-    }
-  }
-
-  public send(data: Record<string, unknown>): Promise<void> {
-    return this.wsQueue.send(data);
-  }
-
-  public enqueueRest<T>(fn: () => Promise<T>): Promise<T> {
-    const result = this.restQueue.then(() => fn());
-    this.restQueue = result.catch(() => {});
-    return result;
-  }
-
-  public async loadTracks(identifier: string): Promise<SearchResult> {
-    return this.rest.loadTracks(identifier);
-  }
-
-  public playerPath(guildId: string): string {
-    return this.version === 4
-      ? `/sessions/${this.sessionId}/players/${guildId}`
-      : `/players/${guildId}`;
-  }
-}