streamify-audio 2.0.0

package/index.d.ts

@@ -0,0 +1,350 @@
+import { EventEmitter } from 'events';
+import { Client, GuildMember } from 'discord.js';
+
+declare module 'streamify-audio' {
+    // ========================================================================
+    // Common Types
+    // ========================================================================
+
+    export interface Track {
+        id: string;
+        title: string;
+        author: string;
+        duration: number;
+        thumbnail?: string;
+        uri: string;
+        streamUrl: string;
+        source: 'youtube' | 'spotify' | 'soundcloud';
+        album?: string;
+        isAutoplay?: boolean;
+        requestedBy?: any;
+        _resolvedId?: string;
+    }
+
+    export interface SearchResult {
+        loadType: 'search' | 'track' | 'empty' | 'error';
+        tracks: Track[];
+        source: string;
+        searchTime?: number;
+    }
+
+    export interface PlaylistResult {
+        loadType: 'playlist' | 'error';
+        playlist?: {
+            id: string;
+            title: string;
+            author: string;
+            thumbnail?: string;
+            source: string;
+        };
+        tracks: Track[];
+        error?: string;
+    }
+
+    export interface Filters {
+        bass?: number;
+        treble?: number;
+        speed?: number;
+        pitch?: number;
+        volume?: number;
+        equalizer?: number[];
+        preset?: string;
+        tremolo?: { frequency?: number; depth?: number };
+        vibrato?: { frequency?: number; depth?: number };
+        rotation?: { speed?: number };
+        lowpass?: number;
+        highpass?: number;
+        bandpass?: { frequency?: number; width?: number };
+        bandreject?: { frequency?: number; width?: number };
+        lowshelf?: { frequency?: number; gain?: number };
+        highshelf?: { frequency?: number; gain?: number };
+        peaking?: { frequency?: number; gain?: number; q?: number };
+        karaoke?: boolean;
+        mono?: boolean;
+        surround?: boolean;
+        flanger?: boolean;
+        phaser?: boolean;
+        chorus?: boolean;
+        compressor?: boolean;
+        normalizer?: boolean;
+        nightcore?: boolean;
+        vaporwave?: boolean;
+        bassboost?: boolean;
+        '8d'?: boolean;
+        start?: number;
+    }
+
+    // ========================================================================
+    // HTTP Server Mode
+    // ========================================================================
+
+    export interface ProviderConfig {
+        enabled?: boolean;
+    }
+
+    export interface ProvidersConfig {
+        youtube?: ProviderConfig;
+        spotify?: ProviderConfig;
+        soundcloud?: ProviderConfig;
+    }
+
+    export interface StreamifyOptions {
+        port?: number;
+        host?: string;
+        cookiesPath?: string;
+        cookies?: string;
+        ytdlpPath?: string;
+        ffmpegPath?: string;
+        providers?: ProvidersConfig;
+        spotify?: {
+            clientId: string;
+            clientSecret: string;
+        };
+        audio?: {
+            bitrate?: string;
+            format?: 'opus' | 'mp3' | 'aac';
+        };
+        logLevel?: 'none' | 'error' | 'warn' | 'info' | 'debug';
+        silent?: boolean;
+        colors?: boolean;
+    }
+
+    export interface ActiveStream {
+        id: string;
+        source: string;
+        trackId: string;
+        position: number;
+        filters: Filters;
+        startTime: number;
+        duration: number;
+    }
+
+    export interface SourceMethods {
+        search(query: string, limit?: number): Promise<SearchResult>;
+        getInfo?(id: string): Promise<Track>;
+        getStreamUrl(id: string, filters?: Filters): string;
+        getStream(id: string, filters?: Filters): Promise<ReadableStream>;
+    }
+
+    export default class Streamify extends EventEmitter {
+        constructor(options?: StreamifyOptions);
+
+        readonly running: boolean;
+        readonly config: StreamifyOptions;
+
+        start(): Promise<this>;
+        stop(): Promise<void>;
+        getBaseUrl(): string;
+
+        detectSource(input: string): { source: string | null; id: string | null; isUrl: boolean };
+        resolve(input: string, limit?: number): Promise<SearchResult>;
+        search(source: string, query: string, limit?: number): Promise<SearchResult>;
+        getInfo(source: string, id: string): Promise<Track>;
+        getStreamUrl(source: string, id: string, filters?: Filters): string;
+        getStream(source: string, id: string, filters?: Filters): Promise<ReadableStream>;
+
+        getActiveStreams(): Promise<{ streams: ActiveStream[] }>;
+        getStreamInfo(streamId: string): Promise<ActiveStream | null>;
+        getPosition(streamId: string): Promise<number | null>;
+        applyFilters(source: string, trackId: string, currentStreamId: string, newFilters: Filters): Promise<{
+            url: string;
+            position: number;
+            filters: Filters;
+        }>;
+
+        youtube: SourceMethods;
+        spotify: SourceMethods;
+        soundcloud: Omit<SourceMethods, 'getInfo'>;
+
+        on(event: 'streamStart', listener: (data: { id: string; source: string; trackId: string; filters: Filters }) => void): this;
+        on(event: 'streamEnd', listener: (data: { id: string; source: string; trackId: string; duration: number }) => void): this;
+        on(event: 'streamError', listener: (data: { id: string; source: string; trackId: string; error: Error }) => void): this;
+
+        static Manager: typeof Manager;
+        static Player: typeof Player;
+        static Queue: typeof Queue;
+    }
+
+    // ========================================================================
+    // Discord Player Mode
+    // ========================================================================
+
+    export interface ManagerOptions {
+        ytdlpPath?: string;
+        ffmpegPath?: string;
+        cookiesPath?: string;
+        providers?: ProvidersConfig;
+        spotify?: {
+            clientId: string;
+            clientSecret: string;
+        };
+        audio?: {
+            bitrate?: string;
+            format?: 'opus' | 'mp3' | 'aac';
+        };
+        defaultVolume?: number;
+        maxPreviousTracks?: number;
+        sponsorblock?: {
+            enabled?: boolean;
+            categories?: string[];
+        };
+        autoLeave?: {
+            enabled?: boolean;
+            emptyDelay?: number;
+            inactivityTimeout?: number;
+        };
+        autoPause?: {
+            enabled?: boolean;
+            minUsers?: number;
+        };
+        autoplay?: {
+            enabled?: boolean;
+            maxTracks?: number;
+        };
+    }
+
+    export interface ManagerStats {
+        players: number;
+        playingPlayers: number;
+        memory: {
+            heapUsed: number;
+            heapTotal: number;
+            rss: number;
+        };
+    }
+
+    export class Manager extends EventEmitter {
+        constructor(client: Client, options?: ManagerOptions);
+
+        players: Map<string, Player>;
+        config: any;
+        autoLeave: { enabled: boolean; emptyDelay: number; inactivityTimeout: number };
+        autoPause: { enabled: boolean; minUsers: number };
+        autoplay: { enabled: boolean; maxTracks: number };
+
+        create(guildId: string, voiceChannelId: string, textChannelId?: string): Promise<Player>;
+        get(guildId: string): Player | undefined;
+        destroy(guildId: string): void;
+        destroyAll(): void;
+
+        search(query: string, options?: { source?: string; limit?: number }): Promise<SearchResult>;
+        resolve(input: string): Promise<SearchResult>;
+        loadPlaylist(url: string): Promise<PlaylistResult>;
+        getRelated(track: Track, limit?: number): Promise<{ tracks: Track[]; source: string }>;
+        getStats(): ManagerStats;
+
+        on(event: 'playerCreate', listener: (player: Player) => void): this;
+        on(event: 'playerDestroy', listener: (player: Player) => void): this;
+    }
+
+    export class Player extends EventEmitter {
+        constructor(manager: Manager, options: any);
+
+        manager: Manager;
+        guildId: string;
+        voiceChannelId: string;
+        textChannelId: string;
+        queue: Queue;
+
+        readonly connected: boolean;
+        readonly playing: boolean;
+        readonly paused: boolean;
+        readonly position: number;
+        volume: number;
+        readonly filters: Filters;
+
+        autoplay: { enabled: boolean; maxTracks: number };
+        autoPause: { enabled: boolean; minUsers: number };
+        autoLeave: { enabled: boolean; emptyDelay: number; inactivityTimeout: number };
+
+        connect(): Promise<void>;
+        disconnect(): boolean;
+        destroy(): void;
+
+        play(track: Track): Promise<void>;
+        pause(destroyStream?: boolean): boolean;
+        resume(): Promise<boolean>;
+        skip(): Promise<Track | null>;
+        previous(): Promise<Track | null>;
+        stop(): boolean;
+        seek(positionMs: number): Promise<boolean>;
+
+        setVolume(volume: number): number;
+        setLoop(mode: 'off' | 'track' | 'queue'): string;
+        setAutoplay(enabled: boolean): boolean;
+        setAutoPause(enabled: boolean): boolean;
+
+        setFilter(name: string, value: any): Promise<boolean>;
+        clearFilters(): Promise<boolean>;
+        setEQ(bands: number[]): Promise<boolean>;
+        setPreset(name: string): Promise<boolean>;
+        clearEQ(): Promise<boolean>;
+        getPresets(): string[];
+
+        toJSON(): any;
+
+        on(event: 'trackStart', listener: (track: Track) => void): this;
+        on(event: 'trackEnd', listener: (track: Track, reason: 'finished' | 'skipped' | 'stopped') => void): this;
+        on(event: 'trackError', listener: (track: Track, error: Error) => void): this;
+        on(event: 'queueEnd', listener: () => void): this;
+        on(event: 'userJoin', listener: (member: GuildMember, count: number) => void): this;
+        on(event: 'userLeave', listener: (member: GuildMember, count: number) => void): this;
+        on(event: 'channelEmpty', listener: () => void): this;
+        on(event: 'channelMove', listener: (channelId: string) => void): this;
+        on(event: 'autoPause', listener: (userCount: number) => void): this;
+        on(event: 'autoResume', listener: (userCount: number) => void): this;
+        on(event: 'autoplayStart', listener: (lastTrack: Track) => void): this;
+        on(event: 'autoplayAdd', listener: (tracks: Track[]) => void): this;
+        on(event: 'destroy', listener: () => void): this;
+    }
+
+    export class Queue {
+        constructor(options?: { maxPreviousTracks?: number });
+
+        current: Track | null;
+        tracks: Track[];
+        previous: Track[];
+        repeatMode: 'off' | 'track' | 'queue';
+
+        readonly size: number;
+        readonly isEmpty: boolean;
+        readonly totalDuration: number;
+
+        add(track: Track, position?: number): void;
+        addMany(tracks: Track[]): void;
+        remove(index: number): Track | null;
+        clear(): void;
+        shuffle(): void;
+        move(from: number, to: number): boolean;
+
+        shift(): Track | null;
+        setCurrent(track: Track | null): void;
+        setRepeatMode(mode: 'off' | 'track' | 'queue'): string;
+
+        toJSON(): any;
+    }
+
+    // ========================================================================
+    // Filter Presets
+    // ========================================================================
+
+    export const PRESETS: {
+        flat: number[];
+        rock: number[];
+        pop: number[];
+        jazz: number[];
+        classical: number[];
+        electronic: number[];
+        hiphop: number[];
+        acoustic: number[];
+        rnb: number[];
+        latin: number[];
+        loudness: number[];
+        piano: number[];
+        vocal: number[];
+        bass_heavy: number[];
+        treble_heavy: number[];
+    };
+
+    export const EQ_BANDS: number[];
+}

