streamify-audio 2.0.4 → 2.1.0

package/index.js

@@ -249,4 +249,14 @@ Streamify.Manager = Manager;
 Streamify.Player = Manager ? require('./src/discord/Player') : null;
 Streamify.Queue = Manager ? require('./src/discord/Queue') : null;
 
+const persistence = require('./src/persistence');
+Streamify.PersistenceAdapter = persistence.PersistenceAdapter;
+Streamify.MemoryAdapter = persistence.MemoryAdapter;
+Streamify.MongoAdapter = persistence.MongoAdapter;
+
+const presets = require('./src/filters/presets');
+Streamify.EffectPresets = presets;
+Streamify.getEffectPresetNames = presets.getPresetNames;
+Streamify.getEffectPresetsInfo = presets.getAllPresetsInfo;
+
 module.exports = Streamify;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.0.4",
+  "version": "2.1.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",

package/src/discord/Manager.js

@@ -5,6 +5,7 @@ const spotify = require('../providers/spotify');
 const soundcloud = require('../providers/soundcloud');
 const log = require('../utils/logger');
 const { loadConfig } = require('../config');
+const { MemoryAdapter, MongoAdapter, serializeTrack, deserializeTrack } = require('../persistence');
 
 function checkDependencies() {
     const missing = [];
@@ -73,11 +74,164 @@ class Manager extends EventEmitter {
             maxTracks: options.autoplay?.maxTracks ?? 5
         };
 
+        this.fallback = {
+            enabled: options.fallback?.enabled ?? false,
+            order: options.fallback?.order || ['youtube', 'soundcloud']
+        };
+
+        this.persistence = null;
+        this._persistenceInterval = null;
+        this._persistenceIntervalMs = options.persistence?.interval || 30000;
+
         this._setupVoiceStateListener();
 
         log.info('MANAGER', 'Streamify Manager initialized');
     }
 
