ryanlink 1.0.1

package/src/core/RyanlinkPlayer.ts

@@ -0,0 +1,403 @@
+import { EventEmitter } from "node:events";
+import { LoadType, type APITrack } from "../types/api/Rest";
+import { DefaultPlayerOptions } from "../config";
+import { isString } from "../utils";
+import { NodeManager } from "../lavalink/ConnectionPool";
+import { VoiceManager } from "../voice/VoiceConnection";
+import { Playlist, Queue, QueueManager, Track } from "../audio";
+import { PlayerPlugin } from "./PluginSystem";
+import type {
+    CreateQueueOptions,
+    PlayerEventMap,
+    PlayerOptions,
+    PlayOptions,
+    PluginRecord,
+    RepeatMode,
+    SearchOptions,
+    SearchResult,
+    CreateNodeOptions,
+    PlayerInstanceOptions,
+    QueueContext,
+    PluginEventMap,
+    MergeUnionType,
+} from "../types";
+
+/**
+ * Constrain event map to ensure all values are arrays
+ */
+type ConstrainEventMap<T> = {
+    [K in keyof T]: T[K] extends unknown[] ? T[K] : never;
+};
+
+/**
+ * Main Player class - entry point for Ryanlink
+ * Manages nodes, voices, queues, and plugins
+ */
+export class Player<
+    Context extends Record<string, unknown> = QueueContext,
+    Plugins extends PlayerPlugin[] = [],
+> extends EventEmitter<ConstrainEventMap<PlayerEventMap & MergeUnionType<PluginEventMap<Plugins[number]>>>> {
+    #initialized = false;
+    #initPromise: Promise<void> | null = null;
+
+    #clientId: string | null = null;
+    #nodes: CreateNodeOptions[] | null = null;
+
+    readonly options: PlayerInstanceOptions;
+    readonly plugins: PluginRecord<Plugins>;
+
+    readonly nodes: NodeManager;
+    readonly voices: VoiceManager;
+    readonly queues: QueueManager<Context>;
+
+    constructor(options: PlayerOptions<Plugins>) {
+        super({ captureRejections: false });
+
+        const _options = { ...DefaultPlayerOptions, ...options };
+
+        if (_options.nodes.length === 0) {
+            throw new Error("Missing node create options");
+        }
+        if (typeof _options.forwardVoiceUpdate !== "function") {
+            throw new Error("Missing voice update function");
+        }
+
+        this.#nodes = _options.nodes;
+        delete (_options as Partial<typeof _options>).nodes;
+
+        this.options = _options;
+        this.plugins = {} as PluginRecord<Plugins>;
+
+        if (_options.plugins !== undefined) {
+            for (const plugin of _options.plugins) {
+                if (!(plugin instanceof PlayerPlugin)) {
+                    throw new Error("Invalid plugin(s)");
+                }
+                (this.plugins as { [x: string]: PlayerPlugin })[plugin.name] = plugin;
+            }
+            delete _options.plugins;
+        }
+
+        this.nodes = new NodeManager(this as unknown as Player);
+        this.voices = new VoiceManager(this as unknown as Player);
+        this.queues = new QueueManager(this as unknown as Player);
+
+        const immutable: PropertyDescriptor = {
+            writable: false,
+            configurable: false,
+        };
+
+        Object.defineProperties(this, {
+            options: immutable,
+            plugins: immutable,
+            nodes: immutable,
+            voices: immutable,
+            queues: immutable,
+        } satisfies { [k in keyof Player]?: PropertyDescriptor });
+    }
+
+    /**
+     * Whether the player is initialized and ready
+     */
+    get ready(): boolean {
+        return this.#initialized;
+    }
+
+    /**
+     * The bot's client ID
+     */
+    get clientId(): string | null {
+        return this.#clientId;
+    }
+
+    /**
+     * Initialize the player
+     * @param clientId Bot client ID
+     */
+    async init(clientId: string): Promise<void> {
+        if (this.#initialized) {
+            return;
+        }
+
+        if (this.#initPromise !== null) {
+            return this.#initPromise;
+        }
+
+        let resolve!: (value: void | PromiseLike<void>) => void;
+        let reject!: (reason?: unknown) => void;
+        const promise = new Promise<void>((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+
+        this.#initPromise = promise;
+        this.#clientId = clientId;
+
+        try {
+            const nodes = this.#nodes ?? [];
+            for (const node of nodes) {
+                this.nodes.create({ ...node, clientId });
+            }
+
+            // Initialize all plugins
+            for (const name in this.plugins) {
+                (this.plugins as Record<string, PlayerPlugin>)[name].init(this as unknown as Player);
+            }
+
+            // Connect to all nodes
+            await this.nodes.connect();
+
+            this.#initialized = true;
+            this.#nodes = null;
+            (this as EventEmitter).emit("init");
+            resolve();
+        } catch (err) {
+            reject(err);
+            throw err;
+        } finally {
+            this.#initPromise = null;
+        }
+    }
+
+    /**
+     * Returns the queue of a guild
+     * @param guildId Id of the guild
+     */
+    getQueue(guildId: string): Queue<Context> | undefined {
+        return this.queues.get(guildId);
+    }
+
+    /**
+     * Creates a queue from options
+     * @param options Options to create from
+     */
+    async createQueue(options: CreateQueueOptions<Context>): Promise<Queue<Context>> {
+        return this.queues.create(options);
+    }
+
+    /**
+     * Destroys the queue of a guild
+     * @param guildId Id of the guild
+     * @param reason Reason for destroying
+     */
+    async destroyQueue(guildId: string, reason?: string): Promise<void> {
+        return this.queues.destroy(guildId, reason);
+    }
+
+    /**
+     * Searches for results based on query and options
+     * @param query Query (or URL as well)
+     * @param options Options for customization
+     */
+    async search(query: string, options?: SearchOptions): Promise<SearchResult> {
+        if (!isString(query, "non-empty")) {
+            throw new Error("Query must be a non-empty string");
+        }
+
+        const node = options?.node !== undefined ? this.nodes.get(options.node) : this.nodes.relevant()[0];
+        if (!node) {
+            if (options?.node === undefined) {
+                throw new Error("No nodes available");
+            }
+            throw new Error(`Node '${options.node}' not found`);
+        }
+
+        const prefix = options?.prefix ?? this.options.queryPrefix;
+        query = isString(query, "url") ? query : `${String(prefix)}:${String(query)} `;
+        const result = await node.rest.loadTracks(query);
+
+        switch (result.loadType) {
+            case LoadType.Empty:
+                return { type: "empty", data: [] };
+            case LoadType.Error:
+                return { type: "error", data: result.data };
+            case LoadType.Playlist:
+                return { type: "playlist", data: new Playlist(result.data) };
+            case LoadType.Search:
+                return { type: "query", data: result.data.map((t: APITrack) => new Track(t)) };
+            case LoadType.Track:
+                return { type: "track", data: new Track(result.data) };
+            default:
+                throw new Error(`Unexpected load result type from node '${node.name}'`);
+        }
+    }
+
+    /**
+     * Adds or searches if source is query and resumes the queue if stopped
+     * @param source Source to play from
+     * @param options Options for customization
+     */
+    async play(source: string | Parameters<Queue["add"]>[0], options: PlayOptions<Context>): Promise<Queue<Context>> {
+        let queue = this.queues.get(options.guildId);
+
+        if (typeof source === "string") {
+            let result: SearchResult;
+            if (!queue) {
+                result = await this.search(source, options);
+            } else {
+                result = await queue.search(source, options.prefix);
+            }
+
+            if (result.type === "empty") {
+                throw new Error(`No results found for '${source}'`);
+            }
+            if (result.type === "error") {
+                throw new Error(result.data.message ?? result.data.cause, { cause: result.data });
+            }
+
+            source = result.type === "query" ? result.data[0] : result.data;
+        }
+
+        queue ??= await this.queues.create(options);
+
+        if (options.context !== undefined) {
+            Object.assign(queue.context, options.context);
+        }
+
+        queue.add(source, options.userData);
+
+        if (queue.stopped) {
+            await queue.resume();
+        }
+
+        return queue;
+    }
+
+    /**
+     * Jumps to the specified index in queue of a guild
+     * @param guildId Id of the guild
+     * @param index Index to jump to
+     */
+    async jump(guildId: string, index: number): Promise<Track> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.jump(index);
+    }
+
+    /**
+     * Pauses the queue of a guild
+     * @param guildId Id of the guild
+     */
+    async pause(guildId: string): Promise<boolean> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.pause();
+    }
+
+    /**
+     * Plays the previous track in queue of a guild
+     * @param guildId Id of the guild
+     */
+    async previous(guildId: string): Promise<Track | null> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.previous();
+    }
+
+    /**
+     * Resumes the queue of a guild
+     * @param guildId Id of the guild
+     */
+    async resume(guildId: string): Promise<boolean> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.resume();
+    }
+
+    /**
+     * Seeks to a position in the current track of a guild
+     * @param guildId Id of the guild
+     * @param ms Position in milliseconds
+     */
+    async seek(guildId: string, ms: number): Promise<number> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.seek(ms);
+    }
+
+    /**
+     * Enables or disables autoplay for the queue of a guild
+     * @param guildId Id of the guild
+     * @param autoplay Whether to enable autoplay
+     */
+    setAutoplay(guildId: string, autoplay?: boolean): boolean {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.setAutoplay(autoplay);
+    }
+
+    /**
+     * Sets the repeat mode for the queue of a guild
+     * @param guildId Id of the guild
+     * @param repeatMode The repeat mode
+     */
+    setRepeatMode(guildId: string, repeatMode: RepeatMode): RepeatMode {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.setRepeatMode(repeatMode);
+    }
+
+    /**
+     * Sets the volume of the queue of a guild
+     * @param guildId Id of the guild
+     * @param volume The volume to set
+     */
+    async setVolume(guildId: string, volume: number): Promise<number> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.setVolume(volume);
+    }
+
+    /**
+     * Shuffles tracks for the queue of a guild
+     * @param guildId Id of the guild
+     * @param includePrevious Whether to pull previous tracks to current
+     */
+    shuffle(guildId: string, includePrevious?: boolean): Queue<Context> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.shuffle(includePrevious);
+    }
+
+    /**
+     * Plays the next track in queue of a guild
+     * @param guildId Id of the guild
+     */
+    async next(guildId: string): Promise<Track | null> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.next();
+    }
+
+    /**
+     * Stops the queue of a guild
+     * @param guildId Id of the guild
+     */
+    async stop(guildId: string): Promise<void> {
+        const queue = this.queues.get(guildId);
+        if (!queue) {
+            throw new Error(`No queue found for guild '${guildId}'`);
+        }
+        return queue.stop();
+    }
+}