package/index.js

@@ -0,0 +1,252 @@
+const { EventEmitter } = require('events');
+const Server = require('./src/server');
+const config = require('./src/config');
+const youtube = require('./src/providers/youtube');
+const spotify = require('./src/providers/spotify');
+const soundcloud = require('./src/providers/soundcloud');
+const log = require('./src/utils/logger');
+const { setEventEmitter } = require('./src/utils/stream');
+
+class Streamify extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.config = null;
+        this.server = null;
+        this.running = false;
+    }
+
+    async start() {
+        if (this.running) return this;
+
+        this.config = config.load(this.options);
+        log.init(this.config);
+        setEventEmitter(this);
+        this.server = new Server(this.config);
+        await this.server.start();
+        this.running = true;
+        return this;
+    }
+
+    async stop() {
+        if (this.server) {
+            await this.server.stop();
+            this.running = false;
+        }
+    }
+
+    getBaseUrl() {
+        if (!this.config) throw new Error('Streamify not started. Call .start() first');
+        return `http://127.0.0.1:${this.config.port}`;
+    }
+
+    detectSource(input) {
+        if (!input) return { source: null, id: null, isUrl: false };
+
+        const patterns = {
+            youtube: [
+                /(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([a-zA-Z0-9_-]{11})/,
+                /^([a-zA-Z0-9_-]{11})$/
+            ],
+            spotify: [
+                /open\.spotify\.com\/track\/([a-zA-Z0-9]+)/,
+                /spotify:track:([a-zA-Z0-9]+)/
+            ],
+            soundcloud: [
+                /soundcloud\.com\/([^\/]+\/[^\/\?]+)/,
+                /api\.soundcloud\.com\/tracks\/(\d+)/
+            ]
+        };
+
+        for (const [source, regexes] of Object.entries(patterns)) {
+            for (const regex of regexes) {
+                const match = input.match(regex);
+                if (match) {
+                    return {
+                        source,
+                        id: match[1],
+                        isUrl: input.includes('://') || input.includes('.com')
+                    };
+                }
+            }
+        }
+
+        return { source: null, id: null, isUrl: false };
+    }
+
+    async resolve(input, limit = 1) {
+        if (!this.running) throw new Error('Streamify not started. Call .start() first');
+
+        const detected = this.detectSource(input);
+
+        if (detected.source && detected.isUrl) {
+            const track = await this.getInfo(detected.source, detected.id).catch(() => null);
+            if (track) {
+                return { source: detected.source, tracks: [track], fromUrl: true };
+            }
+        }
+
+        if (detected.source === 'youtube' && detected.id && !detected.isUrl) {
+            const track = await this.getInfo('youtube', detected.id).catch(() => null);
+            if (track) {
+                return { source: 'youtube', tracks: [track], fromUrl: true };
+            }
+        }
+
+        const results = await this.search('youtube', input, limit);
+        return { source: 'youtube', tracks: results.tracks, fromUrl: false, searchTime: results.searchTime };
+    }
+
+    async search(source, query, limit = 10) {
+        if (!this.running) throw new Error('Streamify not started. Call .start() first');
+
+        switch (source) {
+            case 'youtube':
+            case 'yt':
+                return youtube.search(query, limit, this.config);
+            case 'spotify':
+            case 'sp':
+                return spotify.search(query, limit, this.config);
+            case 'soundcloud':
+            case 'sc':
+                return soundcloud.search(query, limit, this.config);
+            default:
+                throw new Error(`Unknown source: ${source}`);
+        }
+    }
+
+    async getInfo(source, id) {
+        if (!this.running) throw new Error('Streamify not started. Call .start() first');
+
+        switch (source) {
+            case 'youtube':
+            case 'yt':
+                return youtube.getInfo(id, this.config);
+            case 'spotify':
+            case 'sp':
+                return spotify.getInfo(id, this.config);
+            default:
+                throw new Error(`Unknown source: ${source}`);
+        }
+    }
+
+    getStreamUrl(source, id, filters = {}) {
+        if (!this.config) throw new Error('Streamify not started. Call .start() first');
+
+        let endpoint;
+        switch (source) {
+            case 'youtube':
+            case 'yt':
+                endpoint = `/youtube/stream/${id}`;
+                break;
+            case 'spotify':
+            case 'sp':
+                endpoint = `/spotify/stream/${id}`;
+                break;
+            case 'soundcloud':
+            case 'sc':
+                endpoint = `/soundcloud/stream/${id}`;
+                break;
+            default:
+                throw new Error(`Unknown source: ${source}`);
+        }
+
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(filters)) {
+            if (value !== undefined && value !== null) {
+                params.append(key, value);
+            }
+        }
+
+        const queryString = params.toString();
+        return `${this.getBaseUrl()}${endpoint}${queryString ? '?' + queryString : ''}`;
+    }
+
+    async getStream(source, id, filters = {}) {
+        const url = this.getStreamUrl(source, id, filters);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Stream failed: ${response.status}`);
+        }
+        return response.body;
+    }
+
+    youtube = {
+        search: (query, limit = 10) => this.search('youtube', query, limit),
+        getInfo: (id) => this.getInfo('youtube', id),
+        getStreamUrl: (id, filters = {}) => this.getStreamUrl('youtube', id, filters),
+        getStream: (id, filters = {}) => this.getStream('youtube', id, filters)
+    };
+
+    spotify = {
+        search: (query, limit = 10) => this.search('spotify', query, limit),
+        getInfo: (id) => this.getInfo('spotify', id),
+        getStreamUrl: (id, filters = {}) => this.getStreamUrl('spotify', id, filters),
+        getStream: (id, filters = {}) => this.getStream('spotify', id, filters)
+    };
+
+    soundcloud = {
+        search: (query, limit = 10) => this.search('soundcloud', query, limit),
+        getStreamUrl: (id, filters = {}) => this.getStreamUrl('soundcloud', id, filters),
+        getStream: (id, filters = {}) => this.getStream('soundcloud', id, filters)
+    };
+
+    async getActiveStreams() {
+        const res = await fetch(`${this.getBaseUrl()}/streams`);
+        return res.json();
+    }
+
+    async getStreamInfo(streamId) {
+        const res = await fetch(`${this.getBaseUrl()}/streams/${streamId}`);
+        if (!res.ok) return null;
+        return res.json();
+    }
+
+    async getPosition(streamId) {
+        const res = await fetch(`${this.getBaseUrl()}/streams/${streamId}/position`);
+        if (!res.ok) return null;
+        const data = await res.json();
+        return data.position;
+    }
+
+    async applyFilters(source, trackId, currentStreamId, newFilters) {
+        const position = await this.getPosition(currentStreamId);
+        if (position === null) {
+            throw new Error('Stream not found or already ended');
+        }
+
+        const filters = {
+            ...newFilters,
+            start: Math.floor(position)
+        };
+
+        return {
+            url: this.getStreamUrl(source, trackId, filters),
+            position,
+            filters
+        };
+    }
+}
+
+if (require.main === module) {
+    const streamify = new Streamify();
+    streamify.start().then(() => {
+        console.log(`[STREAMIFY] Server running at ${streamify.getBaseUrl()}`);
+    }).catch(err => {
+        console.error('[STREAMIFY] Failed to start:', err.message);
+        process.exit(1);
+    });
+}
+
+let Manager = null;
+try {
+    Manager = require('./src/discord/Manager');
+} catch (e) {
+}
+
+Streamify.Manager = Manager;
+
+Streamify.Player = Manager ? require('./src/discord/Player') : null;
+Streamify.Queue = Manager ? require('./src/discord/Queue') : null;
+
+module.exports = Streamify;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "streamify-audio",
+  "version": "2.0.0",
+  "description": "Dual-mode audio library: HTTP streaming proxy + Discord player (Lavalink alternative). Supports YouTube, Spotify, SoundCloud with audio filters.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "bin": {
+    "streamify": "./bin/streamify.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "dev": "node index.js --dev"
+  },
+  "keywords": [
+    "discord",
+    "music",
+    "bot",
+    "youtube",
+    "spotify",
+    "soundcloud",
+    "audio",
+    "streaming",
+    "lavalink",
+    "lavalink-alternative",
+    "discordjs-voice",
+    "yt-dlp",
+    "ffmpeg"
+  ],
+  "author": "Lucas",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.18.2"
+  },
+  "optionalDependencies": {
+    "@discordjs/opus": "^0.9.0",
+    "@discordjs/voice": "^0.18.0"
+  },
+  "peerDependencies": {
+    "discord.js": "^14.0.0"
+  },
+  "peerDependenciesMeta": {
+    "discord.js": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LucasCzechia/streamify.git"
+  },
+  "homepage": "https://github.com/LucasCzechia/streamify#readme",
+  "bugs": {
+    "url": "https://github.com/LucasCzechia/streamify/issues"
+  }
+}