+    async enablePersistence(options = {}) {
+        if (options.adapter) {
+            this.persistence = options.adapter;
+        } else if (options.type === 'mongodb') {
+            this.persistence = new MongoAdapter({
+                client: options.client,
+                uri: options.uri,
+                db: options.db,
+                collection: options.collection
+            });
+        } else {
+            this.persistence = new MemoryAdapter();
+        }
+
+        if (options.autoSave !== false) {
+            this._persistenceInterval = setInterval(() => {
+                this._saveAllSessions();
+            }, this._persistenceIntervalMs);
+        }
+
+        log.info('MANAGER', `Persistence enabled (type: ${options.type || 'memory'})`);
+        return this;
+    }
+
+    async _saveAllSessions() {
+        if (!this.persistence) return;
+
+        for (const [guildId, player] of this.players) {
+            if (player.connected) {
+                await this.saveSession(guildId);
+            }
+        }
+    }
+
+    async saveSession(guildId) {
+        if (!this.persistence) return false;
+
+        const player = this.players.get(guildId);
+        if (!player || !player.connected) return false;
+
+        const current = player.queue.current;
+        if (!current && player.queue.tracks.length === 0) {
+            await this.persistence.delete(guildId);
+            return true;
+        }
+
+        const sessionData = {
+            guildId,
+            voiceChannelId: player.voiceChannelId,
+            textChannelId: player.textChannelId,
+            currentTrack: serializeTrack(current),
+            positionMs: player.position || 0,
+            queue: player.queue.tracks.map(serializeTrack),
+            volume: player.volume,
+            loop: player.queue.repeatMode || 'off',
+            filters: player.filters || {}
+        };
+
+        await this.persistence.save(guildId, sessionData);
+        log.debug('MANAGER', `Session saved for guild ${guildId}`);
+        return true;
+    }
+
+    async restoreSession(guildId, options = {}) {
+        if (!this.persistence) return null;
+
+        const session = await this.persistence.load(guildId);
+        if (!session) return null;
+
+        const guild = this.client.guilds.cache.get(guildId);
+        if (!guild) {
+            log.debug('MANAGER', `Guild ${guildId} not found, skipping restore`);
+            return null;
+        }
+
+        const voiceChannel = this.client.channels.cache.get(session.voiceChannelId);
+        if (!voiceChannel) {
+            log.debug('MANAGER', `Voice channel ${session.voiceChannelId} not found, skipping restore`);
+            await this.persistence.delete(guildId);
+            return null;
+        }
+
+        log.info('MANAGER', `Restoring session for guild ${guildId}`);
+
+        const player = await this.create(guildId, session.voiceChannelId, session.textChannelId);
+
+        if (session.volume !== undefined) player.setVolume(session.volume);
+        if (session.loop && session.loop !== 'off') player.setLoop(session.loop);
+
+        if (session.currentTrack) {
+            const track = deserializeTrack(session.currentTrack);
+            await player.play(track);
+
+            if (session.positionMs > 0 && !track.isLive && options.seekToPosition !== false) {
+                try {
+                    await player.seek(session.positionMs);
+                } catch (e) {
+                    log.debug('MANAGER', `Could not seek to position: ${e.message}`);
+                }
+            }
+        }
+
+        if (session.queue && session.queue.length > 0) {
+            const tracks = session.queue.map(deserializeTrack);
+            player.queue.addMany(tracks);
+        }
+
+        const members = voiceChannel.members?.filter(m => !m.user.bot);
+        if (members && members.size === 0 && player.autoPause.enabled) {
+            player.pause();
+            player._autoPaused = true;
+            log.info('MANAGER', `Session restored but auto-paused (empty channel)`);
+        }
+
+        this.emit('sessionRestored', { guildId, player, session });
+        return player;
+    }
+
+    async restoreAllSessions(options = {}) {
+        if (!this.persistence) return [];
+
+        const sessions = await this.persistence.loadAll();
+        const restored = [];
+
+        for (const session of sessions) {
+            try {
+                const player = await this.restoreSession(session.guildId, options);
+                if (player) {
+                    restored.push({ guildId: session.guildId, player });
+                }
+            } catch (error) {
+                log.error('MANAGER', `Failed to restore session ${session.guildId}: ${error.message}`);
+            }
+        }
+
+        log.info('MANAGER', `Restored ${restored.length}/${sessions.length} sessions`);
+        return restored;
+    }
+
+    async deleteSession(guildId) {
+        if (!this.persistence) return false;
+        return this.persistence.delete(guildId);
+    }
+
     _setupVoiceStateListener() {
         this.client.on('voiceStateUpdate', (oldState, newState) => {
             const player = this.players.get(oldState.guild.id) || this.players.get(newState.guild.id);
@@ -474,7 +628,84 @@ class Manager extends EventEmitter {
         }
     }
 
+    async searchWithFallback(query, options = {}) {
+        if (!this.fallback.enabled) {
+            return this.search(query, options);
+        }
+
+        const sources = options.sources || this.fallback.order;
+        let lastError = null;
+
+        for (const source of sources) {
+            try {
+                const result = await this.search(query, { ...options, source });
+                if (result.loadType !== 'error' && result.tracks.length > 0) {
+                    return result;
+                }
+            } catch (error) {
+                lastError = error;
+                log.debug('MANAGER', `Fallback: ${source} failed, trying next...`);
+            }
+        }
+
+        return {
+            loadType: 'error',
+            tracks: [],
+            error: lastError?.message || 'All sources failed'
+        };
+    }
+
+    async resolveWithFallback(query) {
+        if (!this.fallback.enabled) {
+            return this.resolve(query);
+        }
+
+        const result = await this.resolve(query);
+        if (result.loadType !== 'error' && result.tracks.length > 0) {
+            return result;
+        }
+
+        const detected = this._detectSource(query);
+        if (detected === 'spotify') {
+            const match = this._extractId(query, detected);
+            if (match) {
+                try {
+                    const track = await this.getInfo(match.id, 'spotify');
+                    const searchQuery = `${track.author} - ${track.title}`;
+
+                    for (const source of this.fallback.order) {
+                        if (source === 'spotify') continue;
+                        try {
+                            const fallbackResult = await this.search(searchQuery, { source, limit: 1 });
+                            if (fallbackResult.tracks.length > 0) {
+                                const fallbackTrack = fallbackResult.tracks[0];
+                                fallbackTrack._originalSpotifyTrack = track;
+                                log.info('MANAGER', `Spotify fallback: resolved via ${source}`);
+                                return {
+                                    loadType: 'track',
+                                    tracks: [fallbackTrack],
+                                    fallbackUsed: source
+                                };
+                            }
+                        } catch (e) {
+                            continue;
+                        }
+                    }
+                } catch (e) {
+                    log.debug('MANAGER', `Spotify info fetch failed: ${e.message}`);
+                }
+            }
+        }
+
+        return result;
+    }
+
     destroyAll() {
+        if (this._persistenceInterval) {
+            clearInterval(this._persistenceInterval);
+            this._persistenceInterval = null;
+        }
+
         for (const [guildId, player] of this.players) {
             player.destroy();
         }

package/src/discord/Player.js

@@ -2,6 +2,7 @@ const { EventEmitter } = require('events');
 const Queue = require('./Queue');
 const { createStream } = require('./Stream');
 const log = require('../utils/logger');
+const { buildPresetFilters, getPresetNames, getAllPresetsInfo } = require('../filters/presets');
 
 let voiceModule;
 try {
@@ -587,6 +588,70 @@ class Player extends EventEmitter {
         return this.setFilter('preset', presetName);
     }
 
+    async setEffectPreset(presetName, intensity = 0.5) {
+        const filters = buildPresetFilters(presetName, intensity);
+
+        for (const [key, value] of Object.entries(filters)) {
+            if (key === '_intensityFactor') continue;
+            this._filters[key] = value;
+        }
+
+        this._activePresets = this._activePresets || new Map();
+        this._activePresets.set(presetName, intensity);
+
+        if (this._playing && this.queue.current) {
+            return this.setFilter('_trigger', null);
+        }
+        return true;
+    }
+
+    async setEffectPresets(presets) {
+        this._activePresets = new Map();
+
+        for (const { name, intensity = 0.5 } of presets) {
+            const filters = buildPresetFilters(name, intensity);
+            for (const [key, value] of Object.entries(filters)) {
+                if (key === '_intensityFactor') continue;
+                this._filters[key] = value;
+            }
+            this._activePresets.set(name, intensity);
+        }
+
+        if (this._playing && this.queue.current) {
+            return this.setFilter('_trigger', null);
+        }
+        return true;
+    }
+
+    async clearEffectPresets() {
+        const presetsToRemove = ['bass', 'treble', 'speed', 'pitch', 'rotation', 'karaoke',
+            'lowpass', 'highpass', 'bandpass', 'vibrato', 'tremolo', 'chorus',
+            'compressor', 'normalizer', 'nightcore', 'vaporwave', 'bassboost', '8d'];
+
+        for (const key of presetsToRemove) {
+            delete this._filters[key];
+        }
+
+        this._activePresets = new Map();
+
+        if (this._playing && this.queue.current) {
+            return this.setFilter('_trigger', null);
+        }
+        return true;
+    }
+
+    getActiveEffectPresets() {
+        return this._activePresets ? Array.from(this._activePresets.entries()).map(([name, intensity]) => ({ name, intensity })) : [];
+    }
+
+    getAvailableEffectPresets() {
+        return getAllPresetsInfo();
+    }
+
+    static getEffectPresetNames() {
+        return getPresetNames();
+    }
+
     async clearEQ() {
         delete this._filters.equalizer;
         delete this._filters.preset;

package/src/discord/Stream.js

@@ -34,9 +34,26 @@ class StreamController {
         }
 
         this.startTime = Date.now();
-        const videoId = this.track._resolvedId || this.track.id;
         const source = this.track.source || 'youtube';
 
+        let videoId = this.track._resolvedId || this.track.id;
+
+        if (source === 'spotify' && !this.track._resolvedId) {
+            log.info('STREAM', `Resolving Spotify track to YouTube: ${this.track.title}`);
+            try {
+                const spotify = require('../providers/spotify');
+                videoId = await spotify.resolveToYouTube(this.track.id, this.config);
+                this.track._resolvedId = videoId;
+            } catch (error) {
+                log.error('STREAM', `Spotify resolution failed: ${error.message}`);
+                throw new Error(`Failed to resolve Spotify track: ${error.message}`);
+            }
+        }
+
+        if (!videoId || videoId === 'undefined') {
+            throw new Error(`Invalid track ID: ${videoId} (source: ${source}, title: ${this.track.title})`);
+        }
+
         log.info('STREAM', `Creating stream for ${videoId} (${source})`);
 
         let url;

package/src/filters/presets.js

@@ -0,0 +1,227 @@
+const EFFECT_PRESETS = {
+    bassboost: {
+        description: 'Boost bass frequencies',
+        build: (intensity = 0.5) => {
+            const gain = 5 + (intensity * 15);
+            return { bass: gain };
+        }
+    },
+
+    nightcore: {
+        description: 'Speed up with higher pitch (anime style)',
+        build: (intensity = 0.5) => {
+            const speedBoost = 0.15 + (intensity * 0.2);
+            return {
+                speed: 1 + speedBoost,
+                pitch: 1 + speedBoost
+            };
+        }
+    },
+
+    vaporwave: {
+        description: 'Slow down with lower pitch (aesthetic)',
+        build: (intensity = 0.5) => {
+            const slowdown = 0.1 + (intensity * 0.2);
+            return {
+                speed: 1 - slowdown,
+                pitch: 1 - slowdown
+            };
+        }
+    },
+
+    '8d': {
+        description: 'Rotating 8D audio effect',
+        build: (intensity = 0.5) => {
+            const speed = 0.05 + (intensity * 0.2);
+            return { rotation: { speed } };
+        }
+    },
+
+    karaoke: {
+        description: 'Reduce vocals (center channel removal)',
+        build: () => ({ karaoke: true })
+    },
+
+    trebleboost: {
+        description: 'Boost high frequencies',
+        build: (intensity = 0.5) => {
+            const gain = 5 + (intensity * 15);
+            return { treble: gain };
+        }
+    },
+
+    deep: {
+        description: 'Deep bass with reduced highs',
+        build: (intensity = 0.5) => {
+            const bassGain = 8 + (intensity * 12);
+            const trebleCut = -3 - (intensity * 7);
+            return { bass: bassGain, treble: trebleCut };
+        }
+    },
+
+    pop: {
+        description: 'Enhanced clarity for pop music',
+        build: (intensity = 0.5) => {
+            const factor = 0.5 + (intensity * 0.5);
+            return {
+                preset: 'pop',
+                _intensityFactor: factor
+            };
+        }
+    },
+
+    rock: {
+        description: 'Punchy mids and lows for rock',
+        build: (intensity = 0.5) => {
+            const factor = 0.5 + (intensity * 0.5);
+            return {
+                preset: 'rock',
+                _intensityFactor: factor
+            };
+        }
+    },
+
+    electronic: {
+        description: 'Enhanced bass and highs for EDM',
+        build: (intensity = 0.5) => {
+            const factor = 0.5 + (intensity * 0.5);
+            return {
+                preset: 'electronic',
+                _intensityFactor: factor
+            };
+        }
+    },
+
+    lofi: {
+        description: 'Lo-fi aesthetic with warmth',
+        build: (intensity = 0.5) => ({
+            lowpass: 8000 - (intensity * 4000),
+            bass: 3 + (intensity * 5)
+        })
+    },
+
+    radio: {
+        description: 'AM radio effect',
+        build: (intensity = 0.5) => ({
+            lowpass: 5000 - (intensity * 2000),
+            highpass: 300 + (intensity * 200)
+        })
+    },
+
+    telephone: {
+        description: 'Telephone/walkie-talkie effect',
+        build: () => ({
+            bandpass: { frequency: 1500, width: 1000 }
+        })
+    },
+
+    soft: {
+        description: 'Soft, gentle sound',
+        build: (intensity = 0.5) => ({
+            lowpass: 12000 - (intensity * 4000),
+            compressor: true
+        })
+    },
+
+    loud: {
+        description: 'Louder, more compressed',
+        build: (intensity = 0.5) => ({
+            preset: 'loudness',
+            compressor: true,
+            normalizer: true
+        })
+    },
+
+    chipmunk: {
+        description: 'High-pitched chipmunk voice',
+        build: (intensity = 0.5) => ({
+            pitch: 1.3 + (intensity * 0.5),
+            speed: 1.2 + (intensity * 0.3)
+        })
+    },
+
+    darth: {
+        description: 'Deep Darth Vader-like voice',
+        build: (intensity = 0.5) => ({
+            pitch: 0.7 - (intensity * 0.2),
+            speed: 0.9 - (intensity * 0.1)
+        })
+    },
+
+    echo: {
+        description: 'Echo/reverb effect',
+        build: () => ({
+            chorus: true
+        })
+    },
+
+    vibrato: {
+        description: 'Vibrating pitch effect',
+        build: (intensity = 0.5) => ({
+            vibrato: {
+                frequency: 4 + (intensity * 6),
+                depth: 0.3 + (intensity * 0.4)
+            }
+        })
+    },
+
+    tremolo: {
+        description: 'Trembling volume effect',
+        build: (intensity = 0.5) => ({
+            tremolo: {
+                frequency: 4 + (intensity * 8),
+                depth: 0.4 + (intensity * 0.4)
+            }
+        })
+    }
+};
+
+function getPresetNames() {
+    return Object.keys(EFFECT_PRESETS);
+}
+
+function getPresetInfo(name) {
+    const preset = EFFECT_PRESETS[name];
+    if (!preset) return null;
+    return {
+        name,
+        description: preset.description
+    };
+}
+
+function getAllPresetsInfo() {
+    return Object.entries(EFFECT_PRESETS).map(([name, preset]) => ({
+        name,
+        description: preset.description
+    }));
+}
+
+function buildPresetFilters(name, intensity = 0.5) {
+    const preset = EFFECT_PRESETS[name];
+    if (!preset) {
+        throw new Error(`Unknown preset: ${name}. Available: ${getPresetNames().join(', ')}`);
+    }
+
+    const clampedIntensity = Math.max(0, Math.min(1, intensity));
+    return preset.build(clampedIntensity);
+}
+
+function combinePresets(presetNames, intensity = 0.5) {
+    const combined = {};
+
+    for (const name of presetNames) {
+        const filters = buildPresetFilters(name, intensity);
+        Object.assign(combined, filters);
+    }
+
+    return combined;
+}
+
+module.exports = {
+    EFFECT_PRESETS,
+    getPresetNames,
+    getPresetInfo,
+    getAllPresetsInfo,
+    buildPresetFilters,
+    combinePresets
+};

package/src/persistence/index.js

@@ -0,0 +1,156 @@
+const log = require('../utils/logger');
+
+class PersistenceAdapter {
+    async save(guildId, sessionData) {
+        throw new Error('save() must be implemented by adapter');
+    }
+
+    async load(guildId) {
+        throw new Error('load() must be implemented by adapter');
+    }
+
+    async delete(guildId) {
+        throw new Error('delete() must be implemented by adapter');
+    }
+
+    async loadAll() {
+        throw new Error('loadAll() must be implemented by adapter');
+    }
+}
+
+class MemoryAdapter extends PersistenceAdapter {
+    constructor() {
+        super();
+        this.sessions = new Map();
+    }
+
+    async save(guildId, sessionData) {
+        this.sessions.set(guildId, {
+            ...sessionData,
+            updatedAt: Date.now()
+        });
+        return true;
+    }
+
+    async load(guildId) {
+        return this.sessions.get(guildId) || null;
+    }
+
+    async delete(guildId) {
+        return this.sessions.delete(guildId);
+    }
+
+    async loadAll() {
+        return Array.from(this.sessions.entries()).map(([guildId, data]) => ({
+            guildId,
+            ...data
+        }));
+    }
+}
+
+class MongoAdapter extends PersistenceAdapter {
+    constructor(options = {}) {
+        super();
+        this.collection = null;
+        this.collectionName = options.collection || 'streamify_sessions';
+        this.mongoClient = options.client || null;
+        this.mongoUri = options.uri || null;
+        this.db = options.db || null;
+    }
+
+    async connect() {
+        if (this.collection) return;
+
+        if (this.mongoClient) {
+            const dbName = this.db || 'streamify';
+            this.collection = this.mongoClient.db(dbName).collection(this.collectionName);
+        } else if (this.mongoUri) {
+            const { MongoClient } = require('mongodb');
+            const client = new MongoClient(this.mongoUri);
+            await client.connect();
+            const dbName = this.db || 'streamify';
+            this.collection = client.db(dbName).collection(this.collectionName);
+        } else {
+            throw new Error('MongoAdapter requires either client or uri option');
+        }
+
+        log.info('PERSISTENCE', `Connected to MongoDB collection: ${this.collectionName}`);
+    }
+
+    async save(guildId, sessionData) {
+        await this.connect();
+        await this.collection.updateOne(
+            { _id: guildId },
+            { $set: { ...sessionData, updatedAt: new Date() } },
+            { upsert: true }
+        );
+        return true;
+    }
+
+    async load(guildId) {
+        await this.connect();
+        const doc = await this.collection.findOne({ _id: guildId });
+        return doc || null;
+    }
+
+    async delete(guildId) {
+        await this.connect();
+        const result = await this.collection.deleteOne({ _id: guildId });
+        return result.deletedCount > 0;
+    }
+
+    async loadAll() {
+        await this.connect();
+        const docs = await this.collection.find({}).toArray();
+        return docs.map(doc => ({
+            guildId: doc._id,
+            ...doc
+        }));
+    }
+}
+
+function serializeTrack(track) {
+    if (!track) return null;
+    return {
+        id: track.id,
+        title: track.title,
+        author: track.author,
+        duration: track.duration,
+        thumbnail: track.thumbnail,
+        uri: track.uri,
+        source: track.source,
+        isLive: track.isLive || false,
+        _resolvedId: track._resolvedId,
+        requestedBy: track.requestedBy ? {
+            id: track.requestedBy.id || null,
+            username: track.requestedBy.username || track.requestedBy,
+            avatarUrl: track.requestedBy.avatarUrl || null
+        } : null,
+        artistUrl: track.artistUrl || null
+    };
+}
+
+function deserializeTrack(data) {
+    if (!data) return null;
+    return {
+        id: data.id,
+        title: data.title,
+        author: data.author,
+        duration: data.duration,
+        thumbnail: data.thumbnail,
+        uri: data.uri,
+        source: data.source,
+        isLive: data.isLive || false,
+        _resolvedId: data._resolvedId,
+        requestedBy: data.requestedBy,
+        artistUrl: data.artistUrl
+    };
+}
+
+module.exports = {
+    PersistenceAdapter,
+    MemoryAdapter,
+    MongoAdapter,
+    serializeTrack,
+    deserializeTrack
+};