ryanlink 1.0.1

package/src/lavalink/ConnectionPool.ts

@@ -0,0 +1,326 @@
+import { EventEmitter } from "node:events";
+import { LavalinkNode } from "./LavalinkConnection";
+import type { Player } from "../core/RyanlinkPlayer";
+import type { NodeOptions, NodeManagerEvents, LavalinkInfo } from "../types/lavalink";
+
+/**
+ * Node metrics for selection and monitoring
+ */
+export interface NodeMetrics {
+    /** Total number of nodes */
+    total: number;
+    /** Number of connected nodes */
+    connected: number;
+    /** Number of ready nodes */
+    ready: number;
+    /** Number of reconnecting nodes */
+    reconnecting: number;
+    /** Total players across all nodes */
+    players: number;
+    /** Total playing players across all nodes */
+    playingPlayers: number;
+}
+
+/**
+ * Manages all Lavalink nodes
+ * Handles node creation, connection, and selection
+ */
+export class NodeManager extends EventEmitter<NodeManagerEvents> {
+    #player: Player;
+    #nodes = new Map<string, LavalinkNode>();
+
+    readonly info = new Map<string, LavalinkInfo>(); // LavalinkInfo cache
+
+    constructor(player: Player) {
+        super({ captureRejections: false });
+        this.#player = player;
+
+        const immutable: PropertyDescriptor = {
+            writable: false,
+            configurable: false,
+        };
+
+        Object.defineProperties(this, {
+            info: immutable,
+        });
+    }
+
+    /**
+     * Get a node by name
+     */
+    get(name: string): LavalinkNode | undefined {
+        return this.#nodes.get(name);
+    }
+
+    /**
+     * Check if a node exists
+     */
+    has(name: string): boolean {
+        return this.#nodes.has(name);
+    }
+
+    /**
+     * Get all nodes
+     */
+    get all(): LavalinkNode[] {
+        return Array.from(this.#nodes.values());
+    }
+
+    /**
+     * Get number of nodes
+     */
+    get size(): number {
+        return this.#nodes.size;
+    }
+
+    /**
+     * Create a new node
+     */
+    create(options: NodeOptions): LavalinkNode {
+        if (this.#nodes.has(options.name)) {
+            throw new Error(`Node '${options.name}' already exists`);
+        }
+
+        const node = new LavalinkNode({
+            ...options,
+            clientId: this.#player.clientId ?? "",
+        });
+
+        // Forward node events
+        node.on("connect", (_attempts, _name) => {
+            this.emit("connect", node);
+        });
+
+        node.on("ready", (resumed, sessionId, _name) => {
+            this.emit("ready", node, resumed, sessionId);
+
+            // Fetch node info on first ready (not on resume)
+            if (!this.info.has(node.name)) {
+                this.fetchInfo(node.name).catch(() => {});
+            }
+
+            if (resumed) {
+                void this.#handleResumed(node);
+            }
+        });
+
+        node.on("disconnect", (code, reason, _byLocal, _name) => {
+            this.emit("disconnect", node, { code, reason });
+        });
+
+        node.on("close", (_code, _reason, _name) => {
+            // Node is reconnecting
+            this.emit("reconnecting", node);
+        });
+
+        node.on("error", (error, _name) => {
+            this.emit("error", node, error);
+        });
+
+        node.on("dispatch", (payload, _name) => {
+            this.emit("raw", node, payload);
+        });
+
+        this.#nodes.set(options.name, node);
+        this.emit("create", node);
+
+        return node;
+    }
+
+    /**
+     * Delete a node
+     */
+    async delete(name: string): Promise<boolean> {
+        const node = this.#nodes.get(name);
+        if (!node) {
+            return false;
+        }
+
+        // Check if node has active queues
+        const activeQueues = this.#player.queues.all.filter((q) => q.node?.name === name);
+        if (activeQueues.length > 0) {
+            throw new Error(`Cannot delete node '${name}' with ${activeQueues.length} active queue(s)`);
+        }
+
+        await node.disconnect();
+        this.#nodes.delete(name);
+        this.info.delete(name);
+        this.emit("destroy", node);
+
+        return true;
+    }
+
+    /**
+     * Connect all nodes
+     */
+    async connect(): Promise<void> {
+        const promises = Array.from(this.#nodes.values()).map((node) => node.connect());
+        await Promise.allSettled(promises);
+    }
+
+    /**
+     * Disconnect all nodes
+     */
+    async disconnect(): Promise<void> {
+        const promises = Array.from(this.#nodes.values()).map((node) => node.disconnect());
+        await Promise.allSettled(promises);
+    }
+
+    /**
+     * Get relevant nodes sorted by load and availability
+     * Returns nodes that are ready and have lowest load
+     */
+    relevant(): LavalinkNode[] {
+        const readyNodes = Array.from(this.#nodes.values()).filter((node) => node.ready);
+
+        if (readyNodes.length === 0) {
+            return [];
+        }
+
+        // Sort by load (players, CPU, memory)
+        return readyNodes.sort((a, b) => {
+            const aStats = a.stats;
+            const bStats = b.stats;
+
+            if (!aStats) {
+                return 1;
+            }
+            if (!bStats) {
+                return -1;
+            }
+
+            // Compare by playing players first
+            const aLoad = aStats.playingPlayers / (aStats.players || 1);
+            const bLoad = bStats.playingPlayers / (bStats.players || 1);
+
+            if (aLoad !== bLoad) {
+                return aLoad - bLoad;
+            }
+
+            // Then by CPU load
+            const aCpu = aStats.cpu.lavalinkLoad;
+            const bCpu = bStats.cpu.lavalinkLoad;
+
+            if (aCpu !== bCpu) {
+                return aCpu - bCpu;
+            }
+
+            // Finally by memory usage
+            const aMemory = aStats.memory.used / aStats.memory.allocated;
+            const bMemory = bStats.memory.used / bStats.memory.allocated;
+
+            return aMemory - bMemory;
+        });
+    }
+
+    /**
+     * Get node metrics
+     */
+    get metrics(): NodeMetrics {
+        const nodes = Array.from(this.#nodes.values());
+
+        return {
+            total: nodes.length,
+            connected: nodes.filter((n) => n.connected).length,
+            ready: nodes.filter((n) => n.ready).length,
+            reconnecting: nodes.filter((n) => n.reconnecting).length,
+            players: nodes.reduce((sum, n) => sum + (n.stats?.players ?? 0), 0),
+            playingPlayers: nodes.reduce((sum, n) => sum + (n.stats?.playingPlayers ?? 0), 0),
+        };
+    }
+
+    /**
+     * Get all node names
+     */
+    keys(): IterableIterator<string> {
+        return this.#nodes.keys();
+    }
+
+    /**
+     * Get all nodes
+     */
+    values(): IterableIterator<LavalinkNode> {
+        return this.#nodes.values();
+    }
+
+    /**
+     * Get all entries
+     */
+    entries(): IterableIterator<[string, LavalinkNode]> {
+        return this.#nodes.entries();
+    }
+
+    /**
+     * Fetch and cache node info
+     * @param name Node name
+     */
+    async fetchInfo(name: string): Promise<LavalinkInfo> {
+        if (this.info.has(name)) {
+            return this.info.get(name) as LavalinkInfo;
+        }
+
+        const node = this.#nodes.get(name);
+        if (!node) {
+            throw new Error(`Node '${name}' not found`);
+        }
+
+        const info = await node.rest.fetchInfo();
+        this.info.set(name, info);
+        return info;
+    }
+
+    /**
+     * Check if a feature is supported by a node
+     * @param type Feature type (filter, source, plugin)
+     * @param value Feature value (name)
+     * @param nodeName Optional node name (checks all if not specified)
+     */
+    supports(type: "filter" | "source" | "plugin", value: string, nodeName?: string): boolean {
+        if (nodeName) {
+            const node = this.#nodes.get(nodeName);
+            if (!node) {
+                return false;
+            }
+            return this.#checkNodeSupport(node.name, type, value);
+        }
+
+        // Check if any node supports it
+        return Array.from(this.#nodes.values()).some((node) => this.#checkNodeSupport(node.name, type, value));
+    }
+
+    /**
+     * Check if a specific node supports a feature
+     */
+    #checkNodeSupport(nodeName: string, type: "filter" | "source" | "plugin", value: string): boolean {
+        const info = this.info.get(nodeName);
+        if (!info) {
+            return false;
+        }
+
+        switch (type) {
+            case "filter":
+                return info.filters?.includes(value) ?? false;
+            case "source":
+                return info.sourceManagers?.includes(value) ?? false;
+            case "plugin":
+                return info.plugins?.some((p: { name: string }) => p.name === value) ?? false;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Handle node resumption
+     * Sync all queues when a node resumes
+     */
+    async #handleResumed(node: LavalinkNode): Promise<void> {
+        try {
+            // Sync queues if autoSync is enabled
+            if (this.#player.options.autoSync) {
+                await this.#player.queues.syncAll();
+            }
+        } catch (error) {
+            this.emit("error", node, error as Error);
+        }
+    }
+}

package/src/lavalink/HttpClient.ts

@@ -0,0 +1,316 @@
+import { Routes } from "../config/endpoints";
+import { CLIENT_NAME, CLIENT_VERSION, CLIENT_REPOSITORY } from "../metadata";
+import type {
+    RESTOptions,
+    LoadResult,
+    APIPlayer,
+    PlayerUpdateRequestBody,
+    PlayerUpdateQueryParams,
+    SessionUpdateRequestBody,
+    SessionUpdateResponseBody,
+    LavalinkInfo,
+    NodeStats,
+    RoutePlannerStatus,
+    APITrack,
+} from "../types";
+
+/**
+ * REST client for Lavalink HTTP API
+ * Uses native fetch for better performance
+ */
+export class REST {
+    #origin: string;
+    #headers: Record<string, string>;
+    #sessionId: string | null = null;
+    #requestTimeout: number;
+
+    readonly userAgent: string;
+
+    constructor(options: RESTOptions) {
+        if (options.origin) {
+            if (!options.origin.startsWith("http://") && !options.origin.startsWith("https://")) {
+                throw new Error("Origin must start with http:// or https://");
+            }
+            this.#origin = options.origin;
+        } else {
+            const protocol = options.secure ? "https" : "http";
+            const port = options.port ?? 2333;
+            const host = options.host ?? "localhost";
+            this.#origin = `${protocol}://${host}:${port}`;
+        }
+
+        if (options.version !== undefined && options.version <= 0) {
+            throw new Error("Version must be a positive number");
+        }
+
+        if (options.password.includes("\n") || options.password.includes("\r")) {
+            throw new Error("Password cannot contain newline characters");
+        }
+
+        const userAgent = options.userAgent ?? `${CLIENT_NAME}/${CLIENT_VERSION} (${CLIENT_REPOSITORY})`;
+        if (userAgent.includes("\n") || userAgent.includes("\r")) {
+            throw new Error("User agent cannot contain newline characters");
+        }
+        this.userAgent = userAgent;
+
+        const requestTimeout = options.requestTimeout ?? 10_000;
+        if (requestTimeout <= 0) {
+            throw new Error("Request timeout must be a positive number");
+        }
+        this.#requestTimeout = requestTimeout;
+
+        this.#headers = {
+            Authorization: options.password,
+            "User-Agent": this.userAgent,
+            "Content-Type": "application/json",
+        };
+
+        if (options.sessionId) {
+            this.#sessionId = options.sessionId;
+        }
+    }
+
+    get origin(): string {
+        return this.#origin;
+    }
+
+    get sessionId(): string | null {
+        return this.#sessionId;
+    }
+
+    set sessionId(value: string | null) {
+        if (value !== null && (typeof value !== "string" || value.trim() === "")) {
+            return;
+        }
+        this.#sessionId = value;
+    }
+
+    /**
+     * Make a request to the Lavalink REST API
+     */
+    async #request<T>(path: string, options: RequestInit = {}, timeout?: number): Promise<T> {
+        const url = `${this.#origin}${path}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout ?? this.#requestTimeout);
+
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    ...this.#headers,
+                    ...options.headers,
+                },
+                signal: controller.signal,
+            });
+
+            clearTimeout(timeoutId);
+
+            if (!response.ok) {
+                const error = await this.#parseError(response);
+                throw error;
+            }
+
+            // Handle 204 No Content
+            if (response.status === 204) {
+                return undefined as T;
+            }
+
+            return (await response.json()) as T;
+        } catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`Request timeout after ${timeout ?? this.#requestTimeout}ms`);
+            }
+            throw error;
+        }
+    }
+
+    async #parseError(response: Response): Promise<Error> {
+        let message = `HTTP ${response.status}: ${response.statusText}`;
+
+        try {
+            const data = (await response.json()) as { error?: string; message?: string };
+            if (data.error) {
+                message = data.error;
+            } else if (data.message) {
+                message = data.message;
+            }
+        } catch {
+            // Use default message
+        }
+
+        const error = new Error(message);
+        error.name = "LavalinkRestError";
+        return error;
+    }
+
+    /**
+     * Load tracks from a query or URL
+     */
+    async loadTracks(identifier: string): Promise<LoadResult> {
+        const path = `${Routes.trackLoading()}?identifier=${encodeURIComponent(identifier)}`;
+        return this.#request<LoadResult>(path, { method: "GET" });
+    }
+
+    /**
+     * Decode a single track
+     */
+    async decodeTrack(encoded: string): Promise<APITrack> {
+        const path = `${Routes.trackDecoding()}?encodedTrack=${encodeURIComponent(encoded)}`;
+        return this.#request<APITrack>(path, { method: "GET" });
+    }
+
+    /**
+     * Decode multiple tracks
+     */
+    async decodeTracks(encoded: string[]): Promise<APITrack[]> {
+        return this.#request<APITrack[]>(Routes.trackDecoding(true), {
+            method: "POST",
+            body: JSON.stringify(encoded),
+        });
+    }
+
+    /**
+     * Fetch all players for a session
+     */
+    async fetchPlayers(): Promise<APIPlayer[]> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<APIPlayer[]>(Routes.player(this.#sessionId), { method: "GET" });
+    }
+
+    /**
+     * Fetch a specific player
+     */
+    async fetchPlayer(guildId: string): Promise<APIPlayer> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<APIPlayer>(Routes.player(this.#sessionId, guildId), { method: "GET" });
+    }
+
+    /**
+     * Update a player
+     */
+    async updatePlayer(
+        guildId: string,
+        data: PlayerUpdateRequestBody,
+        params?: PlayerUpdateQueryParams,
+    ): Promise<APIPlayer> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+
+        let path = Routes.player(this.#sessionId, guildId);
+        if (params?.noReplace) {
+            path += "?noReplace=true";
+        }
+
+        return this.#request<APIPlayer>(path, {
+            method: "PATCH",
+            body: JSON.stringify(data),
+        });
+    }
+
+    /**
+     * Destroy a player
+     */
+    async destroyPlayer(guildId: string): Promise<void> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<void>(Routes.player(this.#sessionId, guildId), { method: "DELETE" });
+    }
+
+    /**
+     * Update session configuration
+     */
+    async updateSession(data: SessionUpdateRequestBody): Promise<SessionUpdateResponseBody> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<SessionUpdateResponseBody>(Routes.session(this.#sessionId), {
+            method: "PATCH",
+            body: JSON.stringify(data),
+        });
+    }
+
+    /**
+     * Fetch Lavalink server info
+     */
+    async fetchInfo(): Promise<LavalinkInfo> {
+        return this.#request<LavalinkInfo>(Routes.info(), { method: "GET" });
+    }
+
+    /**
+     * Fetch node statistics
+     */
+    async fetchStats(): Promise<NodeStats> {
+        return this.#request<NodeStats>(Routes.stats(), { method: "GET" });
+    }
+
+    /**
+     * Fetch Lavalink version
+     */
+    async fetchVersion(): Promise<string> {
+        return this.#request<string>("/version", { method: "GET" });
+    }
+
+    /**
+     * Fetch route planner status
+     */
+    async fetchRoutePlannerStatus(): Promise<RoutePlannerStatus> {
+        return this.#request<RoutePlannerStatus>(Routes.routePlanner(), { method: "GET" });
+    }
+
+    /**
+     * Free a specific address from the route planner
+     */
+    async freeRoutePlannerAddress(address: string): Promise<void> {
+        return this.#request<void>(Routes.routePlanner("address"), {
+            method: "POST",
+            body: JSON.stringify({ address }),
+        });
+    }
+
+    /**
+     * Free all addresses from the route planner
+     */
+    async freeAllRoutePlannerAddresses(): Promise<void> {
+        return this.#request<void>(Routes.routePlanner("all"), { method: "POST" });
+    }
+
+    /**
+     * Set SponsorBlock segments for a player
+     */
+    async setSponsorBlock(guildId: string, segments: string[]): Promise<void> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<void>(`${Routes.player(this.#sessionId, guildId)}/sponsorblock`, {
+            method: "PATCH",
+            body: JSON.stringify(segments),
+        });
+    }
+
+    /**
+     * Get current SponsorBlock segments for a player
+     */
+    async getSponsorBlock(guildId: string): Promise<string[]> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<string[]>(`${Routes.player(this.#sessionId, guildId)}/sponsorblock`, { method: "GET" });
+    }
+
+    /**
+     * Delete SponsorBlock configuration for a player
+     */
+    async deleteSponsorBlock(guildId: string): Promise<void> {
+        if (!this.#sessionId) {
+            throw new Error("No session ID available");
+        }
+        return this.#request<void>(`${Routes.player(this.#sessionId, guildId)}/sponsorblock`, { method: "DELETE" });
+    }
+}