package/src/core/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Core exports - RyanlinkPlayer and PluginSystem
+ */
+
+export * from "./PluginSystem";
+export * from "./RyanlinkPlayer";

package/src/extensions/AutoplayExtension.ts

@@ -0,0 +1,283 @@
+import { PlayerPlugin } from "../core/PluginSystem";
+import type { Player } from "../core/RyanlinkPlayer";
+import type { Track } from "../audio/AudioTrack";
+import { Queue } from "../audio/AudioQueue";
+import { LoadType, type LoadResult } from "../types/api/Rest";
+
+interface PlayerWithGet extends Player {
+    get?<T>(key: string): T;
+}
+
+export interface AutoplayConfig {
+    enabled: boolean;
+    minPlayTime: number;
+    sources: {
+        spotify: boolean;
+        youtube: boolean;
+        youtubemusic: boolean;
+        soundcloud: boolean;
+    };
+    limit: number;
+    /** Filter out tracks shorter than this (ms) */
+    minDuration: number;
+    /** Filter out tracks longer than this (ms) */
+    maxDuration: number;
+    /** Filter out specific keywords in titles */
+    excludeKeywords: string[];
+}
+
+/**
+ * Autoplay Plugin - Automatically adds related tracks when queue ends
+ * Uses Player's existing events - no separate event system
+ */
+export class AutoplayPlugin extends PlayerPlugin {
+    readonly name = "autoplay" as const;
+
+    #player!: Player;
+    #adding = new Set<string>(); // Track which guilds are currently adding
+
+    init(player: Player): void {
+        this.#player = player;
+
+        // Listen to queue finish event
+        player.on("queueFinish", (queue) => {
+            void this.#handleQueueFinish(queue);
+        });
+    }
+
+    async #handleQueueFinish(queue: Queue): Promise<void> {
+        const lastTrack = queue.previousTrack;
+        if (!lastTrack) {
+            return;
+        }
+
+        const config = (queue.player as PlayerWithGet).get?.<AutoplayConfig>(`autoplay_config_${queue.guildId}`) ?? {
+            enabled: true,
+            minPlayTime: 10000,
+            sources: {
+                spotify: true,
+                youtube: true,
+                youtubemusic: true,
+                soundcloud: false,
+            },
+            limit: 5,
+            minDuration: 20000,
+            maxDuration: 900000,
+            excludeKeywords: ["nightcore", "bass boosted", "8d audio", "slowed", "reverb"],
+        };
+
+        if (!config.enabled) {
+            return;
+        }
+
+        // Prevent concurrent autoplay
+        if (this.#adding.has(queue.guildId)) {
+            return;
+        }
+        this.#adding.add(queue.guildId);
+
+        try {
+            const playedData = this.#buildPlayedData(queue);
+            const relatedTracks = await this.#fetchRelatedTracks(queue, lastTrack, config, playedData);
+
+            if (relatedTracks.length > 0) {
+                for (const relatedTrack of relatedTracks) {
+                    if (!relatedTrack.pluginInfo) {
+                        relatedTrack.pluginInfo = {};
+                    }
+                    relatedTrack.pluginInfo.fromAutoplay = true;
+
+                    relatedTrack.userData.requester = {
+                        id: this.#player.clientId ?? "autoplay",
+                        username: "Autoplay",
+                    };
+
+                    queue.add(relatedTrack);
+                }
+
+                if (queue.stopped && queue.tracks.length > 0) {
+                    await queue.resume();
+                }
+            }
+        } catch (error) {
+            this.#player.emit("debug", "autoplay", {
+                message: `Autoplay failed: ${(error as Error).message}`,
+                state: "error",
+                error: error as Error,
+                functionLayer: "AutoplayPlugin",
+            });
+        } finally {
+            this.#adding.delete(queue.guildId);
+        }
+    }
+
+    #buildPlayedData(queue: Queue): {
+        playedIds: Set<string>;
+        playedTracks: Set<string>;
+    } {
+        const playedIds = new Set<string>();
+        const playedTracks = new Set<string>();
+
+        const addTrack = (track: Track) => {
+            if (track.info.identifier) {
+                playedIds.add(track.info.identifier);
+            }
+            if (track.info.isrc) {
+                playedIds.add(track.info.isrc);
+            }
+            if (track.info.title && track.info.author) {
+                const key = `${track.info.title.toLowerCase()}|${track.info.author.toLowerCase()}`;
+                playedTracks.add(key);
+            }
+        };
+
+        if (queue.track) {
+            addTrack(queue.track);
+        }
+        queue.previousTracks.forEach(addTrack);
+        queue.tracks.forEach(addTrack);
+
+        return { playedIds, playedTracks };
+    }
+
+    async #fetchRelatedTracks(
+        queue: Queue,
+        lastTrack: Track,
+        config: AutoplayConfig,
+        playedData: { playedIds: Set<string>; playedTracks: Set<string> },
+    ): Promise<Track[]> {
+        const tracks: Track[] = [];
+        const source = lastTrack.info.sourceName?.toLowerCase();
+
+        if (config.sources.spotify && source?.includes("spotify")) {
+            const spotifyTracks = await this.#getSpotifyRecommendations(queue, lastTrack);
+            tracks.push(...spotifyTracks);
+
+            if (tracks.length < config.limit) {
+                const artistTracks = await this.#getSpotifyArtistSearch(queue, lastTrack);
+                tracks.push(...artistTracks);
+            }
+        }
+
+        if (tracks.length < config.limit && config.sources.youtube && source?.includes("youtube")) {
+            const youtubeTracks = await this.#getYouTubeSimilar(queue, lastTrack);
+            tracks.push(...youtubeTracks);
+
+            if (tracks.length < config.limit) {
+                const artistTracks = await this.#getYouTubeArtist(queue, lastTrack);
+                tracks.push(...artistTracks);
+            }
+        }
+
+        if (tracks.length === 0 && config.sources.youtube) {
+            const youtubeTracks = await this.#getYouTubeSimilar(queue, lastTrack);
+            tracks.push(...youtubeTracks);
+        }
+
+        return this.#filterAutoplayTracks(tracks, playedData, config);
+    }
+
+    #filterAutoplayTracks(
+        tracks: Track[],
+        playedData: { playedIds: Set<string>; playedTracks: Set<string> },
+        config: AutoplayConfig,
+    ): Track[] {
+        return tracks
+            .filter((track) => {
+                if (!track.info) {
+                    return false;
+                }
+
+                if (playedData.playedIds.has(track.info.identifier)) {
+                    return false;
+                }
+                if (track.info.isrc && playedData.playedIds.has(track.info.isrc)) {
+                    return false;
+                }
+
+                const key = `${track.info.title.toLowerCase()}|${track.info.author.toLowerCase()}`;
+                if (playedData.playedTracks.has(key)) {
+                    return false;
+                }
+
+                if (track.info.length) {
+                    if (track.info.length < config.minDuration) {
+                        return false;
+                    }
+                    if (track.info.length > config.maxDuration) {
+                        return false;
+                    }
+                }
+
+                const title = track.info.title.toLowerCase();
+                for (const keyword of config.excludeKeywords) {
+                    if (title.includes(keyword.toLowerCase())) {
+                        return false;
+                    }
+                }
+
+                return true;
+            })
+            .sort(() => Math.random() - 0.5)
+            .slice(0, config.limit);
+    }
+
+    async #getSpotifyRecommendations(queue: Queue, track: Track): Promise<Track[]> {
+        try {
+            const query = `sprec:seed_tracks=${track.info.identifier}`;
+            const result = (await queue.search(query)) as unknown as LoadResult;
+
+            if (result.loadType === LoadType.Track || result.loadType === LoadType.Playlist) {
+                if (result.loadType === LoadType.Track) {
+                    return [result.data as unknown as Track];
+                }
+                return result.data.tracks as unknown as Track[];
+            }
+        } catch (error) {
+            // Silent fail
+        }
+        return [];
+    }
+
+    async #getSpotifyArtistSearch(queue: Queue, track: Track): Promise<Track[]> {
+        try {
+            const query = `spsearch:${track.info.author}`;
+            const result = (await queue.search(query)) as unknown as LoadResult;
+
+            if (result.loadType === LoadType.Search && Array.isArray(result.data)) {
+                return (result.data as unknown as Track[]).slice(0, 5);
+            }
+        } catch (error) {
+            // Silent fail
+        }
+        return [];
+    }
+
+    async #getYouTubeSimilar(queue: Queue, track: Track): Promise<Track[]> {
+        try {
+            const query = `https://www.youtube.com/watch?v=${track.info.identifier}&list=RD${track.info.identifier}`;
+            const result = (await queue.search(query)) as unknown as LoadResult;
+
+            if (result.loadType === LoadType.Playlist && result.data && "tracks" in result.data) {
+                return (result.data.tracks as unknown as Track[]).slice(0, 10);
+            }
+        } catch (error) {
+            // Silent fail
+        }
+        return [];
+    }
+
+    async #getYouTubeArtist(queue: Queue, track: Track): Promise<Track[]> {
+        try {
+            const query = `ytsearch:${track.info.author}`;
+            const result = (await queue.search(query)) as unknown as LoadResult;
+
+            if (result.loadType === LoadType.Search && Array.isArray(result.data)) {
+                return (result.data as unknown as Track[]).slice(0, 5);
+            }
+        } catch (error) {
+            // Silent fail
+        }
+        return [];
+    }
+}