diff --git a/.gitignore b/.gitignore index 2d45f857..e042b72c 100644 --- a/.gitignore +++ b/.gitignore @@ -15,7 +15,7 @@ !LICENSE !package.json !README.md -!config.default.js +!config.default.ts !biome.json !.husky !.husky/** diff --git a/README.md b/README.md index f72d46ba..76f6f52c 100644 --- a/README.md +++ b/README.md @@ -103,7 +103,7 @@ However, some clients may not work properly, since NodeLink changes certain beha | [lava-lyra](https://github.com/ParrotXray/lava-lyra) | Python | Yes | Yes | v3 | | | [Hikari-ongaku](https://github.com/MPlatypus/hikari-ongaku) | Python | unknown | No | v1 and v2 | | | [Moonlink.js](https://github.com/1Lucas1apk/moonlink.js) | TypeScript | Yes | Yes | v1, v2, v3 | | -| [Magmastream](https://github.com/Blackfort-Hosting/magmastream) | TypeScript | unknown | No | v1 | | +| [Magmastream](https://github.com/Blackfort-Hosting/magmastream) | TypeScript | Yes | Yes | v1 and v3 | | | [Lavacord](https://github.com/lavacord/Lavacord) | TypeScript | unknown | No | v1 and v2 | | | [Shoukaku](https://github.com/Deivu/Shoukaku) | TypeScript | Yes | No | v1, v2, v3 | | | [Hoshimi](https://github.com/Ganyu-Studios/Hoshimi) | TypeScript | Yes | No | v1, v2, v3 | ;P | diff --git a/biome.json b/biome.json index c364a77f..62d14c98 100644 --- a/biome.json +++ b/biome.json @@ -1,5 +1,5 @@ { - "$schema": "https://biomejs.dev/schemas/2.4.12/schema.json", + "$schema": "https://biomejs.dev/schemas/2.5.0/schema.json", "assist": { "actions": { "source": { "organizeImports": "on" } } }, "formatter": { "enabled": true, @@ -20,7 +20,7 @@ "linter": { "enabled": true, "rules": { - "recommended": true, + "preset": "recommended", "style": { "useConst": "error" }, diff --git a/config.default.js b/config.default.js deleted file mode 100644 index 01e3f7c0..00000000 --- a/config.default.js +++ /dev/null @@ -1,667 +0,0 @@ -export default { - server: { - host: '0.0.0.0', - port: 3000, - password: 'youshallnotpass', - useBunServer: false // set to true to use Bun.serve websocket (experimental) - }, - cluster: { - enabled: true, // active cluster (or use env CLUSTER_ENABLED) - workers: 0, // 0 => uses os.cpus().length, or specify a number (1 = 2 processes total: master + 1 worker) - minWorkers: 1, // Minimum workers to keep alive (improves availability during bursts) - runtime: { - workerMaxOldSpaceMb: 0, // 0 disables override; set >0 to pass --max-old-space-size to playback workers - workerExposeGc: false, // If true, adds --expose-gc to playback workers - workerExecArgv: [], // Extra Node.js args for playback workers (e.g. ['--trace-gc']) - sourceWorkerMaxOldSpaceMb: 0, // 0 disables override; set >0 to pass --max-old-space-size to source workers - sourceWorkerExposeGc: false, // If true, adds --expose-gc to source workers - sourceWorkerExecArgv: [] // Extra Node.js args for source workers - }, - specializedSourceWorker: { - enabled: true, // If true, source loading (search, lyrics, etc.) is delegated to dedicated workers to prevent voice worker lag - count: 1, // Number of separate process clusters for source operations - microWorkers: 2, // Number of worker threads per process cluster - tasksPerWorker: 32, // Number of parallel tasks each micro-worker can handle before queuing - silentLogs: true // If true, micro-workers will only log warnings and errors - }, - commandTimeout: 6000, // Timeout for heavy operations like loadTracks (6s) - fastCommandTimeout: 4000, // Timeout for player commands like play/pause (4s) - maxRetries: 2, // Number of retry attempts on timeout or worker failure - hibernation: { - enabled: true, - timeoutMs: 1200000 - }, - scaling: { - //scaling configurations - maxPlayersPerWorker: 20, // Reference capacity for utilization calculation - targetUtilization: 0.7, // Target utilization for scaling up/down - scaleUpThreshold: 0.75, // Utilization threshold to scale up - scaleDownThreshold: 0.3, // Utilization threshold to scale down - checkIntervalMs: 5000, // Interval to check for scaling needs - idleWorkerTimeoutMs: 60000, // Time in ms an idle worker should wait before being removed - queueLengthScaleUpFactor: 5, // How many commands in queue per active worker trigger scale up - lagPenaltyLimit: 60, // Event loop lag threshold (ms) to penalize worker cost - cpuPenaltyLimit: 0.85 // CPU usage threshold (85% of a core) to force scale up - }, - endpoint: { - patchEnabled: true, - allowExternalPatch: false, - code: 'CAPYBARA' - } - }, - logging: { - level: 'debug', - file: { - enabled: false, - path: 'logs', - rotation: 'daily', - ttlDays: 7 - }, - debug: { - all: false, - request: true, - session: true, - player: true, - filters: true, - sources: true, - lyrics: true, - youtube: true, - 'youtube-cipher': true, - sabr: false, - potoken: false - } - }, - connection: { - logAllChecks: false, - interval: 300000, // 5 minutes - timeout: 10000, // 10 seconds - thresholds: { - bad: 1, // Mbps - average: 5 // Mbps - } - }, - maxSearchResults: 10, - maxAlbumPlaylistLength: 100, - playerUpdateInterval: 2000, - statsUpdateInterval: 30000, - trackStuckThresholdMs: 10000, - eventTimeoutMs: 15000, - zombieThresholdMs: 60000, - enableHoloTracks: false, - enableTrackStreamEndpoint: false, - enableLoadStreamEndpoint: false, - resolveExternalLinks: false, - fetchChannelInfo: false, - sponsorblock: { - enabled: false, - api: 'https://sponsor.ajay.app', - categories: [ - 'sponsor', - 'selfpromo', - 'interaction', - 'intro', - 'outro', - 'preview', - 'music_offtopic', - 'filler' - ], - actionTypes: ['skip'], - skipMarginMs: 150 - }, - filters: { - enabled: { - tremolo: true, - vibrato: true, - lowpass: true, - highpass: true, - rotation: true, - karaoke: true, - distortion: true, - channelMix: true, - equalizer: true, - chorus: true, - compressor: true, - echo: true, - phaser: true, - timescale: true - } - }, - defaultSearchSource: ['youtube', 'soundcloud'], - unifiedSearchSources: ['youtube', 'soundcloud'], - sources: { - vkmusic: { - enabled: true, - userToken: '', // (optional) get from vk in browser devtools -> reqs POST /?act=web_token HTTP/2 - headers -> response -> access_token - userCookie: '', // (required without userToken) get from vk in browser devtools -> reqs POST /?act=web_token HTTP/2 - headers -> request -> cookie (copy full cookie header) - proxy: { - url: '', - username: '', - password: '' - } - }, - amazonmusic: { - enabled: true - }, - bluesky: { - enabled: true - }, - anghami: { - enabled: false, - cookies: '' // Optional: Useful for accessing restricted or private content - }, - rss: { - enabled: true - }, - songlink: { - enabled: true, - apiKey: '', - userCountry: 'US', - songIfSingle: true, - useApi: true, - useScrapeFallback: true, - preferredPlatforms: [ - 'spotify', - 'appleMusic', - 'youtubeMusic', - 'youtube', - 'deezer', - 'tidal', - 'amazonMusic', - 'soundcloud', - 'bandcamp', - 'audius', - 'audiomack', - 'pandora', - 'itunes', - 'amazonStore' - ], - fallbackToAny: true - }, - mixcloud: { - enabled: true - }, - audiomack: { - enabled: true - }, - deezer: { - // arl: '', - // decryptionKey: '', - enabled: true - }, - bandcamp: { - enabled: true - }, - soundcloud: { - enabled: true - // clientId: "" - }, - local: { - enabled: true, - basePath: './local-music/' - }, - http: { - enabled: true, - userAgent: '' // Optional: defaults to NodeLink/ (https://github.com/PerformanC/NodeLink) - }, - eternalbox: { - enabled: true, - baseUrl: 'https://eternalboxmirror.xyz', - searchResults: 30, - enrichSpotify: true, - includeAnalysis: true, - includeAnalysisSummary: true, - eternalStream: true, - cacheMaxBytes: 20 * 1024 * 1024, - maxBranches: 4, - maxBranchThreshold: 75, - branchThresholdStart: 10, - branchThresholdStep: 5, - branchTargetDivisor: 6, - addLastEdge: true, - justBackwards: false, - justLongBranches: false, - removeSequentialBranches: true, - useFilteredSegments: true, - minRandomBranchChance: 0.18, - maxRandomBranchChance: 0.5, - randomBranchChanceDelta: 0.09, - timbreWeight: 1, - pitchWeight: 10, - loudStartWeight: 1, - loudMaxWeight: 1, - durationWeight: 100, - confidenceWeight: 1, - infiniteStream: true, - maxReconnects: 0, - reconnectDelayMs: 1000 - }, - vimeo: { - // Note: not 100% of the songs are currently working (but most should.), because i need to code a different extractor for every year (2010, 2011, etc. not all are done) - enabled: true - }, - iheartradio: { - enabled: true - }, - telegram: { - enabled: true - }, - shazam: { - enabled: true, - allowExplicit: true - }, - bilibili: { - enabled: true, - sessdata: '' // Optional, improves access to some videos (premium and 4k+) - }, - genius: { - enabled: true - }, - pinterest: { - enabled: true - }, - flowery: { - enabled: true, - voice: 'Salli', - translate: false, - silence: 0, - speed: 1.0, - enforceConfig: false - }, - lazypytts: { - enabled: true, - service: 'Cerence', - voice: 'Luciana', - maxTextLength: 3000, - enforceConfig: false - }, - jiosaavn: { - enabled: true, - playlistLoadLimit: 50, - artistLoadLimit: 20, - proxy: { - url: '', - username: '', - password: '' - } - // "secretKey": "38346591" // Optional, defaults to standard key - }, - gaana: { - enabled: true, - streamQuality: 'high', - playlistLoadLimit: 100, - albumLoadLimit: 100, - artistLoadLimit: 100, - proxy: { - url: '', // The HTTP/HTTPS proxy to use - username: '', // Optional username - password: '' // Optional password - } - }, - 'google-tts': { - enabled: true, - language: 'en-US' - }, - // Piper TTS Configuration - // This source uses an external Piper TTS HTTP server. - // You can find the Piper HTTP server repository here: - // https://github.com/OHF-Voice/piper1-gpl/tree/main?tab=readme-ov-file - pipertts: { - enabled: false, // Disabled by default. Enable it to use Piper TTS. - url: 'http://localhost:5000' // URL of your Piper TTS server - // Optional settings (defaults from Piper): - // voice: 'en_US-lessac-medium', - // speaker: 0, - // length_scale: 1.0, - // noise_scale: 0.667, - // noise_w_scale: 0.8 - }, - youtube: { - enabled: true, - allowItag: [], // additional itags for audio streams, e.g., [140, 141] - targetItag: null, // force a specific itag for audio streams, overriding the quality option - getOAuthToken: false, - hl: 'en', - gl: 'US', - proxies: [ - /* { - url: "http://proxy1:port", - username: "username", - password: "password" - }, - { - url: "http://proxy2:port" - } */ - ], - fallbackSources: [ - 'soundcloud', - 'deezer', - 'jiosaavn', - 'qobuz', - 'gaana', - 'vkmusic', - 'yandexmusic', - 'audiomack', - 'bandcamp', - 'audius', - 'mixcloud', - 'bilibili', - 'bluesky', - 'nicovideo' - ], // Internal fallback chain when YouTube stream URL fails - clients: { - search: ['Android'], // Clients used for searching tracks - playback: [ - 'AndroidVR', - 'TV', - 'TVCast', - 'WebEmbedded', - 'WebParentTools', - 'Web', - 'IOS' - ], // Clients used for playback/streaming - resolve: [ - 'AndroidVR', - 'TV', - 'TVCast', - 'WebEmbedded', - 'WebParentTools', - 'IOS', - 'Web' - ], // Clients used for resolving detailed track information (channel, external links, etc.) - settings: { - TV: { - refreshToken: [''] // You can use a string "token" or an array ["token1", "token2"] for rotation/fallback - } - } - }, - cipher: { - url: 'https://cipher.kikkia.dev/api', - token: null - } - }, - instagram: { - enabled: true - }, - kwai: { - enabled: true - }, - twitch: { - enabled: true - }, - spotify: { - enabled: true, - clientId: '', - clientSecret: '', - externalAuthUrl: 'http://get.1lucas1apk.fun/spotify/gettoken', // URL to external token provider (e.g. http://localhost:8080/api/token - use https://github.com/topi314/spotify-tokener or https://github.com/1Lucas1apk/gettoken) - market: 'US', - playlistLoadLimit: 1, // 0 means no limit (loads all tracks), 1 = 100 tracks, 2 = 100 and so on! - playlistPageLoadConcurrency: 10, // How many pages to load simultaneously - albumLoadLimit: 1, // 0 means no limit (loads all tracks), 1 = 50 tracks, 2 = 100 tracks, etc. - albumPageLoadConcurrency: 5, // How many pages to load simultaneously - allowExplicit: true, // If true plays the explicit version of the song, If false plays the Non-Explicit version of the song. Normal songs are not affected. - allowLocalFiles: false, // If true, Spotify playlist local files are kept as placeholder tracks so they can still be searched and played through fallback sources. - sp_dc: '' // fot getting mobile token (optional) get from spotify in browser devtools -> Application -> Cookies -> sp_dc (required for canvas) - }, - applemusic: { - enabled: true, - mediaApiToken: 'token_here', //manually | or "token_here" to get a token automatically - market: 'US', - playlistLoadLimit: 0, - albumLoadLimit: 0, - playlistPageLoadConcurrency: 5, - albumPageLoadConcurrency: 5, - allowExplicit: true - }, - audius: { - enabled: true, - appName: '', - apiKey: '', // go to https://audius.co/settings and create an app and paste the app name and api stuff into here. - apiSecret: '', - playlistLoadLimit: 100, - albumLoadLimit: 100 - }, - tidal: { - enabled: true, - token: 'token_here', //manually | or "token_here" to get a token automatically, get from tidal web player devtools; using login google account - countryCode: 'US', - playlistLoadLimit: 2, // 0 = no limit, 1 = 50 tracks, 2 = 100 tracks, etc. - playlistPageLoadConcurrency: 5, // How many pages to load simultaneously - hifiApis: [''], // optional, but required for direflct streaming, artist resolving host: https://github.com/binimum/hifi-api/ - hifiQualities: ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'] //tried sequentially until one works (only used if hifiApis is set) - }, - pandora: { - enabled: true, - // Optional, setting this manually can help unblocking countries (since pandora is US only.). May need to be updated periodically. - // fetching manually: use a vpn connected to US, go on pandora.com, open devtools, Network tab, first request to appear and copy the 2nd csrfToken= value. - // csrfToken: '', - remoteTokenUrl: 'https://get.1lucas1apk.fun/pandora/gettoken' // URL to a remote provider that returns { success: true, authToken: "...", csrfToken: "...", expires_in_seconds: ... } //https://github.com/1Lucas1apk/gettoken - }, - nicovideo: { - enabled: true - }, - reddit: { - enabled: true - }, - tumblr: { - enabled: true - }, - twitter: { - enabled: true - }, - qobuz: { - enabled: true, - userToken: '', // (optional) get from play.qobuz.com in browser devtools -> Application -> Local Storage -> localuser -> token - formatId: '5', // 5 = MP3 320kbps, 6 = FLAC (requires Studio subscription), 27 = Hi-Res FLAC - allowExplicit: true - }, - lastfm: { - enabled: true, - apiKey: '' // You can get the api key from: https://www.last.fm/api/account/create - }, - netease: { - enabled: true - }, - letrasmus: { - enabled: true - }, - yandexmusic: { - enabled: true, - accessToken: '', - allowUnavailable: false, - allowExplicit: true, - artistLoadLimit: 1, // 0 = no limit, 1 = 10 tracks, 2 = 20 tracks, etc. - albumLoadLimit: 1, // 0 = no limit, 1 = 50 tracks, 2 = 100 tracks, etc. - playlistLoadLimit: 1, // 0 = no limit, 1 = 100 tracks, 2 = 200 tracks, etc. - proxy: { - url: '', - username: '', - password: '' - } - }, - monochrome: { - enabled: true, - instances: [], // (optional) list of API instances - streamingInstances: [], // (optional) list of streaming instances - quality: 'HI_RES_LOSSLESS' // HI_RES_LOSSLESS, LOSSLESS, HIGH, LOW - }, - googledrive: { - enabled: true - } - }, - lyrics: { - fallbackSource: 'genius', - youtube: { - enabled: true - }, - genius: { - enabled: true - }, - musixmatch: { - enabled: true - // signatureSecret: '' - }, - deezer: { - enabled: true - }, - lrclib: { - enabled: true - }, - letrasmus: { - enabled: true - }, - bilibili: { - enabled: true - }, - yandexmusic: { - enabled: true - }, - monochrome: { - enabled: true - } - }, - meanings: { - letrasmus: { - enabled: true - }, - wikipedia: { - enabled: true - } - }, - audio: { - quality: 'high', // high, medium, low, lowest - encryption: 'aead_aes256_gcm_rtpsize', - resamplingQuality: 'best', // best, medium, fastest, zero order holder, linear - loudnessNormalizer: false, // Enable/disable AGC globally - lookaheadMs: 5, // Limiter lookahead buffer in milliseconds - gateThresholdLUFS: -60, // Silence threshold for AGC gate - fading: { - enabled: false, // Master switch for all fades - // type meanings: - // volume = only amplitude fades, tape = pitch/speed ramps, both = simultaneous fade and ramp, scratch = physical vinyl simulation - // curve meanings: - // linear = constant rate, exponential = slow start then faster, sinusoidal = smooth s-curve, start/wash/stop/random/baby = scratch specific movements - trackStart: { - // Effect when a new track begins - duration: 0, // ms - curve: 'linear', - type: 'volume' // volume, tape, both - }, - trackEnd: { - // Effect triggered automatically before track finishes - duration: 0, - curve: 'linear', - type: 'volume' - }, - trackStop: { - // Effect when manually stopping or skipping - duration: 0, - curve: 'linear', - type: 'volume' - }, - seek: { - // Effect applied after a seek operation - duration: 0, - curve: 'linear', - type: 'volume' - }, - pause: { - // Effect applied when pausing playback - duration: 0, - curve: 'sinusoidal', - type: 'tape' - }, - resume: { - // Effect applied when resuming from pause - duration: 0, - curve: 'sinusoidal', - type: 'tape' - }, - ducking: { - // Partial fade out for overlay events (e.g., TTS, notifications) - enabled: false, - duration: 0, // ms - targetVolume: 0.3, // Volume multiplier (0.3 = 30%) - curve: 'linear' - } - }, - crossfade: { - enabled: false, - duration: 0, // Crossfade duration in milliseconds - curve: 'sinusoidal', // linear | sine | sinusoidal - mode: 'preload', // preload or stream - minBufferMs: 250, // Minimum buffered PCM before crossfade starts - bufferMs: 0 // 0 = auto (use duration) - } - }, - voiceReceive: { - enabled: false, - format: 'opus' // pcm_s16le, opus - }, - routePlanner: { - strategy: 'RotateOnBan', // RotateOnBan, RoundRobin, LoadBalance - bannedIpCooldown: 600000, // 10 minutes - ipBlocks: [] - }, - rateLimit: { - enabled: true, - global: { - maxRequests: 1000, - timeWindowMs: 60000 // 1 minute - }, - perIp: { - maxRequests: 100, - timeWindowMs: 10000 // 10 seconds - }, - perUserId: { - maxRequests: 50, - timeWindowMs: 5000 // 5 seconds - }, - perGuildId: { - maxRequests: 20, - timeWindowMs: 5000 // 5 seconds - }, - ignorePaths: [], - ignore: { - userIds: [], - guildIds: [], - ips: [] - } - }, - dosProtection: { - enabled: true, - thresholds: { - burstRequests: 50, - timeWindowMs: 10000 // 10 seconds - }, - mitigation: { - delayMs: 500, - blockDurationMs: 300000 // 5 minutes - }, - ignore: { - userIds: [], - guildIds: [], - ips: [] - } - }, - metrics: { - enabled: true, - authorization: { - type: 'Bearer', // Bearer or Basic. - username: 'admin', - password: '' // If empty, uses server.password - } - }, - mix: { - enabled: true, - defaultVolume: 0.8, - maxLayersMix: 5, - autoCleanup: true - }, - plugins: [ - /* { - name: 'nodelink-sample-plugin', - source: 'local' - } */ - ], - pluginConfig: {} -} diff --git a/config.default.ts b/config.default.ts new file mode 100644 index 00000000..59c7cfb2 --- /dev/null +++ b/config.default.ts @@ -0,0 +1,798 @@ +import type { NodelinkConfig } from './src/typings/config/config.types.ts' + +export const config: NodelinkConfig = { + server: { + host: '0.0.0.0', + port: 3000, + password: 'youshallnotpass', + useBunServer: true + }, + + cluster: { + enabled: true, + workers: 0, + minWorkers: 1, + runtime: { + workerMaxOldSpaceMb: 0, + workerExposeGc: false, + workerExecArgv: [], + sourceWorkerMaxOldSpaceMb: 0, + sourceWorkerExposeGc: false, + sourceWorkerExecArgv: [] + }, + specializedSourceWorker: { + enabled: true, + count: 1, + microWorkers: 2, + tasksPerWorker: 32, + silentLogs: true + }, + timeouts: { + heavyMs: 6000, + fastMs: 4000 + }, + commandTimeout: 6000, + fastCommandTimeout: 4000, + maxRetries: 2, + hibernation: { + enabled: true, + timeoutMs: 1200000 + }, + scaling: { + maxPlayersPerWorker: 20, + targetUtilization: 0.7, + scaleUpThreshold: 0.75, + scaleDownThreshold: 0.3, + checkIntervalMs: 5000, + idleWorkerTimeoutMs: 60000, + queueLengthScaleUpFactor: 5, + lagPenaltyLimit: 60, + cpuPenaltyLimit: 0.85 + }, + endpoint: { + patchEnabled: true, + allowExternalPatch: false, + code: 'CAPYBARA' + } + }, + + logging: { + level: 'debug', + file: { + enabled: false, + path: 'logs', + rotation: 'daily', + ttlDays: 7 + }, + debug: { + all: false, + request: true, + session: true, + player: true, + filters: true, + sources: true, + lyrics: true, + youtube: true, + 'youtube-cipher': true, + sabr: false, + potoken: false + } + }, + + connection: { + logAllChecks: false, + interval: 300000, + timeout: 10000, + thresholds: { + bad: 1, + average: 5 + } + }, + + rateLimit: { + enabled: true, + maxEntries: 10000, + global: { + maxRequests: 1000, + timeWindowMs: 60000 + }, + perIp: { + maxRequests: 100, + timeWindowMs: 10000 + }, + perUserId: { + maxRequests: 50, + timeWindowMs: 5000 + }, + perGuildId: { + maxRequests: 20, + timeWindowMs: 5000 + }, + ignorePaths: [], + ignore: { + userIds: [], + guildIds: [], + ips: [] + } + }, + + dosProtection: { + enabled: true, + thresholds: { + burstRequests: 50, + timeWindowMs: 10000 + }, + mitigation: { + delayMs: 500, + blockDurationMs: 300000 + }, + ignore: { + userIds: [], + guildIds: [], + ips: [] + } + }, + + trustProxy: false, + + network: { + proxy: { + enabled: false, + strategy: 'RoundRobin', + retries: 3, + timeout: 10000, + shuffleOnStart: true, + list: [] + }, + connection: { + logAllChecks: false, + interval: 300000, + timeout: 10000, + thresholds: { + bad: 1, + average: 5 + } + }, + routePlanner: { + strategy: 'RotateOnBan', + bannedIpCooldown: 600000, + ipBlocks: [] + } + }, + + search: { + maxResults: 10, + defaultSource: ['youtube', 'soundcloud'], + unifiedSources: ['youtube', 'soundcloud'], + resolveExternalLinks: false, + fetchChannelInfo: false + }, + + playback: { + maxPlaylistLength: 100, + playerUpdateInterval: 2000, + statsUpdateInterval: 30000, + trackStuckThresholdMs: 10000, + eventTimeoutMs: 15000, + zombieThresholdMs: 60000, + sponsorblock: { + enabled: false, + api: 'https://sponsor.ajay.app', + categories: [ + 'sponsor', + 'selfpromo', + 'interaction', + 'intro', + 'outro', + 'preview', + 'music_offtopic', + 'filler' + ], + actionTypes: ['skip'], + skipMarginMs: 150 + }, + filters: { + enabled: { + tremolo: true, + vibrato: true, + lowpass: true, + highpass: true, + rotation: true, + karaoke: true, + distortion: true, + channelMix: true, + equalizer: true, + chorus: true, + compressor: true, + echo: true, + phaser: true, + timescale: true + } + }, + audio: { + quality: 'high', + encryption: 'aead_xchacha20_poly1305_rtpsize', + resamplingQuality: 'best', + loudnessNormalizer: false, + lookaheadMs: 5, + gateThresholdLUFS: -60, + fading: { + enabled: false, + trackStart: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + trackEnd: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + trackStop: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + seek: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + pause: { + duration: 0, + curve: 'sinusoidal', + type: 'tape' + }, + resume: { + duration: 0, + curve: 'sinusoidal', + type: 'tape' + }, + ducking: { + enabled: false, + duration: 0, + targetVolume: 0.3, + curve: 'linear' + } + }, + crossfade: { + enabled: false, + duration: 0, + curve: 'sinusoidal', + mode: 'preload', + minBufferMs: 250, + bufferMs: 0 + } + }, + voiceReceive: { + enabled: false, + format: 'opus' + }, + mix: { + enabled: true, + defaultVolume: 0.8, + maxLayersMix: 5, + autoCleanup: true + } + }, + + api: { + enableTrackStreamEndpoint: false, + enableLoadStreamEndpoint: false, + metrics: { + enabled: true, + authorization: { + type: 'Bearer', + username: 'admin', + password: '' + } + } + }, + + experimental: { + enableHoloTracks: false + }, + + sources: { + youtube: { + enabled: true, + allowItag: [], + targetItag: null, + getOAuthToken: false, + hl: 'en', + gl: 'US', + proxies: [], + fallbackSources: [ + 'soundcloud', + 'deezer', + 'jiosaavn', + 'qobuz', + 'gaana', + 'vkmusic', + 'yandexmusic', + 'audiomack', + 'bandcamp', + 'audius', + 'mixcloud', + 'bilibili', + 'bluesky', + 'nicovideo' + ], + clients: { + search: ['Android'], + playback: [ + 'AndroidVR', + 'TV_DOWN', + 'TV', + 'TVCast', + 'WebEmbedded', + 'WebParentTools', + 'Web', + 'IOS' + ], + resolve: [ + 'AndroidVR', + 'TV_DOWN', + 'TV', + 'TVCast', + 'WebEmbedded', + 'WebParentTools', + 'IOS', + 'Web' + ], + settings: { + TV: { + refreshToken: [''] + } + } + }, + cipher: { + url: 'https://cipher.kikkia.dev/api', + token: null + } + }, + + spotify: { + enabled: true, + clientId: '', + clientSecret: '', + externalAuthUrl: 'http://get.1lucas1apk.fun/spotify/gettoken', + market: 'US', + playlistLoadLimit: 1, + playlistPageLoadConcurrency: 10, + albumLoadLimit: 1, + albumPageLoadConcurrency: 5, + allowExplicit: true, + allowLocalFiles: false, + sp_dc: '' + }, + + applemusic: { + enabled: true, + mediaApiToken: 'token_here', + market: 'US', + playlistLoadLimit: 0, + albumLoadLimit: 0, + playlistPageLoadConcurrency: 5, + albumPageLoadConcurrency: 5, + allowExplicit: true + }, + + vkmusic: { + enabled: true, + userToken: '', + userCookie: '', + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + } + }, + + deezer: { + enabled: true, + arl: '', + decryptionKey: '' + }, + + tidal: { + enabled: true, + token: 'token_here', + countryCode: 'US', + playlistLoadLimit: 2, + playlistPageLoadConcurrency: 5, + hifiApis: [''], + hifiQualities: ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'] + }, + + jiosaavn: { + enabled: true, + playlistLoadLimit: 50, + artistLoadLimit: 20, + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + }, + secretKey: '38346591' + }, + + gaana: { + enabled: true, + streamQuality: 'high', + playlistLoadLimit: 100, + albumLoadLimit: 100, + artistLoadLimit: 100, + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + } + }, + + yandexmusic: { + enabled: true, + accessToken: '', + allowUnavailable: false, + allowExplicit: true, + artistLoadLimit: 1, + albumLoadLimit: 1, + playlistLoadLimit: 1, + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + } + }, + + eternalbox: { + enabled: true, + baseUrl: 'https://eternalboxmirror.xyz', + searchResults: 30, + enrichSpotify: true, + includeAnalysis: true, + includeAnalysisSummary: true, + eternalStream: true, + cacheMaxBytes: 20971520, + maxBranches: 4, + maxBranchThreshold: 75, + branchThresholdStart: 10, + branchThresholdStep: 5, + branchTargetDivisor: 6, + addLastEdge: true, + justBackwards: false, + justLongBranches: false, + removeSequentialBranches: true, + useFilteredSegments: true, + minRandomBranchChance: 0.18, + maxRandomBranchChance: 0.5, + randomBranchChanceDelta: 0.09, + timbreWeight: 1, + pitchWeight: 10, + loudStartWeight: 1, + loudMaxWeight: 1, + durationWeight: 100, + confidenceWeight: 1, + infiniteStream: true, + maxReconnects: 0, + reconnectDelayMs: 1000 + }, + + songlink: { + enabled: true, + apiKey: '', + userCountry: 'US', + songIfSingle: true, + useApi: true, + useScrapeFallback: true, + preferredPlatforms: [ + 'spotify', + 'appleMusic', + 'youtubeMusic', + 'youtube', + 'deezer', + 'tidal', + 'amazonMusic', + 'soundcloud', + 'bandcamp', + 'audius', + 'audiomack', + 'pandora', + 'itunes', + 'amazonStore' + ], + fallbackToAny: true + }, + + http: { + enabled: true, + userAgent: '' + }, + + flowery: { + enabled: true, + voice: 'Salli', + translate: false, + silence: 0, + speed: 1.0, + enforceConfig: false + }, + + lazypytts: { + enabled: true, + service: 'Cerence', + voice: 'Luciana', + maxTextLength: 3000, + enforceConfig: false + }, + + pipertts: { + enabled: false, + url: 'http://localhost:5000', + voice: 'en_US-lessac-medium', + speaker: 0, + speaker_id: '', + length_scale: 1.0, + noise_scale: 0.667, + noise_w_scale: 0.8 + }, + + audius: { + enabled: true, + appName: '', + apiKey: '', + apiSecret: '', + playlistLoadLimit: 100, + albumLoadLimit: 100 + }, + + qobuz: { + enabled: true, + userToken: '', + formatId: '5', + allowExplicit: true + }, + + monochrome: { + enabled: false, + instances: [], + streamingInstances: [], + quality: 'HI_RES_LOSSLESS', + qobuzQuality: 6 + }, + + pandora: { + enabled: true, + csrfToken: '', + remoteTokenUrl: 'https://get.1lucas1apk.fun/pandora/gettoken' + }, + + amazonmusic: { + enabled: true, + playlistLoadLimit: 0, + albumLoadLimit: 0 + }, + + bluesky: { + enabled: true, + maxSearchResults: 10 + }, + + anghami: { + enabled: false, + cookies: '' + }, + + rss: { + enabled: true + }, + + mixcloud: { + enabled: true + }, + + audiomack: { + enabled: true + }, + + bandcamp: { + enabled: true + }, + + newgrounds: { + enabled: true + }, + + soundcloud: { + enabled: true, + clientId: '' + }, + + local: { + enabled: true, + basePath: './local-music/' + }, + + vimeo: { + enabled: true + }, + + iheartradio: { + enabled: true + }, + + telegram: { + enabled: true + }, + + shazam: { + enabled: true, + allowExplicit: true + }, + + bilibili: { + enabled: true, + sessdata: '', + network: { + proxy: { + url: '', + username: '', + password: '' + } + } + }, + + genius: { + enabled: true + }, + + pinterest: { + enabled: true + }, + + 'google-tts': { + enabled: true, + language: 'en-US' + }, + + instagram: { + enabled: true + }, + + kwai: { + enabled: true + }, + + twitch: { + enabled: true + }, + + nicovideo: { + enabled: true + }, + + reddit: { + enabled: true + }, + + tumblr: { + enabled: true + }, + + twitter: { + enabled: true + }, + + lastfm: { + enabled: true, + apiKey: '' + }, + + netease: { + enabled: true + }, + + letrasmus: { + enabled: true + }, + + googledrive: { + enabled: true, + cookies: '' + }, + + tiktok: { + enabled: true + } + }, + + lyrics: { + fallbackSource: 'genius', + preferredSources: [], + youtube: { + enabled: true + }, + genius: { + enabled: true + }, + musixmatch: { + enabled: true + }, + deezer: { + enabled: true + }, + lrclib: { + enabled: true + }, + letrasmus: { + enabled: true + }, + bilibili: { + enabled: true + }, + yandexmusic: { + enabled: true + }, + monochrome: { + enabled: true + } + }, + + meanings: { + letrasmus: { + enabled: true + }, + wikipedia: { + enabled: true + } + }, + + metrics: { + enabled: true, + authorization: { + type: 'Bearer', + username: 'admin', + password: '' + } + }, + + mix: { + enabled: true, + defaultVolume: 0.8, + maxLayersMix: 5, + autoCleanup: true + }, + + plugins: [], + pluginConfig: {} +} + +export default config diff --git a/dist/config.default.js b/dist/config.default.js index c4732495..c444fd94 100644 --- a/dist/config.default.js +++ b/dist/config.default.js @@ -1,47 +1,50 @@ -export default { +export const config = { server: { host: '0.0.0.0', port: 3000, password: 'youshallnotpass', - useBunServer: false // set to true to use Bun.serve websocket (experimental) + useBunServer: true }, cluster: { - enabled: true, // active cluster (or use env CLUSTER_ENABLED) - workers: 0, // 0 => uses os.cpus().length, or specify a number (1 = 2 processes total: master + 1 worker) - minWorkers: 1, // Minimum workers to keep alive (improves availability during bursts) + enabled: true, + workers: 0, + minWorkers: 1, runtime: { - workerMaxOldSpaceMb: 0, // 0 disables override; set >0 to pass --max-old-space-size to playback workers - workerExposeGc: false, // If true, adds --expose-gc to playback workers - workerExecArgv: [], // Extra Node.js args for playback workers (e.g. ['--trace-gc']) - sourceWorkerMaxOldSpaceMb: 0, // 0 disables override; set >0 to pass --max-old-space-size to source workers - sourceWorkerExposeGc: false, // If true, adds --expose-gc to source workers - sourceWorkerExecArgv: [] // Extra Node.js args for source workers + workerMaxOldSpaceMb: 0, + workerExposeGc: false, + workerExecArgv: [], + sourceWorkerMaxOldSpaceMb: 0, + sourceWorkerExposeGc: false, + sourceWorkerExecArgv: [] }, specializedSourceWorker: { - enabled: true, // If true, source loading (search, lyrics, etc.) is delegated to dedicated workers to prevent voice worker lag - count: 1, // Number of separate process clusters for source operations - microWorkers: 2, // Number of worker threads per process cluster - tasksPerWorker: 32, // Number of parallel tasks each micro-worker can handle before queuing - silentLogs: true // If true, micro-workers will only log warnings and errors - }, - commandTimeout: 6000, // Timeout for heavy operations like loadTracks (6s) - fastCommandTimeout: 4000, // Timeout for player commands like play/pause (4s) - maxRetries: 2, // Number of retry attempts on timeout or worker failure + enabled: true, + count: 1, + microWorkers: 2, + tasksPerWorker: 32, + silentLogs: true + }, + timeouts: { + heavyMs: 6000, + fastMs: 4000 + }, + commandTimeout: 6000, + fastCommandTimeout: 4000, + maxRetries: 2, hibernation: { enabled: true, timeoutMs: 1200000 }, scaling: { - //scaling configurations - maxPlayersPerWorker: 20, // Reference capacity for utilization calculation - targetUtilization: 0.7, // Target utilization for scaling up/down - scaleUpThreshold: 0.75, // Utilization threshold to scale up - scaleDownThreshold: 0.3, // Utilization threshold to scale down - checkIntervalMs: 5000, // Interval to check for scaling needs - idleWorkerTimeoutMs: 60000, // Time in ms an idle worker should wait before being removed - queueLengthScaleUpFactor: 5, // How many commands in queue per active worker trigger scale up - lagPenaltyLimit: 60, // Event loop lag threshold (ms) to penalize worker cost - cpuPenaltyLimit: 0.85 // CPU usage threshold (85% of a core) to force scale up + maxPlayersPerWorker: 20, + targetUtilization: 0.7, + scaleUpThreshold: 0.75, + scaleDownThreshold: 0.3, + checkIntervalMs: 5000, + idleWorkerTimeoutMs: 60000, + queueLengthScaleUpFactor: 5, + lagPenaltyLimit: 60, + cpuPenaltyLimit: 0.85 }, endpoint: { patchEnabled: true, @@ -73,135 +76,379 @@ export default { }, connection: { logAllChecks: false, - interval: 300000, // 5 minutes - timeout: 10000, // 10 seconds + interval: 300000, + timeout: 10000, thresholds: { - bad: 1, // Mbps - average: 5 // Mbps + bad: 1, + average: 5 } }, - maxSearchResults: 10, - maxAlbumPlaylistLength: 100, - playerUpdateInterval: 2000, - statsUpdateInterval: 30000, - trackStuckThresholdMs: 10000, - eventTimeoutMs: 15000, - zombieThresholdMs: 60000, - enableHoloTracks: false, - enableTrackStreamEndpoint: false, - enableLoadStreamEndpoint: false, - resolveExternalLinks: false, - fetchChannelInfo: false, - sponsorblock: { - enabled: false, - api: 'https://sponsor.ajay.app', - categories: [ - 'sponsor', - 'selfpromo', - 'interaction', - 'intro', - 'outro', - 'preview', - 'music_offtopic', - 'filler' - ], - actionTypes: ['skip'], - skipMarginMs: 150 + rateLimit: { + enabled: true, + maxEntries: 10000, + global: { + maxRequests: 1000, + timeWindowMs: 60000 + }, + perIp: { + maxRequests: 100, + timeWindowMs: 10000 + }, + perUserId: { + maxRequests: 50, + timeWindowMs: 5000 + }, + perGuildId: { + maxRequests: 20, + timeWindowMs: 5000 + }, + ignorePaths: [], + ignore: { + userIds: [], + guildIds: [], + ips: [] + } }, - filters: { - enabled: { - tremolo: true, - vibrato: true, - lowpass: true, - highpass: true, - rotation: true, - karaoke: true, - distortion: true, - channelMix: true, - equalizer: true, - chorus: true, - compressor: true, - echo: true, - phaser: true, - timescale: true + dosProtection: { + enabled: true, + thresholds: { + burstRequests: 50, + timeWindowMs: 10000 + }, + mitigation: { + delayMs: 500, + blockDurationMs: 300000 + }, + ignore: { + userIds: [], + guildIds: [], + ips: [] } }, - defaultSearchSource: ['youtube', 'soundcloud'], - unifiedSearchSources: ['youtube', 'soundcloud'], - sources: { - vkmusic: { - enabled: true, - userToken: '', // (optional) get from vk in browser devtools -> reqs POST /?act=web_token HTTP/2 - headers -> response -> access_token - userCookie: '', // (required without userToken) get from vk in browser devtools -> reqs POST /?act=web_token HTTP/2 - headers -> request -> cookie (copy full cookie header) - proxy: { - url: '', - username: '', - password: '' + trustProxy: false, + network: { + proxy: { + enabled: false, + strategy: 'RoundRobin', + retries: 3, + timeout: 10000, + shuffleOnStart: true, + list: [] + }, + connection: { + logAllChecks: false, + interval: 300000, + timeout: 10000, + thresholds: { + bad: 1, + average: 5 } }, - amazonmusic: { - enabled: true + routePlanner: { + strategy: 'RotateOnBan', + bannedIpCooldown: 600000, + ipBlocks: [] + } + }, + search: { + maxResults: 10, + defaultSource: ['youtube', 'soundcloud'], + unifiedSources: ['youtube', 'soundcloud'], + resolveExternalLinks: false, + fetchChannelInfo: false + }, + playback: { + maxPlaylistLength: 100, + playerUpdateInterval: 2000, + statsUpdateInterval: 30000, + trackStuckThresholdMs: 10000, + eventTimeoutMs: 15000, + zombieThresholdMs: 60000, + sponsorblock: { + enabled: false, + api: 'https://sponsor.ajay.app', + categories: [ + 'sponsor', + 'selfpromo', + 'interaction', + 'intro', + 'outro', + 'preview', + 'music_offtopic', + 'filler' + ], + actionTypes: ['skip'], + skipMarginMs: 150 + }, + filters: { + enabled: { + tremolo: true, + vibrato: true, + lowpass: true, + highpass: true, + rotation: true, + karaoke: true, + distortion: true, + channelMix: true, + equalizer: true, + chorus: true, + compressor: true, + echo: true, + phaser: true, + timescale: true + } }, - bluesky: { - enabled: true + audio: { + quality: 'high', + encryption: 'aead_xchacha20_poly1305_rtpsize', + resamplingQuality: 'best', + loudnessNormalizer: false, + lookaheadMs: 5, + gateThresholdLUFS: -60, + fading: { + enabled: false, + trackStart: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + trackEnd: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + trackStop: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + seek: { + duration: 0, + curve: 'linear', + type: 'volume' + }, + pause: { + duration: 0, + curve: 'sinusoidal', + type: 'tape' + }, + resume: { + duration: 0, + curve: 'sinusoidal', + type: 'tape' + }, + ducking: { + enabled: false, + duration: 0, + targetVolume: 0.3, + curve: 'linear' + } + }, + crossfade: { + enabled: false, + duration: 0, + curve: 'sinusoidal', + mode: 'preload', + minBufferMs: 250, + bufferMs: 0 + } }, - anghami: { + voiceReceive: { enabled: false, - cookies: '' // Optional: Useful for accessing restricted or private content + format: 'opus' }, - rss: { - enabled: true - }, - songlink: { + mix: { enabled: true, - apiKey: '', - userCountry: 'US', - songIfSingle: true, - useApi: true, - useScrapeFallback: true, - preferredPlatforms: [ - 'spotify', - 'appleMusic', - 'youtubeMusic', - 'youtube', - 'deezer', - 'tidal', - 'amazonMusic', + defaultVolume: 0.8, + maxLayersMix: 5, + autoCleanup: true + } + }, + api: { + enableTrackStreamEndpoint: false, + enableLoadStreamEndpoint: false, + metrics: { + enabled: true, + authorization: { + type: 'Bearer', + username: 'admin', + password: '' + } + } + }, + experimental: { + enableHoloTracks: false + }, + sources: { + youtube: { + enabled: true, + allowItag: [], + targetItag: null, + getOAuthToken: false, + hl: 'en', + gl: 'US', + proxies: [], + fallbackSources: [ 'soundcloud', + 'deezer', + 'jiosaavn', + 'qobuz', + 'gaana', + 'vkmusic', + 'yandexmusic', + 'audiomack', 'bandcamp', 'audius', - 'audiomack', - 'pandora', - 'itunes', - 'amazonStore' + 'mixcloud', + 'bilibili', + 'bluesky', + 'nicovideo' ], - fallbackToAny: true + clients: { + search: ['Android'], + playback: [ + 'AndroidVR', + 'TV_DOWN', + 'TV', + 'TVCast', + 'WebEmbedded', + 'WebParentTools', + 'Web', + 'IOS' + ], + resolve: [ + 'AndroidVR', + 'TV_DOWN', + 'TV', + 'TVCast', + 'WebEmbedded', + 'WebParentTools', + 'IOS', + 'Web' + ], + settings: { + TV: { + refreshToken: [''] + } + } + }, + cipher: { + url: 'https://cipher.kikkia.dev/api', + token: null + } }, - mixcloud: { - enabled: true + spotify: { + enabled: true, + clientId: '', + clientSecret: '', + externalAuthUrl: 'http://get.1lucas1apk.fun/spotify/gettoken', + market: 'US', + playlistLoadLimit: 1, + playlistPageLoadConcurrency: 10, + albumLoadLimit: 1, + albumPageLoadConcurrency: 5, + allowExplicit: true, + allowLocalFiles: false, + sp_dc: '' }, - audiomack: { - enabled: true + applemusic: { + enabled: true, + mediaApiToken: 'token_here', + market: 'US', + playlistLoadLimit: 0, + albumLoadLimit: 0, + playlistPageLoadConcurrency: 5, + albumPageLoadConcurrency: 5, + allowExplicit: true + }, + vkmusic: { + enabled: true, + userToken: '', + userCookie: '', + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + } }, deezer: { - // arl: '', - // decryptionKey: '', - enabled: true + enabled: true, + arl: '', + decryptionKey: '' }, - bandcamp: { - enabled: true + tidal: { + enabled: true, + token: 'token_here', + countryCode: 'US', + playlistLoadLimit: 2, + playlistPageLoadConcurrency: 5, + hifiApis: [''], + hifiQualities: ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'] }, - soundcloud: { - enabled: true - // clientId: "" + jiosaavn: { + enabled: true, + playlistLoadLimit: 50, + artistLoadLimit: 20, + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + }, + secretKey: '38346591' }, - local: { + gaana: { enabled: true, - basePath: './local-music/' + streamQuality: 'high', + playlistLoadLimit: 100, + albumLoadLimit: 100, + artistLoadLimit: 100, + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + } }, - http: { + yandexmusic: { enabled: true, - userAgent: '' // Optional: defaults to NodeLink/ (https://github.com/PerformanC/NodeLink) + accessToken: '', + allowUnavailable: false, + allowExplicit: true, + artistLoadLimit: 1, + albumLoadLimit: 1, + playlistLoadLimit: 1, + proxy: { + url: '', + username: '', + password: '' + }, + network: { + proxy: { + url: '', + username: '', + password: '' + } + } }, eternalbox: { enabled: true, @@ -211,7 +458,7 @@ export default { includeAnalysis: true, includeAnalysisSummary: true, eternalStream: true, - cacheMaxBytes: 20 * 1024 * 1024, + cacheMaxBytes: 20971520, maxBranches: 4, maxBranchThreshold: 75, branchThresholdStart: 10, @@ -235,29 +482,34 @@ export default { maxReconnects: 0, reconnectDelayMs: 1000 }, - vimeo: { - // Note: not 100% of the songs are currently working (but most should.), because i need to code a different extractor for every year (2010, 2011, etc. not all are done) - enabled: true - }, - iheartradio: { - enabled: true - }, - telegram: { - enabled: true - }, - shazam: { + songlink: { enabled: true, - allowExplicit: true + apiKey: '', + userCountry: 'US', + songIfSingle: true, + useApi: true, + useScrapeFallback: true, + preferredPlatforms: [ + 'spotify', + 'appleMusic', + 'youtubeMusic', + 'youtube', + 'deezer', + 'tidal', + 'amazonMusic', + 'soundcloud', + 'bandcamp', + 'audius', + 'audiomack', + 'pandora', + 'itunes', + 'amazonStore' + ], + fallbackToAny: true }, - bilibili: { + http: { enabled: true, - sessdata: '' // Optional, improves access to some videos (premium and 4k+) - }, - genius: { - enabled: true - }, - pinterest: { - enabled: true + userAgent: '' }, flowery: { enabled: true, @@ -274,167 +526,120 @@ export default { maxTextLength: 3000, enforceConfig: false }, - jiosaavn: { - enabled: true, - playlistLoadLimit: 50, - artistLoadLimit: 20, - proxy: { - url: '', - username: '', - password: '' - } - // "secretKey": "38346591" // Optional, defaults to standard key + pipertts: { + enabled: false, + url: 'http://localhost:5000', + voice: 'en_US-lessac-medium', + speaker: 0, + speaker_id: '', + length_scale: 1.0, + noise_scale: 0.667, + noise_w_scale: 0.8 }, - gaana: { + audius: { enabled: true, - streamQuality: 'high', + appName: '', + apiKey: '', + apiSecret: '', playlistLoadLimit: 100, - albumLoadLimit: 100, - artistLoadLimit: 100, - proxy: { - url: '', // The HTTP/HTTPS proxy to use - username: '', // Optional username - password: '' // Optional password - } + albumLoadLimit: 100 }, - 'google-tts': { + qobuz: { enabled: true, - language: 'en-US' + userToken: '', + formatId: '5', + allowExplicit: true }, - // Piper TTS Configuration - // This source uses an external Piper TTS HTTP server. - // You can find the Piper HTTP server repository here: - // https://github.com/OHF-Voice/piper1-gpl/tree/main?tab=readme-ov-file - pipertts: { - enabled: false, // Disabled by default. Enable it to use Piper TTS. - url: 'http://localhost:5000' // URL of your Piper TTS server - // Optional settings (defaults from Piper): - // voice: 'en_US-lessac-medium', - // speaker: 0, - // length_scale: 1.0, - // noise_scale: 0.667, - // noise_w_scale: 0.8 + monochrome: { + enabled: false, + instances: [], + streamingInstances: [], + quality: 'HI_RES_LOSSLESS', + qobuzQuality: 6 }, - youtube: { + pandora: { enabled: true, - allowItag: [], // additional itags for audio streams, e.g., [140, 141] - targetItag: null, // force a specific itag for audio streams, overriding the quality option - getOAuthToken: false, - hl: 'en', - gl: 'US', - proxies: [ - /* { - url: "http://proxy1:port", - username: "username", - password: "password" - }, - { - url: "http://proxy2:port" - } */ - ], - fallbackSources: [ - 'soundcloud', - 'deezer', - 'jiosaavn', - 'qobuz', - 'gaana', - 'vkmusic', - 'yandexmusic', - 'audiomack', - 'bandcamp', - 'audius', - 'mixcloud', - 'bilibili', - 'bluesky', - 'nicovideo' - ], // Internal fallback chain when YouTube stream URL fails - clients: { - search: ['Android'], // Clients used for searching tracks - playback: [ - 'AndroidVR', - 'TV', - 'TVCast', - 'WebEmbedded', - 'WebParentTools', - 'Web', - 'IOS' - ], // Clients used for playback/streaming - resolve: [ - 'AndroidVR', - 'TV', - 'TVCast', - 'WebEmbedded', - 'WebParentTools', - 'IOS', - 'Web' - ], // Clients used for resolving detailed track information (channel, external links, etc.) - settings: { - TV: { - refreshToken: [''] // You can use a string "token" or an array ["token1", "token2"] for rotation/fallback - } - } - }, - cipher: { - url: 'https://cipher.kikkia.dev/api', - token: null - } + csrfToken: '', + remoteTokenUrl: 'https://get.1lucas1apk.fun/pandora/gettoken' }, - instagram: { + amazonmusic: { + enabled: true, + playlistLoadLimit: 0, + albumLoadLimit: 0 + }, + bluesky: { + enabled: true, + maxSearchResults: 10 + }, + anghami: { + enabled: false, + cookies: '' + }, + rss: { enabled: true }, - kwai: { + mixcloud: { enabled: true }, - twitch: { + audiomack: { enabled: true }, - spotify: { + bandcamp: { + enabled: true + }, + newgrounds: { + enabled: true + }, + soundcloud: { enabled: true, - clientId: '', - clientSecret: '', - externalAuthUrl: 'http://get.1lucas1apk.fun/spotify/gettoken', // URL to external token provider (e.g. http://localhost:8080/api/token - use https://github.com/topi314/spotify-tokener or https://github.com/1Lucas1apk/gettoken) - market: 'US', - playlistLoadLimit: 1, // 0 means no limit (loads all tracks), 1 = 100 tracks, 2 = 100 and so on! - playlistPageLoadConcurrency: 10, // How many pages to load simultaneously - albumLoadLimit: 1, // 0 means no limit (loads all tracks), 1 = 50 tracks, 2 = 100 tracks, etc. - albumPageLoadConcurrency: 5, // How many pages to load simultaneously - allowExplicit: true, // If true plays the explicit version of the song, If false plays the Non-Explicit version of the song. Normal songs are not affected. - allowLocalFiles: false, // If true, Spotify playlist local files are kept as placeholder tracks so they can still be searched and played through fallback sources. - sp_dc: '' // fot getting mobile token (optional) get from spotify in browser devtools -> Application -> Cookies -> sp_dc (required for canvas) + clientId: '' }, - applemusic: { + local: { enabled: true, - mediaApiToken: 'token_here', //manually | or "token_here" to get a token automatically - market: 'US', - playlistLoadLimit: 0, - albumLoadLimit: 0, - playlistPageLoadConcurrency: 5, - albumPageLoadConcurrency: 5, - allowExplicit: true + basePath: './local-music/' }, - audius: { + vimeo: { + enabled: true + }, + iheartradio: { + enabled: true + }, + telegram: { + enabled: true + }, + shazam: { enabled: true, - appName: '', - apiKey: '', // go to https://audius.co/settings and create an app and paste the app name and api stuff into here. - apiSecret: '', - playlistLoadLimit: 100, - albumLoadLimit: 100 + allowExplicit: true }, - tidal: { + bilibili: { enabled: true, - token: 'token_here', //manually | or "token_here" to get a token automatically, get from tidal web player devtools; using login google account - countryCode: 'US', - playlistLoadLimit: 2, // 0 = no limit, 1 = 50 tracks, 2 = 100 tracks, etc. - playlistPageLoadConcurrency: 5, // How many pages to load simultaneously - hifiApis: [''], // optional, but required for direflct streaming, artist resolving host: https://github.com/binimum/hifi-api/ - hifiQualities: ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'] //tried sequentially until one works (only used if hifiApis is set) + sessdata: '', + network: { + proxy: { + url: '', + username: '', + password: '' + } + } }, - pandora: { + genius: { + enabled: true + }, + pinterest: { + enabled: true + }, + 'google-tts': { enabled: true, - // Optional, setting this manually can help unblocking countries (since pandora is US only.). May need to be updated periodically. - // fetching manually: use a vpn connected to US, go on pandora.com, open devtools, Network tab, first request to appear and copy the 2nd csrfToken= value. - // csrfToken: '', - remoteTokenUrl: 'https://get.1lucas1apk.fun/pandora/gettoken' // URL to a remote provider that returns { success: true, authToken: "...", csrfToken: "...", expires_in_seconds: ... } //https://github.com/1Lucas1apk/gettoken + language: 'en-US' + }, + instagram: { + enabled: true + }, + kwai: { + enabled: true + }, + twitch: { + enabled: true }, nicovideo: { enabled: true @@ -448,15 +653,9 @@ export default { twitter: { enabled: true }, - qobuz: { - enabled: true, - userToken: '', // (optional) get from play.qobuz.com in browser devtools -> Application -> Local Storage -> localuser -> token - formatId: '5', // 5 = MP3 320kbps, 6 = FLAC (requires Studio subscription), 27 = Hi-Res FLAC - allowExplicit: true - }, lastfm: { enabled: true, - apiKey: '' // You can get the api key from: https://www.last.fm/api/account/create + apiKey: '' }, netease: { enabled: true @@ -464,32 +663,17 @@ export default { letrasmus: { enabled: true }, - yandexmusic: { - enabled: true, - accessToken: '', - allowUnavailable: false, - allowExplicit: true, - artistLoadLimit: 1, // 0 = no limit, 1 = 10 tracks, 2 = 20 tracks, etc. - albumLoadLimit: 1, // 0 = no limit, 1 = 50 tracks, 2 = 100 tracks, etc. - playlistLoadLimit: 1, // 0 = no limit, 1 = 100 tracks, 2 = 200 tracks, etc. - proxy: { - url: '', - username: '', - password: '' - } - }, - monochrome: { + googledrive: { enabled: true, - instances: [], // (optional) list of API instances - streamingInstances: [], // (optional) list of streaming instances - quality: 'HI_RES_LOSSLESS' // HI_RES_LOSSLESS, LOSSLESS, HIGH, LOW + cookies: '' }, - googledrive: { + tiktok: { enabled: true } }, lyrics: { fallbackSource: 'genius', + preferredSources: [], youtube: { enabled: true }, @@ -498,7 +682,6 @@ export default { }, musixmatch: { enabled: true - // signatureSecret: '' }, deezer: { enabled: true @@ -527,128 +710,12 @@ export default { enabled: true } }, - audio: { - quality: 'high', // high, medium, low, lowest - encryption: 'aead_aes256_gcm_rtpsize', - resamplingQuality: 'best', // best, medium, fastest, zero order holder, linear - loudnessNormalizer: false, // Enable/disable AGC globally - lookaheadMs: 5, // Limiter lookahead buffer in milliseconds - gateThresholdLUFS: -60, // Silence threshold for AGC gate - fading: { - enabled: false, // Master switch for all fades - // type meanings: - // volume = only amplitude fades, tape = pitch/speed ramps, both = simultaneous fade and ramp, scratch = physical vinyl simulation - // curve meanings: - // linear = constant rate, exponential = slow start then faster, sinusoidal = smooth s-curve, start/wash/stop/random/baby = scratch specific movements - trackStart: { - // Effect when a new track begins - duration: 0, // ms - curve: 'linear', - type: 'volume' // volume, tape, both - }, - trackEnd: { - // Effect triggered automatically before track finishes - duration: 0, - curve: 'linear', - type: 'volume' - }, - trackStop: { - // Effect when manually stopping or skipping - duration: 0, - curve: 'linear', - type: 'volume' - }, - seek: { - // Effect applied after a seek operation - duration: 0, - curve: 'linear', - type: 'volume' - }, - pause: { - // Effect applied when pausing playback - duration: 0, - curve: 'sinusoidal', - type: 'tape' - }, - resume: { - // Effect applied when resuming from pause - duration: 0, - curve: 'sinusoidal', - type: 'tape' - }, - ducking: { - // Partial fade out for overlay events (e.g., TTS, notifications) - enabled: false, - duration: 0, // ms - targetVolume: 0.3, // Volume multiplier (0.3 = 30%) - curve: 'linear' - } - }, - crossfade: { - enabled: false, - duration: 0, // Crossfade duration in milliseconds - curve: 'sinusoidal', // linear | sine | sinusoidal - mode: 'preload', // preload or stream - minBufferMs: 250, // Minimum buffered PCM before crossfade starts - bufferMs: 0 // 0 = auto (use duration) - } - }, - voiceReceive: { - enabled: false, - format: 'opus' // pcm_s16le, opus - }, - routePlanner: { - strategy: 'RotateOnBan', // RotateOnBan, RoundRobin, LoadBalance - bannedIpCooldown: 600000, // 10 minutes - ipBlocks: [] - }, - rateLimit: { - enabled: true, - global: { - maxRequests: 1000, - timeWindowMs: 60000 // 1 minute - }, - perIp: { - maxRequests: 100, - timeWindowMs: 10000 // 10 seconds - }, - perUserId: { - maxRequests: 50, - timeWindowMs: 5000 // 5 seconds - }, - perGuildId: { - maxRequests: 20, - timeWindowMs: 5000 // 5 seconds - }, - ignorePaths: [], - ignore: { - userIds: [], - guildIds: [], - ips: [] - } - }, - dosProtection: { - enabled: true, - thresholds: { - burstRequests: 50, - timeWindowMs: 10000 // 10 seconds - }, - mitigation: { - delayMs: 500, - blockDurationMs: 300000 // 5 minutes - }, - ignore: { - userIds: [], - guildIds: [], - ips: [] - } - }, metrics: { enabled: true, authorization: { - type: 'Bearer', // Bearer or Basic. + type: 'Bearer', username: 'admin', - password: '' // If empty, uses server.password + password: '' } }, mix: { @@ -657,11 +724,7 @@ export default { maxLayersMix: 5, autoCleanup: true }, - plugins: [ - /* { - name: 'nodelink-sample-plugin', - source: 'local' - } */ - ], + plugins: [], pluginConfig: {} }; +export default config; diff --git a/dist/package.json b/dist/package.json index 642296c5..dbde68d7 100644 --- a/dist/package.json +++ b/dist/package.json @@ -1,10 +1,10 @@ { "name": "nodelink", - "version": "3.8.0-dev.20260422.1", + "version": "3.8.1-dev.20260801.1", "scripts": { "build": "tsc --incremental false", - "start": "node --dns-result-order=ipv4first --import tsx src/index.ts", - "start:experimental": "node --experimental-transform-types --dns-result-order=ipv4first src/index.ts", + "start": "node -e \"const v=process.versions.node.split('.').map(Number); const t=(v[0]===22&&v[1]>=6)||v[0]>=23; require('child_process').spawnSync('node', ['--dns-result-order=ipv4first', ...(t?['--experimental-strip-types','src/index.ts']:['dist/src/index.js']), ...process.argv.slice(1)], {stdio:'inherit'})\" --", + "start:experimental": "node --dns-result-order=ipv4first src/index.ts", "start:dist": "node --dns-result-order=ipv4first dist/src/index.js", "start:bun": "bun run --dns-result-order=ipv4first src/index.ts", "type-check": "tsc --noEmit", @@ -21,24 +21,21 @@ "@ecliptia/seekable-stream": "github:1Lucas1apk/seekable-stream", "@performanc/pwsl-server": "github:performanc/internals#PWSL-server", "@performanc/voice": "github:PerformanC/voice", - "@toddynnn/symphonia-decoder": "1.0.6", + "@toddynnn/symphonia-decoder": "1.1.0", "@toddynnn/voice-opus": "^1.0.1", "fastest-validator": "^1.19.1", - "jsdom": "^29.0.2", - "mp4box": "^2.3.0", + "mp4box": "^2.4.1", "prom-client": "^15.1.3", - "proxy-agent": "^8.0.1" + "proxy-agent": "^8.0.2" }, "devDependencies": { - "@biomejs/biome": "^2.4.12", - "@commitlint/cli": "20.5.0", - "@commitlint/config-conventional": "20.5.0", - "@types/bun": "^1.3.12", - "@types/jsdom": "^28.0.1", - "@types/node": "^25.6.0", + "@biomejs/biome": "^2.5.0", + "@commitlint/cli": "21.0.2", + "@commitlint/config-conventional": "21.0.2", + "@types/bun": "^1.3.14", + "@types/node": "^26.0.0", "dotenv": "^17.4.2", "husky": "9.1.7", - "tsx": "^4.21.0", - "typescript": "^6.0.3" + "typescript": "^7.0.2" } } diff --git a/dist/src/api/connection.js b/dist/src/api/connection.js index efdfa55c..f0c2ce99 100644 --- a/dist/src/api/connection.js +++ b/dist/src/api/connection.js @@ -1,4 +1,4 @@ -import { sendResponse } from "../utils.js"; +import { sendResponse } from '../utils.js'; /** * Creates a strongly typed runtime view for the connection endpoint. * diff --git a/dist/src/api/decodeTrack.js b/dist/src/api/decodeTrack.js index c0e932b4..929b1741 100644 --- a/dist/src/api/decodeTrack.js +++ b/dist/src/api/decodeTrack.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Default validation message used when the encoded track query parameter is * absent or empty. diff --git a/dist/src/api/decodeTracks.js b/dist/src/api/decodeTracks.js index 27fcfb89..65bfd883 100644 --- a/dist/src/api/decodeTracks.js +++ b/dist/src/api/decodeTracks.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Default validation message used when the request body is not a non-empty * array of encoded track strings. diff --git a/dist/src/api/encodeTrack.js b/dist/src/api/encodeTrack.js index 049380d5..d78da288 100644 --- a/dist/src/api/encodeTrack.js +++ b/dist/src/api/encodeTrack.js @@ -1,4 +1,4 @@ -import { encodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { encodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Validation message used when no usable track payload is provided. */ diff --git a/dist/src/api/encodedTracks.js b/dist/src/api/encodedTracks.js index 641f8667..1c11e2f2 100644 --- a/dist/src/api/encodedTracks.js +++ b/dist/src/api/encodedTracks.js @@ -1,4 +1,4 @@ -import { encodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { encodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Validation message used when the request body is not a non-empty track list. */ diff --git a/dist/src/api/index.js b/dist/src/api/index.js index ced90178..736d5da4 100644 --- a/dist/src/api/index.js +++ b/dist/src/api/index.js @@ -9,8 +9,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte import fs from 'node:fs/promises'; import { dirname, join } from 'node:path'; import { fileURLToPath } from 'node:url'; -import { PATH_VERSION } from "../constants.js"; -import { logger, sendErrorResponse, sendResponse, verifyMethod } from "../utils.js"; +import { PATH_VERSION } from '../constants.js'; +import { logger, sendErrorResponse, sendResponse, verifyMethod } from '../utils.js'; const __filename = fileURLToPath(import.meta.url); const __dirname = dirname(__filename); const defaultMethods = ['GET']; @@ -81,9 +81,9 @@ async function loadRoutes() { else if (routeName.includes('.')) { const parts = routeName.split('.'); const basePattern = parts - .map((part) => (part === 'id' ? '(?:id|[A-Za-z0-9]+)' : part)) + .map((part) => (part === 'id' ? '(?:id|[A-Za-z0-9_-]+)' : part)) .join('/'); - pathname = new RegExp(`^/${PATH_VERSION}/${basePattern}(?:/[A-Za-z0-9]+)?/?$`); + pathname = new RegExp(`^/${PATH_VERSION}/${basePattern}(?:/[A-Za-z0-9_-]+)?/?$`); } else { pathname = `/${PATH_VERSION}/${routeName}`; @@ -171,7 +171,7 @@ async function requestHandler(nodelink, req, res) { parsedUrl.pathname === `/${PATH_VERSION}/profiler/ui` || parsedUrl.pathname === `/${PATH_VERSION}/profiler/file`; if (isMetricsEndpoint) { - const metricsConfig = nodelink.options.metrics || {}; + const metricsConfig = nodelink.options.api.metrics || {}; if (!metricsConfig.enabled) { logger('warn', 'Metrics', `Metrics endpoint disabled - ${clientAddress} attempted to access ${parsedUrl.pathname}`); res.writeHead(404, { 'Content-Type': 'text/plain' }); diff --git a/dist/src/api/info.js b/dist/src/api/info.js index be708869..0e179c26 100644 --- a/dist/src/api/info.js +++ b/dist/src/api/info.js @@ -1,5 +1,5 @@ import process from 'node:process'; -import { getVersion } from "../utils.js"; +import { getVersion } from '../utils.js'; /** * Creates a strongly typed runtime view for the info endpoint. * @@ -137,7 +137,7 @@ async function buildInfoResponse(nodelink) { }, isNodelink: true, sourceManagers: await getSourceManagers(nodelink), - filters: getEnabledFilterNames(nodelink.options.filters?.enabled), + filters: getEnabledFilterNames(nodelink.options.playback.filters?.enabled), plugins: getPlugins(nodelink.pluginManager) }; } diff --git a/dist/src/api/loadChapters.js b/dist/src/api/loadChapters.js index 886ae7d0..49e57c0b 100644 --- a/dist/src/api/loadChapters.js +++ b/dist/src/api/loadChapters.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Default validation message used when the `encodedTrack` query parameter is * missing or empty. @@ -29,7 +29,7 @@ function getLoadChaptersRuntime(nodelink) { const runtime = nodelink; if (runtime.sourceWorkerManager === undefined || runtime.workerManager === undefined || - !runtime.sources) { + runtime.sources === undefined) { return null; } return runtime; diff --git a/dist/src/api/loadLyrics.js b/dist/src/api/loadLyrics.js index 90281789..c41b4701 100644 --- a/dist/src/api/loadLyrics.js +++ b/dist/src/api/loadLyrics.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Default validation message used when the `encodedTrack` query parameter is * missing or empty. diff --git a/dist/src/api/loadStream.js b/dist/src/api/loadStream.js index d373aacf..8c6d41da 100644 --- a/dist/src/api/loadStream.js +++ b/dist/src/api/loadStream.js @@ -1,5 +1,5 @@ import { pipeline } from 'node:stream'; -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Cached dynamic import for the stream processor module. */ @@ -19,7 +19,7 @@ const LOAD_STREAM_HEADERS = { */ function getStreamProcessorModule() { if (!streamProcessorModulePromise) { - streamProcessorModulePromise = import("../playback/processing/streamProcessor.js"); + streamProcessorModulePromise = import('../playback/processing/streamProcessor.js'); } return streamProcessorModulePromise; } @@ -224,7 +224,7 @@ async function handler(nodelink, req, res, _sendResponse, parsedUrl) { sendErrorResponse(req, res, 500, 'Internal Server Error', 'Load stream runtime contract is incomplete.', parsedUrl.pathname, true); return; } - if (!runtime.options.enableLoadStreamEndpoint) { + if (!runtime.options.api.enableLoadStreamEndpoint) { sendErrorResponse(req, res, 404, 'Not Found', 'The requested route was not found.', parsedUrl.pathname); return; } @@ -285,7 +285,7 @@ async function handler(nodelink, req, res, _sendResponse, parsedUrl) { if (urlResult.url && !isHls && !isLocal && !isSabr) { const resource = (await createSeekeableAudioResource(input.guildId || 'api-stream', urlResult.url, input.position, undefined, streamProcessorRuntime, input.filters, { streamInfo: urlResult, - loudnessNormalizer: runtime.options.audio?.loudnessNormalizer + loudnessNormalizer: runtime.options.playback.audio?.loudnessNormalizer }, input.volume / 100, null, true)); if ('exception' in resource) { sendErrorResponse(req, res, 500, 'Internal Server Error', resource.exception.message, parsedUrl.pathname); @@ -308,7 +308,7 @@ async function handler(nodelink, req, res, _sendResponse, parsedUrl) { } fetchedStream = fetched.stream; const resource = createAudioResource(input.guildId || 'api-stream', fetched.stream, fetched.type ?? - (typeof urlResult.format === 'string' ? urlResult.format : 'unknown'), streamProcessorRuntime, input.filters, input.volume / 100, null, true, runtime.options.audio?.loudnessNormalizer); + (typeof urlResult.format === 'string' ? urlResult.format : 'unknown'), streamProcessorRuntime, input.filters, input.volume / 100, null, true, runtime.options.playback.audio?.loudnessNormalizer); pcmStream = resource.stream; } pcmStream.on('error', (error) => { diff --git a/dist/src/api/loadTracks.js b/dist/src/api/loadTracks.js index 3c49e4ec..1ebf0221 100644 --- a/dist/src/api/loadTracks.js +++ b/dist/src/api/loadTracks.js @@ -1,5 +1,5 @@ -import { logger, sendErrorResponse } from "../utils.js"; -import { validator } from "../validators.js"; +import { logger, sendErrorResponse } from '../utils.js'; +import { validator } from '../validators.js'; /** * Quick protocol matcher for absolute URLs. */ @@ -67,6 +67,13 @@ function parseIdentifier(identifier, defaultSearchSource) { if (groups.source === 'search') { return { kind: 'unifiedSearch', query: groups.query }; } + if (groups.source.toLowerCase() === 'isrc') { + return { + kind: 'search', + source: normalizeDefaultSearchSource(defaultSearchSource), + query: groups.query + }; + } return { kind: 'search', source: groups.source, query: groups.query }; } return { @@ -126,7 +133,7 @@ async function handler(nodelink, req, res, sendResponse, parsedUrl) { return sendErrorResponse(req, res, 400, 'missing identifier parameter', IDENTIFIER_REQUIRED_MESSAGE, parsedUrl.pathname, true); } logger('debug', 'Tracks', `Loading tracks with identifier: "${identifier}"`); - const target = parseIdentifier(identifier, nodelink.options.defaultSearchSource); + const target = parseIdentifier(identifier, nodelink.options.search.defaultSource); const workerRequest = buildWorkerRequest(target); const runtime = nodelink; try { diff --git a/dist/src/api/meaning.js b/dist/src/api/meaning.js index 6e5512c5..9d6ee529 100644 --- a/dist/src/api/meaning.js +++ b/dist/src/api/meaning.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Default validation message used when the `encodedTrack` query parameter is * missing or empty. diff --git a/dist/src/api/profiler.file.js b/dist/src/api/profiler.file.js index 65576d99..78e75504 100644 --- a/dist/src/api/profiler.file.js +++ b/dist/src/api/profiler.file.js @@ -1,7 +1,7 @@ import fsPromises from 'node:fs/promises'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import { sendErrorResponse, sendResponse } from "../utils.js"; +import { sendErrorResponse, sendResponse } from '../utils.js'; /** * Loopback addresses allowed to access the profiler endpoints when external * access is disabled. diff --git a/dist/src/api/profiler.js b/dist/src/api/profiler.js index afe22bd1..58740b44 100644 --- a/dist/src/api/profiler.js +++ b/dist/src/api/profiler.js @@ -3,7 +3,7 @@ import fsPromises from 'node:fs/promises'; import inspector from 'node:inspector'; import os from 'node:os'; import v8 from 'node:v8'; -import { sendErrorResponse, sendResponse } from "../utils.js"; +import { sendErrorResponse, sendResponse } from '../utils.js'; const LOOPBACKS = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']); const { NODELINK_PROFILER_DIR: profilerDirectoryEnv } = process.env; const profilerBaseDir = profilerDirectoryEnv || '.profiles'; @@ -655,8 +655,8 @@ async function runMasterProfilerCommand(action, payload) { async function runWorkerProfilerCommand(manager, workers, action, payload) { const timeoutMs = getTimeoutForAction(action); const commandPayload = { - action, - ...(payload ?? {}) + ...(payload ?? {}), + action }; const settled = await Promise.allSettled(workers.map(async (worker) => { const response = await manager.execute(worker, 'profilerCommand', commandPayload, { timeoutMs }); @@ -741,7 +741,7 @@ async function collectActionSnapshot(nodelink, action, payload) { 'Specialized source workers are not enabled or do not support profiling.'; } else { - output.sourceWorkers = await sourceManager.executeAll('profilerCommand', { action, ...safePayload }, { timeoutMs: getTimeoutForAction(action), parseJson: true }); + output.sourceWorkers = await sourceManager.executeAll('profilerCommand', { ...safePayload, action }, { timeoutMs: getTimeoutForAction(action), parseJson: true }); } } return output; diff --git a/dist/src/api/profiler.ui.js b/dist/src/api/profiler.ui.js index fee87c3a..0e8abbe9 100644 --- a/dist/src/api/profiler.ui.js +++ b/dist/src/api/profiler.ui.js @@ -1,7 +1,7 @@ import fs from 'node:fs'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import { sendErrorResponse } from "../utils.js"; +import { sendErrorResponse } from '../utils.js'; const LOOPBACKS = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']); const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); @@ -94,6 +94,7 @@ function buildPage(code) {
Trace Buffer
0
network + events
Players Active
0
across workers
Heap Pressure
0.0%
heapUsed/heapTotal
+
V8 Internal
0 MB
v8 gap
@@ -611,7 +612,18 @@ function buildPage(code) { const safeRss = Math.max(rss, 1) const heapReservedFree = Math.max(0, allocated - used) - const trackedNative = Math.max(0, Math.max(external, arrayBuffers)) + const trackedNative = Math.max(0, external + arrayBuffers) + + // V8 heap spaces sum + let v8HeapTotal = 0 + for (const p of procs) { + const spaces = p?.heapSpaces || p?.runtime?.heapSpaces || [] + for (const s of spaces) { + v8HeapTotal += Number(s?.spaceSize || 0) + } + } + const v8Internal = Math.max(0, allocated - v8HeapTotal) + const unattributed = Math.max(0, rss - used - heapReservedFree - trackedNative) const usedPct = Math.max(0, Math.min(100, (used / safeRss) * 100)) @@ -656,6 +668,9 @@ function buildPage(code) { if (memHeroMachineOtherMetric) memHeroMachineOtherMetric.textContent = fmtBytes(machineOtherAbs) + ' · ' + machineOtherPct.toFixed(1) + '%' if (memHeroMachineFreeMetric) memHeroMachineFreeMetric.textContent = fmtBytes(machineFree) + ' · ' + machineFreePct.toFixed(1) + '%' + const v8InternalEl = document.getElementById('v8Internal') + if (v8InternalEl) v8InternalEl.textContent = fmtBytes(v8Internal) + ' · ' + ((v8Internal / Math.max(rss, 1)) * 100).toFixed(1) + '%' + const masterRss = Number(snapshot?.master?.memory?.rss || 0) let workersRss = 0 for (const w of (snapshot?.workers || [])) workersRss += Number(w?.response?.memory?.rss || 0) diff --git a/dist/src/api/routeplanner.js b/dist/src/api/routeplanner.js index 341fa888..daa27e87 100644 --- a/dist/src/api/routeplanner.js +++ b/dist/src/api/routeplanner.js @@ -1,4 +1,4 @@ -import { sendErrorResponse, sendResponse } from "../utils.js"; +import { sendErrorResponse, sendResponse } from '../utils.js'; /** * Builds a strongly typed runtime view for the route planner endpoint. * diff --git a/dist/src/api/sessions.id.groups.js b/dist/src/api/sessions.id.groups.js new file mode 100644 index 00000000..cc24b1c6 --- /dev/null +++ b/dist/src/api/sessions.id.groups.js @@ -0,0 +1,413 @@ +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; +function isObjectRecord(value) { + return Boolean(value) && typeof value === 'object' && !Array.isArray(value); +} +function getGroupsRouteRuntime(nodelink) { + const runtime = nodelink; + if (!runtime.sessions || + typeof runtime.sessions.get !== 'function') { + return null; + } + return runtime; +} +function getPathParams(parsedUrl) { + const parts = parsedUrl.pathname.split('/'); + const sessionId = parts[3]; + const groupId = parts[5]; + if (!sessionId) { + return null; + } + return groupId && groupId !== '' + ? { sessionId, groupId } + : { sessionId }; +} +function normalizeTrackInfo(decodedTrack) { + return { + ...decodedTrack.info, + uri: decodedTrack.info.uri ?? '', + artworkUrl: decodedTrack.info.artworkUrl ?? null, + isrc: decodedTrack.info.isrc ?? null + }; +} +function getAudioTrackId(trackPayload) { + return trackPayload.language ?? trackPayload.audioTrackId ?? undefined; +} +async function resolvePlayPayload(nodelink, trackPayload) { + if (!trackPayload) { + return undefined; + } + if (trackPayload.encoded !== undefined) { + if (trackPayload.encoded === null) { + return null; + } + const decodedTrack = decodeTrack(trackPayload.encoded.replace(/ /g, '+')); + return { + encoded: decodedTrack.encoded, + info: normalizeTrackInfo(decodedTrack), + audioTrackId: getAudioTrackId(trackPayload) + }; + } + if (trackPayload.identifier) { + if (!nodelink.loadTrack) { + throw new Error('Track identifier loading is not supported.'); + } + const loadResult = await nodelink.loadTrack(trackPayload.identifier); + if (loadResult.loadType !== 'track') { + if (loadResult.loadType === 'empty') { + throw new Error('Track identifier resolved to no tracks.'); + } + throw new Error(`Track identifier resolved to ${loadResult.loadType}, expected 'track'.`); + } + return { + encoded: loadResult.data.encoded, + info: loadResult.data.info, + audioTrackId: getAudioTrackId(trackPayload) + }; + } + return undefined; +} +function sanitizeFadingConfig(raw) { + const safe = { + enabled: false, + trackStart: { duration: 0, curve: 'linear', type: 'volume' }, + trackEnd: { duration: 0, curve: 'linear', type: 'volume' }, + trackStop: { duration: 0, curve: 'linear', type: 'volume' }, + seek: { duration: 0, curve: 'linear', type: 'volume' }, + pause: { duration: 0, curve: 'linear', type: 'volume' }, + resume: { duration: 0, curve: 'linear', type: 'volume' } + }; + if (!isObjectRecord(raw)) { + return safe; + } + const payload = raw; + safe.enabled = payload.enabled === true; + const updateSection = (key) => { + const section = payload[key]; + const target = safe[key]; + if (!isObjectRecord(section) || !target) { + return; + } + const typedSection = section; + const { duration, curve, type } = typedSection; + if (typeof duration === 'number' && Number.isFinite(duration)) { + target.duration = Math.max(0, duration); + } + if (typeof curve === 'string') { + target.curve = curve; + } + if (type === 'volume' || + type === 'tape' || + type === 'scratch' || + type === 'both') { + target.type = type; + } + }; + updateSection('trackStart'); + updateSection('trackEnd'); + updateSection('trackStop'); + updateSection('seek'); + updateSection('pause'); + updateSection('resume'); + if (isObjectRecord(payload.ducking)) { + const duckingInput = payload.ducking; + safe.ducking = { + enabled: duckingInput.enabled === true, + duration: typeof duckingInput.duration === 'number' && Number.isFinite(duckingInput.duration) + ? Math.max(0, duckingInput.duration) + : 500, + targetVolume: typeof duckingInput.targetVolume === 'number' && Number.isFinite(duckingInput.targetVolume) + ? Math.max(0, Math.min(1, duckingInput.targetVolume)) + : 0.3, + curve: typeof duckingInput.curve === 'string' ? duckingInput.curve : 'linear' + }; + } + return safe; +} +function getGroupCreatePayload(body) { + if (!isObjectRecord(body)) + return null; + const payload = body; + const id = payload.id; + if (typeof id !== 'string' || id.length === 0) + return null; + const guildIds = payload.guildIds; + if (guildIds !== undefined) { + if (!Array.isArray(guildIds)) + return null; + for (const gid of guildIds) { + if (typeof gid !== 'string' || !/^\d{17,20}$/.test(gid)) + return null; + } + } + return { + id: id, + guildIds: guildIds ?? [] + }; +} +function getGroupPatchPayload(body) { + if (!isObjectRecord(body)) + return null; + const payload = body; + const result = {}; + if (payload.players !== undefined) { + if (!isObjectRecord(payload.players)) + return null; + const p = payload.players; + const players = {}; + if (p.add !== undefined) { + if (!Array.isArray(p.add)) + return null; + for (const gid of p.add) { + if (typeof gid !== 'string' || !/^\d{17,20}$/.test(gid)) + return null; + } + players.add = p.add; + } + if (p.remove !== undefined) { + if (!Array.isArray(p.remove)) + return null; + for (const gid of p.remove) { + if (typeof gid !== 'string') + return null; + } + players.remove = p.remove; + } + result.players = players; + } + if (payload.track !== undefined) { + if (payload.track !== null && !isObjectRecord(payload.track)) + return null; + result.track = payload.track; + } + if (payload.position !== undefined) { + if (typeof payload.position !== 'number' || + !Number.isFinite(payload.position) || + payload.position < 0) + return null; + result.position = payload.position; + } + if (payload.endTime !== undefined) { + if (payload.endTime !== null && + (typeof payload.endTime !== 'number' || + !Number.isFinite(payload.endTime) || + payload.endTime < 0)) + return null; + result.endTime = payload.endTime; + } + if (payload.volume !== undefined) { + if (typeof payload.volume !== 'number' || + !Number.isFinite(payload.volume) || + payload.volume < 0 || + payload.volume > 1000) + return null; + result.volume = payload.volume; + } + if (payload.paused !== undefined) { + if (typeof payload.paused !== 'boolean') + return null; + result.paused = payload.paused; + } + if (payload.filters !== undefined) { + if (!payload.filters || + typeof payload.filters !== 'object' || + Array.isArray(payload.filters)) + return null; + result.filters = payload.filters; + } + if (payload.fading !== undefined) { + if (!payload.fading || + typeof payload.fading !== 'object' || + Array.isArray(payload.fading)) + return null; + result.fading = payload.fading; + } + if (payload.loudnessNormalizer !== undefined) { + if (typeof payload.loudnessNormalizer !== 'boolean') + return null; + result.loudnessNormalizer = payload.loudnessNormalizer; + } + if (payload.ducking !== undefined) { + if (typeof payload.ducking !== 'boolean') + return null; + result.ducking = payload.ducking; + } + return result; +} +async function applyGroupPatch(runtime, session, groupId, payload) { + const groups = session.groups; + if (!groups.has(groupId)) { + throw new Error(`Group '${groupId}' not found`); + } + if (payload.players?.add) { + for (const guildId of payload.players.add) { + groups.addPlayer(groupId, guildId); + } + } + if (payload.players?.remove) { + for (const guildId of payload.players.remove) { + groups.removePlayer(groupId, guildId); + } + } + const guildIds = groups.getGuildIds(groupId); + let trackToPlay = undefined; + if (payload.track !== undefined) { + trackToPlay = await resolvePlayPayload(runtime, payload.track); + } + const errors = []; + const playerStates = []; + for (const guildId of guildIds) { + try { + await session.players.create(guildId); + if (trackToPlay === null) { + await session.players.stop(guildId); + } + else if (trackToPlay) { + await session.players.play(guildId, { + ...trackToPlay, + userData: payload.track?.userData, + startTime: payload.position, + endTime: payload.endTime ?? undefined + }); + } + if (payload.volume !== undefined) { + await session.players.volume(guildId, payload.volume); + } + if (payload.paused !== undefined) { + await session.players.pause(guildId, payload.paused); + } + if (payload.position !== undefined && trackToPlay === undefined) { + await session.players.seek(guildId, payload.position); + } + if (payload.endTime !== undefined && trackToPlay === undefined) { + const playerState = await session.players.toJSON(guildId); + await session.players.seek(guildId, playerState.state.position, payload.endTime ?? undefined); + } + if (payload.filters !== undefined) { + await session.players.setFilters(guildId, payload.filters); + } + if (payload.fading !== undefined) { + await session.players.setFading(guildId, sanitizeFadingConfig(payload.fading)); + } + if (payload.loudnessNormalizer !== undefined) { + await session.players.setLoudnessNormalizer(guildId, payload.loudnessNormalizer); + } + if (payload.ducking !== undefined) { + await session.players.setDucking(guildId, payload.ducking); + } + const state = await session.players.toJSON(guildId); + playerStates.push(state); + await new Promise(resolve => setTimeout(resolve, 35)); + } + catch (err) { + const message = err instanceof Error ? err.message : String(err); + logger('error', 'GroupUpdate', `Failed to apply patch to guild ${guildId} in group '${groupId}': ${message}`); + errors.push({ guildId, error: message }); + } + } + const groupJson = groups.toJSON(groupId); + return { + ...groupJson, + players: playerStates, + ...(errors.length > 0 ? { errors } : {}) + }; +} +/** + * Handles requests for the groups route. + * + * Supports: + * - `GET /sessions/:id/groups` — list all groups + * - `GET /sessions/:id/groups/:groupId` — get specific group + * - `POST /sessions/:id/groups` — create a new group + * - `PATCH /sessions/:id/groups/:groupId` — update group (membership + orchestration) + * - `DELETE /sessions/:id/groups/:groupId` — delete group (does not destroy players) + */ +async function handler(nodelink, req, res, sendResponse, parsedUrl) { + const runtime = getGroupsRouteRuntime(nodelink); + if (!runtime) { + sendErrorResponse(req, res, 500, 'Internal Server Error', 'Groups runtime contract is incomplete.', parsedUrl.pathname, true); + return; + } + const pathParams = getPathParams(parsedUrl); + if (!pathParams) { + sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid path parameters', parsedUrl.pathname); + return; + } + const session = runtime.sessions.get(pathParams.sessionId); + if (!session) { + sendErrorResponse(req, res, 404, 'Not Found', "The provided sessionId doesn't exist.", parsedUrl.pathname); + return; + } + try { + if (!pathParams.groupId) { + if (req.method === 'GET') { + sendResponse(req, res, session.groups.list(), 200); + return; + } + if (req.method === 'POST') { + const payload = getGroupCreatePayload(req.body); + if (!payload) { + sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid group creation payload. Required: { id: string, guildIds?: string[] }', parsedUrl.pathname); + return; + } + session.groups.create(payload.id, payload.guildIds); + sendResponse(req, res, session.groups.toJSON(payload.id), 201); + return; + } + sendErrorResponse(req, res, 405, 'Method Not Allowed', 'Method Not Allowed', parsedUrl.pathname); + return; + } + if (req.method === 'GET') { + const group = session.groups.toJSON(pathParams.groupId); + if (!group) { + sendErrorResponse(req, res, 404, 'Not Found', `Group '${pathParams.groupId}' not found.`, parsedUrl.pathname); + return; + } + sendResponse(req, res, group, 200); + return; + } + if (req.method === 'DELETE') { + if (!session.groups.has(pathParams.groupId)) { + sendErrorResponse(req, res, 404, 'Not Found', `Group '${pathParams.groupId}' not found.`, parsedUrl.pathname); + return; + } + session.groups.delete(pathParams.groupId); + sendResponse(req, res, null, 204); + return; + } + if (req.method === 'PATCH') { + if (!session.groups.has(pathParams.groupId)) { + sendErrorResponse(req, res, 404, 'Not Found', `Group '${pathParams.groupId}' not found.`, parsedUrl.pathname); + return; + } + const payload = getGroupPatchPayload(req.body); + if (!payload) { + sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid group patch payload.', parsedUrl.pathname); + return; + } + const result = await applyGroupPatch(runtime, session, pathParams.groupId, payload); + sendResponse(req, res, result, 200); + return; + } + } + catch (error) { + const errorMessage = error instanceof Error ? error.message : 'Unhandled group error'; + if (errorMessage.includes('not found') || + errorMessage.includes('already exists')) { + const status = errorMessage.includes('already exists') ? 409 : 404; + sendErrorResponse(req, res, status, status === 409 ? 'Conflict' : 'Not Found', errorMessage, parsedUrl.pathname); + return; + } + logger('error', 'GroupUpdate', `Unhandled error: ${errorMessage}`, error); + sendErrorResponse(req, res, 500, 'Internal Server Error', errorMessage, parsedUrl.pathname, true); + return; + } + sendErrorResponse(req, res, 405, 'Method Not Allowed', 'Method Not Allowed', parsedUrl.pathname); +} +/** + * Route module definition for the groups route. + */ +const groupsRoute = { + handler, + methods: ['GET', 'POST', 'PATCH', 'DELETE'] +}; +export default groupsRoute; diff --git a/dist/src/api/sessions.id.js b/dist/src/api/sessions.id.js index abe5f65c..a42c9a63 100644 --- a/dist/src/api/sessions.id.js +++ b/dist/src/api/sessions.id.js @@ -1,4 +1,4 @@ -import { logger, sendErrorResponse } from "../utils.js"; +import { logger, sendErrorResponse } from '../utils.js'; /** * Builds a strongly typed runtime view for the session patch endpoint. * diff --git a/dist/src/api/sessions.id.players.id.lyrics.subscribe.js b/dist/src/api/sessions.id.players.id.lyrics.subscribe.js index af1b4fd7..834973e1 100644 --- a/dist/src/api/sessions.id.players.id.lyrics.subscribe.js +++ b/dist/src/api/sessions.id.players.id.lyrics.subscribe.js @@ -1,4 +1,4 @@ -import { logger, sendErrorResponse } from "../utils.js"; +import { logger, sendErrorResponse } from '../utils.js'; /** * Builds a strongly typed runtime view for the lyrics subscription route. * diff --git a/dist/src/api/sessions.id.players.id.mix.id.js b/dist/src/api/sessions.id.players.id.mix.id.js index 6706cc5e..81602c1e 100644 --- a/dist/src/api/sessions.id.players.id.mix.id.js +++ b/dist/src/api/sessions.id.players.id.mix.id.js @@ -1,4 +1,4 @@ -import { logger, sendErrorResponse } from "../utils.js"; +import { logger, sendErrorResponse } from '../utils.js'; /** * Builds a strongly typed runtime view for the mix item route. * diff --git a/dist/src/api/sessions.id.players.id.mix.js b/dist/src/api/sessions.id.players.id.mix.js index ba679a77..727f5ecd 100644 --- a/dist/src/api/sessions.id.players.id.mix.js +++ b/dist/src/api/sessions.id.players.id.mix.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Builds a strongly typed runtime view for the mix collection route. * @@ -130,7 +130,7 @@ async function handleCreateMix(req, res, pathParams, runtime, sendResponse, pars sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid parameters', parsedUrl.pathname, true); return; } - const mixConfig = runtime.options.mix ?? { + const mixConfig = runtime.options.playback.mix ?? { enabled: true, defaultVolume: 0.8, maxLayersMix: 5, diff --git a/dist/src/api/sessions.id.players.id.sponsorblock.js b/dist/src/api/sessions.id.players.id.sponsorblock.js index 2aae63c6..daf18591 100644 --- a/dist/src/api/sessions.id.players.id.sponsorblock.js +++ b/dist/src/api/sessions.id.players.id.sponsorblock.js @@ -1,4 +1,4 @@ -import { sendErrorResponse } from "../utils.js"; +import { sendErrorResponse } from '../utils.js'; /** * Builds a strongly typed runtime view for the SponsorBlock route. * @@ -44,7 +44,7 @@ async function handleGetSponsorBlock(req, res, pathParams, runtime, sendResponse return; } try { - const state = session.players.getSponsorBlock(pathParams.guildId); + const state = await session.players.getSponsorBlock(pathParams.guildId); sendResponse(req, res, state, 200); } catch (error) { @@ -67,13 +67,17 @@ async function handlePatchSponsorBlock(req, res, pathParams, runtime, sendRespon return; } try { - session.players.updateSponsorBlock(pathParams.guildId, { + const result = await session.players.updateSponsorBlock(pathParams.guildId, { enabled: body.enabled, categories: body.categories, actionTypes: body.actionTypes, skipMarginMs: body.skipMarginMs }); - sendResponse(req, res, session.players.getSponsorBlock(pathParams.guildId), 200); + if (result && 'status' in result && result.status !== 200) { + sendErrorResponse(req, res, result.status || 500, 'Internal Server Error', result.message || 'Operation failed', req.url || ''); + return; + } + sendResponse(req, res, await session.players.getSponsorBlock(pathParams.guildId), 200); } catch (error) { const errorMessage = error instanceof Error ? error.message : 'Player not found'; @@ -95,8 +99,12 @@ async function handlePostSponsorBlock(req, res, pathParams, runtime, sendRespons return; } try { - session.players.setSponsorBlockSegments(pathParams.guildId, body.segments); - sendResponse(req, res, session.players.getSponsorBlock(pathParams.guildId), 200); + const result = await session.players.setSponsorBlockSegments(pathParams.guildId, body.segments); + if (result && 'status' in result && result.status !== 200) { + sendErrorResponse(req, res, result.status || 500, 'Internal Server Error', result.message || 'Operation failed', req.url || ''); + return; + } + sendResponse(req, res, await session.players.getSponsorBlock(pathParams.guildId), 200); } catch (error) { const errorMessage = error instanceof Error ? error.message : 'Player not found'; @@ -113,7 +121,7 @@ async function handleDeleteSponsorBlock(req, res, pathParams, runtime) { return; } try { - session.players.clearSponsorBlock(pathParams.guildId); + await session.players.clearSponsorBlock(pathParams.guildId); res.writeHead(204); res.end(); } diff --git a/dist/src/api/sessions.id.players.js b/dist/src/api/sessions.id.players.js index c65c575c..50eb09af 100644 --- a/dist/src/api/sessions.id.players.js +++ b/dist/src/api/sessions.id.players.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Validates that a value is a non-array object. * @@ -206,6 +206,10 @@ function getPlayerPatchPayload(body) { typeof loudnessNormalizer !== 'boolean') { return null; } + const ducking = payload.ducking; + if (ducking !== undefined && typeof ducking !== 'boolean') { + return null; + } const filtersValue = payload.filters; if (filtersValue !== undefined && (!filtersValue || @@ -243,6 +247,7 @@ function getPlayerPatchPayload(body) { volume, paused, loudnessNormalizer, + ducking, filters: filtersValue, fading, voice: voice ?? undefined @@ -296,6 +301,19 @@ function sanitizeFadingConfig(raw) { updateSection('seek'); updateSection('pause'); updateSection('resume'); + if (isObjectRecord(payload.ducking)) { + const duckingInput = payload.ducking; + safe.ducking = { + enabled: duckingInput.enabled === true, + duration: typeof duckingInput.duration === 'number' && Number.isFinite(duckingInput.duration) + ? Math.max(0, duckingInput.duration) + : 500, + targetVolume: typeof duckingInput.targetVolume === 'number' && Number.isFinite(duckingInput.targetVolume) + ? Math.max(0, Math.min(1, duckingInput.targetVolume)) + : 0.3, + curve: typeof duckingInput.curve === 'string' ? duckingInput.curve : 'linear' + }; + } return safe; } /** @@ -500,6 +518,9 @@ async function applyPlayerPatch(runtime, session, guildId, payload, query) { if (payload.loudnessNormalizer !== undefined) { await session.players.setLoudnessNormalizer(guildId, payload.loudnessNormalizer); } + if (payload.ducking !== undefined) { + await session.players.setDucking(guildId, payload.ducking); + } return await session.players.toJSON(guildId); } /** diff --git a/dist/src/api/stats.js b/dist/src/api/stats.js index abb9de29..b6331f29 100644 --- a/dist/src/api/stats.js +++ b/dist/src/api/stats.js @@ -1,4 +1,4 @@ -import { getStats } from "../utils.js"; +import { getStats } from '../utils.js'; /** * Builds a strongly typed runtime view for the stats endpoint. * diff --git a/dist/src/api/trackstream.js b/dist/src/api/trackstream.js index b408bc08..169aa8da 100644 --- a/dist/src/api/trackstream.js +++ b/dist/src/api/trackstream.js @@ -1,4 +1,4 @@ -import { decodeTrack, logger, sendErrorResponse } from "../utils.js"; +import { decodeTrack, logger, sendErrorResponse } from '../utils.js'; /** * Default validation message used when the `encodedTrack` query parameter is * missing or empty. @@ -57,7 +57,7 @@ function getTrackStreamRuntime(nodelink) { * @returns Promise that resolves once the response has been written. */ async function handler(nodelink, req, res, sendResponse, parsedUrl) { - if (!nodelink.options.enableTrackStreamEndpoint) { + if (!nodelink.options.api.enableTrackStreamEndpoint) { sendErrorResponse(req, res, 404, 'Not Found', 'The requested route was not found.', parsedUrl.pathname); return; } diff --git a/dist/src/api/workers.js b/dist/src/api/workers.js index d8d86c00..1c42917e 100644 --- a/dist/src/api/workers.js +++ b/dist/src/api/workers.js @@ -1,4 +1,4 @@ -import { sendErrorResponse, sendResponse } from "../utils.js"; +import { sendErrorResponse, sendResponse } from '../utils.js'; /** * Loopback addresses allowed to access the workers patch endpoint when * external patching is disabled. diff --git a/dist/src/api/youtube.config.js b/dist/src/api/youtube.config.js index 4548a1cd..a82d68fb 100644 --- a/dist/src/api/youtube.config.js +++ b/dist/src/api/youtube.config.js @@ -1,5 +1,5 @@ -import OAuth from "../sources/youtube/OAuth.js"; -import { logger, sendErrorResponse } from "../utils.js"; +import OAuth from '../sources/youtube/OAuth.js'; +import { logger, sendErrorResponse } from '../utils.js'; /** * Returns whether the provided body value is a plain object record. * diff --git a/dist/src/api/youtube.oauth.js b/dist/src/api/youtube.oauth.js index cee57a6b..c7aab864 100644 --- a/dist/src/api/youtube.oauth.js +++ b/dist/src/api/youtube.oauth.js @@ -1,4 +1,4 @@ -import { logger, makeRequest, sendErrorResponse } from "../utils.js"; +import { logger, makeRequest, sendErrorResponse } from '../utils.js'; /** * Google OAuth client identifier used by the YouTube refresh flow. * diff --git a/dist/src/constants.js b/dist/src/constants.js index c113dc20..0d18285a 100644 --- a/dist/src/constants.js +++ b/dist/src/constants.js @@ -305,6 +305,8 @@ export const SupportedFormats = { WAV: 'wav', /** Flash Video container format */ FLV: 'flv', + /** Apple Lossless Audio Codec */ + ALAC: 'alac', /** Unknown or unsupported audio format */ UNKNOWN: 'unknown' }; @@ -369,6 +371,8 @@ export function normalizeFormat(type) { if (!type) return SupportedFormats.UNKNOWN; const lowerType = type.toLowerCase(); + if (lowerType.includes('alac')) + return SupportedFormats.ALAC; if (lowerType.includes('opus') || lowerType.includes('webm') || lowerType.includes('weba')) diff --git a/dist/src/index.js b/dist/src/index.js index 720b2751..0558f543 100644 --- a/dist/src/index.js +++ b/dist/src/index.js @@ -12,21 +12,25 @@ import http from 'node:http'; import { resolve as resolvePath } from 'node:path'; import { pathToFileURL } from 'node:url'; import WebSocketServer from '@performanc/pwsl-server'; -import RoutePlannerManager from "./managers/routePlannerManager.js"; -import SessionManager from "./managers/sessionManager.js"; -import StatsManager from "./managers/statsManager.js"; -import { applyEnvOverrides, checkForUpdates, cleanupHttpAgents, cleanupLogger, decodeTrack, getGitInfo, getStats, getVersion, initLogger, logger, parseClient, verifyDiscordID } from "./utils.js"; +import RoutePlannerManager from './managers/routePlannerManager.js'; +import SessionManager from './managers/sessionManager.js'; +import StatsManager from './managers/statsManager.js'; +import { migrateConfig, persistConfig } from './modules/config/configMigration.js'; +import { cleanupBunServer, createBunServer } from './server/bunServer.js'; +import { applyEnvOverrides, checkDependencyUpdates, checkForUpdates, cleanupHttpAgents, cleanupLogger, decodeTrack, getGitInfo, getStats, getVersion, initLogger, logger, parseClient, verifyDiscordID } from './utils.js'; import 'dotenv/config'; -import { GatewayEvents, MINIMUM_NODE_VERSION } from "./constants.js"; -import ConfigValidationManager from "./managers/configValidationManager.js"; -import DosProtectionManager from "./managers/dosProtectionManager.js"; -import PluginManager from "./managers/pluginManager.js"; -import RateLimitManager from "./managers/rateLimitManager.js"; -import { parseVoiceFrameHeader } from "./voice/voiceFrames.js"; -import { createVoiceRelay } from "./voice/voiceRelay.js"; +import { GatewayEvents, MINIMUM_NODE_VERSION } from './constants.js'; +import ConfigValidationManager from './managers/configValidationManager.js'; +import DosProtectionManager from './managers/dosProtectionManager.js'; +import PluginManager from './managers/pluginManager.js'; +import RateLimitManager from './managers/rateLimitManager.js'; +import { parseVoiceFrameHeader } from './voice/voiceFrames.js'; +import { createVoiceRelay } from './voice/voiceRelay.js'; let requestHandlerPromise = null; let profilerApiPromise = null; -const isRuntimeAtLeast = (current, minimum) => current.replace(/^v/, '').localeCompare(minimum.replace(/^v/, ''), undefined, { +const isRuntimeAtLeast = (current, minimum) => current + .replace(/^v/, '') + .localeCompare(minimum.replace(/^v/, ''), undefined, { numeric: true }) >= 0; const NODE_LTS_CREDENTIAL_KEY = 'runtime.node.latestLts'; @@ -85,13 +89,13 @@ const getLatestNodeLtsVersion = async (credentialManager) => { }; const getRequestHandler = async () => { if (!requestHandlerPromise) { - requestHandlerPromise = import("./api/index.js").then((module) => module.default); + requestHandlerPromise = import('./api/index.js').then((module) => module.default); } return requestHandlerPromise; }; const getProfilerApi = async () => { if (!profilerApiPromise) { - profilerApiPromise = import("./api/profiler.js"); + profilerApiPromise = import('./api/profiler.js'); } return profilerApiPromise; }; @@ -119,61 +123,126 @@ const memoryTrace = (stage) => { let playerManagerClassPromise = null; const getPlayerManagerClass = async () => { if (!playerManagerClassPromise) { - playerManagerClassPromise = import("./managers/playerManager.js").then((module) => module.default); + playerManagerClassPromise = import('./managers/playerManager.js').then((module) => module.default); } return playerManagerClassPromise; }; let workerManagerClassPromise = null; const getWorkerManagerClass = async () => { if (!workerManagerClassPromise) { - workerManagerClassPromise = import("./managers/workerManager.js").then((module) => module.default); + workerManagerClassPromise = import('./managers/workerManager.js').then((module) => module.default); } return workerManagerClassPromise; }; let sourceWorkerManagerClassPromise = null; const getSourceWorkerManagerClass = async () => { if (!sourceWorkerManagerClassPromise) { - sourceWorkerManagerClassPromise = import("./managers/sourceWorkerManager.js").then((module) => module.default); + sourceWorkerManagerClassPromise = import('./managers/sourceWorkerManager.js').then((module) => module.default); } return sourceWorkerManagerClassPromise; }; let credentialManagerClassPromise = null; const getCredentialManagerClass = async () => { if (!credentialManagerClassPromise) { - credentialManagerClassPromise = import("./managers/credentialManager.js").then((module) => module.default); + credentialManagerClassPromise = import('./managers/credentialManager.js').then((module) => module.default); } return credentialManagerClassPromise; }; let trackCacheManagerClassPromise = null; const getTrackCacheManagerClass = async () => { if (!trackCacheManagerClassPromise) { - trackCacheManagerClassPromise = import("./managers/trackCacheManager.js").then((module) => module.default); + trackCacheManagerClassPromise = import('./managers/trackCacheManager.js').then((module) => module.default); } return trackCacheManagerClassPromise; }; let config; -const resolveRootConfigUrl = (fileName) => pathToFileURL(resolvePath(process.cwd(), fileName)).href; -try { - config = (await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.js')))) - .default; -} -catch (e) { - const error = e; - if (error.code === 'ERR_MODULE_NOT_FOUND' || error.code === 'ENOENT') { +const loadConfig = async () => { + const resolveRootConfigUrl = (fileName) => pathToFileURL(resolvePath(process.cwd(), fileName)).href; + const resolveConfigExport = (importedModule, fileName) => { + const candidate = importedModule.default ?? + importedModule.config; + if (candidate && + typeof candidate === 'object' && + Object.keys(candidate).length > 0) { + return candidate; + } + throw new Error(`[ERROR] Config: ${fileName} must export a non-empty configuration object (default export or named "config").`); + }; + /** + * Loads and merges configuration files. + * Prioritizes config.ts/js, falls back to config.default.ts/js. + * @returns Migrated and merged configuration object. + */ + const loadAndMerge = async () => { + // 1. Load defaults (Mandatory) + let baseConfig = {}; + let defaultFileName = 'config.default.ts'; try { - config = (await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.default.js')))) - .default; - console.log('[WARN] Config: config.js not found, using config.default.js. It is recommended to create a config.js file for your own configuration.'); + const module = await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.default.ts'))); + baseConfig = resolveConfigExport(module, 'config.default.ts'); } - catch (e2) { - console.error('[ERROR] Config: Failed to load config.default.js. Please make sure it exists.'); - throw e2; + catch { + try { + const module = await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.default.js'))); + baseConfig = resolveConfigExport(module, 'config.default.js'); + defaultFileName = 'config.default.js'; + } + catch { + throw new Error('[ERROR] Config: Base configuration (config.default.ts/js) not found.'); + } } - } - else { - throw e; - } -} + // 2. Try to load user configuration + let userConfig = {}; + let userFileName = null; + const userCandidates = ['config.ts', 'config.js']; + for (const fileName of userCandidates) { + try { + const module = await import(__rewriteRelativeImportExtension(resolveRootConfigUrl(fileName))); + userConfig = resolveConfigExport(module, fileName); + userFileName = fileName; + console.log(`[INFO] Config: Loaded user configuration from ${fileName}`); + break; + } + catch (e) { + const error = e; + const isNotFound = error.code === 'ERR_MODULE_NOT_FOUND' || + error.code === 'ENOENT' || + error.message?.includes('Cannot find module'); + if (isNotFound) + continue; + throw e; + } + } + if (!userFileName) { + console.log(`[INFO] Config: No user configuration found. Using defaults.`); + } + // 3. Merge user config over defaults + // We do a deep merge for 'sources', 'lyrics', 'meanings', 'pluginConfig' + // and a shallow merge for the rest to keep it simple but functional. + const merged = { ...baseConfig }; + for (const [key, value] of Object.entries(userConfig)) { + if (value && + typeof value === 'object' && + !Array.isArray(value) && + baseConfig[key] && + typeof baseConfig[key] === 'object' && + !Array.isArray(baseConfig[key])) { + merged[key] = { + ...baseConfig[key], + ...value + }; + } + else { + merged[key] = value; + } + } + const migrated = migrateConfig(merged); + await persistConfig(migrated, userFileName ?? defaultFileName); + return migrated; + }; + return await loadAndMerge(); +}; +config = await loadConfig(); // Apply environment variable overrides after config is loaded applyEnvOverrides(config); const clusterEnabled = @@ -191,6 +260,21 @@ else if (typeof config.cluster?.workers === 'number') initLogger(config); const isBun = typeof Bun !== 'undefined'; if (!cluster.isWorker) { + const supportGuidelines = `\x1b[35m +╭──────────────────────────────────────────────────────────────────────────────╮ +│ SUPPORT GUIDELINES │ +│ │ +│ 1. Turn on debugging in config.ts before asking for help. │ +│ 2. Test the 'dev' branch (git checkout dev) to ensure it's not fixed yet. │ +│ 3. If providing logs, start copying EXACTLY from this box onwards. │ +│ 4. Cut logs or missing Node.js version will result in an ignored ticket. │ +│ 5. FAQ and Rules: https://discord.gg/bVz6ppZ3SP │ +│ https://discord.gg/z4ayqfeBdB │ +╰──────────────────────────────────────────────────────────────────────────────╯\x1b[0m + + * +`; + process.stdout.write(supportGuidelines); const ascii = ` ▄ ████▄ ██▄ ▄███▄ █ ▄█ ▄ █ █▀ █ █ █ █ █ █▀ ▀ █ ██ █ █▄█ @@ -198,107 +282,23 @@ if (!cluster.isWorker) { █ █ █ ▀████ █ █ █▄ ▄▀ ███▄ ▐█ █ █ █ █ █ v${getVersion()} █ █ █ ███▀ ▀███▀ ▀ ▐ █ █ █ █ Powered by PerformanC; █ ██ █ ██ ▀ rewritten by 1Lucas1.apk; + maintained by 1Lucas1.apk & ToddyTheNoobDud `; process.stdout.write(`\x1b[32m${ascii}\x1b[0m\n`); -} -await checkForUpdates(); -memoryTrace('bootstrap:after-check-for-updates'); -/** - * Wrapper for Bun's ServerWebSocket that implements EventEmitter - * Provides compatibility with Node.js WebSocket implementations - */ -class BunSocketWrapper extends EventEmitter { - ws; - remoteAddress; - /** - * Creates a new BunSocketWrapper - * @param ws - Bun ServerWebSocket instance - */ - constructor(ws) { - super(); - this.ws = ws; - this.remoteAddress = ws?.data?.remoteAddress || 'unknown'; - } - /** - * Sends data through the WebSocket connection - * @param data - Data to send - * @returns True if sent successfully - */ - /** - * Sends data through the WebSocket connection - * @param data - Data to send - * @returns True if sent successfully - * @public - */ - send(data) { - try { - const r = this.ws.send(data); - return r !== 0; - } - catch { - return false; - } - } - /** - * Sends a WebSocket ping frame - * @param data - Optional ping data - * @returns True if sent successfully - * @public - */ - ping(data) { - try { - this.ws.ping?.(data); - return true; - } - catch { - return false; - } - } - /** - * Closes the connection. - * - * Here is a list of close codes: - * - `1000` means "normal closure" **(default)** - * - `1009` means a message was too big and was rejected - * - `1011` means the server encountered an error - * - `1012` means the server is restarting - * - `1013` means the server is too busy or the client is rate-limited - * - `4000` through `4999` are reserved for applications (you can use it!) - * - * To close the connection abruptly, use `terminate()`. - * - * @param code The close code to send - * @param reason The close reason to send - * @public - */ - close(code, reason) { - this.ws.close(code, reason); + try { + await checkForUpdates(); } - /** - * Terminates the connection immediately - * @public - */ - terminate() { - this.ws.close(1000, 'Terminated'); + catch (e) { + logger('error', 'Git', `Update check failed: ${e.message}`); } - /** - * Internal handler for received messages - * @param message - Message data - * @internal - */ - _handleMessage(message) { - this.emit('message', message); + try { + await checkDependencyUpdates(); } - /** - * Internal handler for connection close events - * @param code - Close code - * @param reason - Close reason - * @internal - */ - _handleClose(code, reason) { - this.emit('close', code, reason); + catch (e) { + logger('error', 'Git', `Dependency check failed: ${e.message}`); } } +memoryTrace('bootstrap:after-check-for-updates'); /** * Main NodeLink server class * Handles WebSocket connections, audio sources, and player management @@ -314,6 +314,7 @@ class NodelinkServer extends EventEmitter { lyrics; meanings; _sourceInitPromise; + proxyManager; routePlanner; credentialManager; trackCacheManager; @@ -360,6 +361,7 @@ class NodelinkServer extends EventEmitter { this._sourceInitPromise = this._initSources(isClusterPrimary, options); this.routePlanner = new RoutePlannerManager(this); memoryTrace('constructor:after-route-planner'); + this.proxyManager = null; this.credentialManager = null; memoryTrace('constructor:after-credential-manager'); this.trackCacheManager = null; @@ -395,8 +397,8 @@ class NodelinkServer extends EventEmitter { }; this.voiceSockets = new Map(); this.voiceRelay = createVoiceRelay({ - enabled: options.voiceReceive?.enabled || false, - format: options.voiceReceive?.format || 'pcm', + enabled: options.playback.voiceReceive?.enabled || false, + format: options.playback.voiceReceive?.format || 'pcm', sendFrame: (frame) => this.handleVoiceFrame(frame), logger }); @@ -426,9 +428,9 @@ class NodelinkServer extends EventEmitter { async _initSources(isClusterPrimary, _options) { if (!isClusterPrimary) { const [{ default: sourceMan }, { default: lyricsMan }, { default: meaningMan }] = await Promise.all([ - import("./managers/sourceManager.js"), - import("./managers/lyricsManager.js"), - import("./managers/meaningManager.js") + import('./managers/sourceManager.js'), + import('./managers/lyricsManager.js'), + import('./managers/meaningManager.js') ]); this.sources = new sourceMan(this); this.lyrics = new lyricsMan(this); @@ -442,7 +444,7 @@ class NodelinkServer extends EventEmitter { await this._connectionManagerInitPromise; return; } - this._connectionManagerInitPromise = import("./managers/connectionManager.js") + this._connectionManagerInitPromise = import('./managers/connectionManager.js') .then(({ default: ConnectionManagerClass }) => { if (!this.connectionManager) { this.connectionManager = new ConnectionManagerClass(this); @@ -478,12 +480,18 @@ class NodelinkServer extends EventEmitter { await this._persistenceManagersInitPromise; } /** - * Starts the heartbeat interval to keep WebSocket connections alive + * Starts the heartbeat interval to keep WebSocket connections alive. + * + * No-op when running under `Bun.serve` because Bun handles WebSocket pings + * natively via `websocket.sendPings: true`. Running both would double the + * keepalive traffic. * @internal */ _startHeartbeat() { if (this._heartbeatInterval) return; + if (this._usingBunServer) + return; this._heartbeatInterval = setInterval(() => { for (const session of this.sessions.activeSessions.values()) { if (session.socket && !session.isPaused) { @@ -637,60 +645,62 @@ class NodelinkServer extends EventEmitter { return originalOn(event, listener); }; logger('debug', 'Resume', `Processing websocket connection. oldSessionId: ${oldSessionId}`); + let session = null; if (oldSessionId) { - const session = this.sessions.resume(oldSessionId, socket); - if (session) { - logger('info', 'Server', `\x1b[36m${clientInfo.name}\x1b[0m${clientInfo.version - ? `/\x1b[32mv${clientInfo.version}\x1b[0m` - : ''} resumed session with ID: ${oldSessionId}`); - this.statsManager.incrementSessionResume(clientInfo.name, true); - socket.on('close', (...args) => { - const code = args[0]; - const reason = args[1]; - if (!this.sessions.has(oldSessionId)) - return; - const session = this.sessions.get(oldSessionId); - if (!session) - return; - logger('info', 'Server', `\x1b[36m${clientInfo.name}\x1b[0m/\x1b[32mv${clientInfo.version}\x1b[0m disconnected with code ${code} and reason: ${reason || 'without reason'}`); - if (session.resuming) { - this.sessions.pause(oldSessionId); - } - else { - this.sessions.shutdown(oldSessionId); - } - const sessionCount = this.sessions.activeSessions?.size || 0; - this.statsManager.setWebsocketConnections(sessionCount); - }); - socket.send(JSON.stringify({ - op: 'ready', - resumed: true, - sessionId: oldSessionId - })); - while (session.eventQueue.length > 0) { - const event = session.eventQueue.shift(); - if (event) - socket.send(event); + session = this.sessions.resume(oldSessionId, socket); + if (!session) { + logger('warn', 'Server', `Session-ID provided by ${clientInfo.name} does not exist or is not resumable: ${oldSessionId}, creating a new session`); + } + } + if (session) { + logger('info', 'Server', `\x1b[36m${clientInfo.name}\x1b[0m${clientInfo.version ? `/\x1b[32mv${clientInfo.version}\x1b[0m` : ''} resumed session with ID: ${oldSessionId}`); + this.statsManager.incrementSessionResume(clientInfo.name, true); + socket.on('close', (...args) => { + const code = args[0]; + const reason = args[1]; + if (!this.sessions.has(oldSessionId)) + return; + const session = this.sessions.get(oldSessionId); + if (!session) + return; + logger('info', 'Server', `\x1b[36m${clientInfo.name}\x1b[0m/\x1b[32mv${clientInfo.version}\x1b[0m disconnected with code ${code} and reason: ${reason || 'without reason'}`); + if (session.resuming) { + this.sessions.pause(oldSessionId); } - for (const [playerKey, playerInfo] of session.players.players.entries()) { - if (this.workerManager) { - const worker = this.workerManager.getWorkerForGuild(playerKey); - if (worker) { - this.workerManager.execute(worker, 'playerCommand', { - sessionId: session.id, - guildId: playerInfo.guildId, - command: 'forceUpdate', - args: [] - }); - } - } - else { - playerInfo._sendUpdate(); - } + else { + this.sessions.shutdown(oldSessionId); } const sessionCount = this.sessions.activeSessions?.size || 0; this.statsManager.setWebsocketConnections(sessionCount); + }); + socket.send(JSON.stringify({ + op: 'ready', + resumed: true, + sessionId: oldSessionId + })); + while (session.eventQueue.length > 0) { + const event = session.eventQueue.shift(); + if (event) + socket.send(event); } + for (const [playerKey, playerInfo] of session.players.players.entries()) { + if (this.workerManager) { + const worker = this.workerManager.getWorkerForGuild(playerKey); + if (worker) { + this.workerManager.execute(worker, 'playerCommand', { + sessionId: session.id, + guildId: playerInfo.guildId, + command: 'forceUpdate', + args: [] + }); + } + } + else { + playerInfo._sendUpdate(); + } + } + const sessionCount = this.sessions.activeSessions?.size || 0; + this.statsManager.setWebsocketConnections(sessionCount); } else { const sessionId = this.sessions.create(request, socket, clientInfo); @@ -867,275 +877,90 @@ class NodelinkServer extends EventEmitter { }, allocEveryMs); } }); - } - /** - * Creates and configures Bun HTTP server with WebSocket support - * @internal - */ - _createBunServer() { - const port = this.options.server.port; - const host = this.options.server.host || '0.0.0.0'; - const password = this.options.server.password; - const self = this; - logger('warn', 'Server', 'Running with Bun.serve, remember this is experimental!'); - this.server = Bun.serve({ - port, - hostname: host, - maxRequestBodySize: 1024 * 1024 * 50, - async fetch(req, server) { - const url = new URL(req.url); - const pathname = url.pathname.endsWith('/') - ? url.pathname.slice(0, -1) - : url.pathname; - if (pathname === '/v4/profiler/socket') { - const remoteAddress = server.requestIP(req)?.address || 'unknown'; - const isInternal = /^(::1|localhost|127\.0\.0\.1)/.test(remoteAddress); - const endpoint = self.options.cluster?.endpoint || {}; - const patchEnabled = endpoint.patchEnabled === true; - const allowExternalPatch = endpoint.allowExternalPatch === true; - const expectedCode = typeof endpoint.code === 'string' && endpoint.code.length > 0 - ? endpoint.code - : 'CAPYBARA'; - const providedCode = url.searchParams.get('code') || - req.headers.get('x-nodelink-code') || - req.headers.get('x-worker-code'); - if (!patchEnabled) { - return new Response('Profiler socket endpoint is disabled.', { - status: 403, - statusText: 'Forbidden' - }); - } - if (!allowExternalPatch && !isInternal) { - return new Response('External profiler socket access is blocked.', { - status: 403, - statusText: 'Forbidden' - }); - } - if (!providedCode || providedCode !== expectedCode) { - return new Response('Invalid or missing profiler code.', { - status: 403, - statusText: 'Forbidden' - }); - } - const success = server.upgrade(req, { - data: { - clientInfo: { name: 'ProfilerUI', version: '1' }, - sessionId: null, - reqHeaders: Object.fromEntries(req.headers), - remoteAddress, - url: req.url - } - }); - if (success) - return undefined; - return new Response('WebSocket upgrade failed', { status: 400 }); + this.socket?.on('/v4/websocket/voice', (socket, request, _clientInfo, _sessionId, guildId) => { + socket.guildId = guildId; + if (!this.options.playback.voiceReceive?.enabled) { + try { + socket.close(1008, 'Voice receive disabled'); } - if (pathname === '/v4/websocket') { - const remoteAddress = server.requestIP(req)?.address || 'unknown'; - const clientAddress = `[External] (${remoteAddress})`; - const clientName = req.headers.get('client-name'); - const auth = req.headers.get('authorization'); - const userId = req.headers.get('user-id'); - const sessionId = req.headers.get('session-id'); - if (auth !== password) { - logger('warn', 'Server', `Unauthorized connection attempt from ${clientAddress} - Invalid password provided: ${auth || 'None'}`); - return new Response('Invalid password provided.', { - status: 401, - statusText: 'Unauthorized', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }); - } - if (!clientName) { - logger('warn', 'Server', `Missing client-name from ${clientAddress}`); - return new Response('Invalid or missing Client-Name header.', { - status: 400, - statusText: 'Bad Request', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }); - } - if (!userId || !verifyDiscordID(userId)) { - logger('warn', 'Server', `Invalid user ID from ${clientAddress}`); - return new Response('Invalid or missing User-Id header.', { - status: 400, - statusText: 'Bad Request', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }); - } - const clientInfo = parseClient(clientName); - if (!clientInfo) { - logger('warn', 'Server', `Invalid client-name from ${clientAddress}`); - return new Response('Invalid or missing Client-Name header.', { - status: 400, - statusText: 'Bad Request', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }); + catch { } + return; + } + logger('info', 'Voice', `Voice websocket connected from ${request.socket?.remoteAddress || 'unknown'} | guild ${guildId}`); + this.registerVoiceSocket(guildId, socket); + }); + this.socket?.on('/v4/websocket/youtube/live', (socket, request, _clientInfo, _sessionId, id) => { + let videoId = id; + socket.guildId = id; // Tag it with videoId or guildId equivalent + if (/^\d{17,20}$/.test(id)) { + const player = this.sessions.getPlayer(id); + if (player?.track?.info?.sourceName?.includes('youtube')) { + videoId = player.track.info.identifier; + } + } + else if (id.length > 50) { + try { + const decoded = decodeTrack(id); + if (decoded?.info?.sourceName?.includes('youtube')) { + videoId = decoded.info.identifier; } - const success = server.upgrade(req, { - data: { - clientInfo, - sessionId, - reqHeaders: Object.fromEntries(req.headers), - remoteAddress, - url: req.url - } - }); - if (success) - return undefined; - return new Response('WebSocket upgrade failed', { - status: 400, - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }); } - return new Promise((resolve) => { - const reqShim = { - method: req.method, - url: url.pathname + url.search, - headers: Object.fromEntries(req.headers), - socket: { remoteAddress: server.requestIP(req)?.address }, - on: (event, cb) => { - if (event === 'data') { - req - .arrayBuffer() - .then((buf) => { - cb(Buffer.from(buf)); - if (reqShim._endCb) - reqShim._endCb(); - }) - .catch(() => { }); - } - if (event === 'end') { - reqShim._endCb = cb; - } - } - }; - const resShim = { - _status: 200, - _headers: {}, - _body: [], - writeHead(status, headers) { - this._status = status; - if (headers) - Object.assign(this._headers, headers); - }, - setHeader(name, value) { - this._headers[name] = value; - }, - getHeader(name) { - return this._headers[name]; - }, - end(data) { - if (data) - this._body.push(data); - const finalBody = Buffer.concat(this._body.map((chunk) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))); - const headers = new Headers(); - for (const [key, value] of Object.entries(this._headers)) { - if (Array.isArray(value)) { - for (const v of value) - headers.append(key, v); - } - else if (value !== undefined) { - headers.set(key, String(value)); - } - } - const response = new Response(finalBody, { - status: this._status, - headers - }); - resolve(response); - }, - write(data) { - if (data) - this._body.push(data); - } - }; - void getRequestHandler() - .then((handler) => handler(self, reqShim, resShim)) - .catch((error) => { - logger('error', 'Server', `Failed to handle Bun request: ${error.message}`); - if (!resShim._status || resShim._status < 400) { - resShim.writeHead(500, { 'Content-Type': 'text/plain' }); - } - resShim.end('Internal Server Error'); + catch (_e) { } + } + if (!this.sourceWorkerManager) { + const yt = this.sources?.getSource('youtube'); + if (!yt) { + socket.close(1008, 'YouTube source not enabled'); + return; + } + const liveChatFn = yt.handleLiveChat; + if (typeof liveChatFn === 'function') { + liveChatFn.call(yt, socket, videoId); + } + else { + socket.close(1008, 'YouTube live chat not supported'); + } + return; + } + logger('info', 'YouTube-LiveChat', `Delegating live chat for video: ${videoId} to worker`); + const resShim = { + headersSent: false, + send: (data) => { + const payload = Buffer.isBuffer(data) + ? data + : Buffer.from(String(data)); + socket.sendFrame?.(payload, { + len: payload.length, + fin: true, + opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 }); - }); - }, - websocket: { - sendPings: true, - data: {}, - open(ws) { - if (!ws.data) - return; - const wrapper = new BunSocketWrapper(ws); - ws.data.wrapper = wrapper; - const { clientInfo, sessionId, reqHeaders } = ws.data; - const reqShim = { - headers: reqHeaders, - url: ws.data.url, - socket: { remoteAddress: ws.data.remoteAddress } - }; - let pathname = '/v4/websocket'; - try { - pathname = new URL(ws.data.url).pathname; - } - catch { } - if (pathname === '/v4/profiler/socket') { - logger('info', 'ProfilerSocket', `Profiler socket connected from [External] (${ws.data.remoteAddress})`); - self.socket?.emit('/v4/profiler/socket', wrapper, reqShim, null, null); - return; - } - logger('info', 'Server', `\x1b[36m${clientInfo.name}\x1b[0m${clientInfo.version ? `/\x1b[32mv${clientInfo.version}\x1b[0m` : ''} connected from [External] (${ws.data.remoteAddress}) | \x1b[33mURL:\x1b[0m ${ws.data.url}`); - let eventName = '/v4/websocket'; - let guildId = null; - let liveId = null; - try { - const url = new URL(ws.data.url); - const voiceMatch = url.pathname.match(/^\/v4\/websocket\/voice\/([A-Za-z0-9]+)\/?$/); - const liveMatch = url.pathname.match(/^\/v4\/websocket\/youtube\/live\/([^/]+)\/?$/); - if (voiceMatch) { - if (!self.options.voiceReceive?.enabled) { - try { - wrapper.close(1008, 'Voice receive disabled'); - } - catch { } - return; - } - eventName = '/v4/websocket/voice'; - guildId = voiceMatch[1]; - } - else if (liveMatch) { - eventName = '/v4/websocket/youtube/live'; - liveId = liveMatch[1]; - } - } - catch { } - if (self.socket) { - self.socket.emit(eventName, wrapper, reqShim, clientInfo, sessionId, guildId || liveId); - } }, - message(ws, message) { - ws.data?.wrapper?._handleMessage(message); + writeHead: (status) => { + if (status !== 200) + socket.close(1011, 'Worker failed'); }, - close(ws, code, reason) { - ws.data?.wrapper?._handleClose(code, reason); - } - } + write: (data) => { + const payload = Buffer.isBuffer(data) + ? data + : Buffer.from(String(data)); + socket.sendFrame?.(payload, { + len: payload.length, + fin: true, + opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 + }); + }, + end: () => socket.close(1000, 'Finished'), + on: (event, cb) => socket.on(event, cb) + }; + this.sourceWorkerManager.delegate(request, resShim, 'loadLiveChat', { videoId }, { isWebSocket: true }); }); - logger('started', 'Server', `Successfully listening on ${host}:${port} (Bun Native)`); + } + /** + * Creates and configures Bun HTTP server with WebSocket support + * @internal + */ + _createBunServer() { + this.server = createBunServer(this, getRequestHandler); } /** * Creates HTTP server (Node.js or Bun) @@ -1294,7 +1119,7 @@ class NodelinkServer extends EventEmitter { logger('warn', 'Server', `Unauthorized connection attempt from ${clientAddress} - Invalid user ID provided`); return rejectUpgrade(400, 'Bad Request', 'Invalid User-Id header.'); } - if (voiceMatch && !this.options.voiceReceive?.enabled) { + if (voiceMatch && !this.options.playback.voiceReceive?.enabled) { return rejectUpgrade(404, 'Not Found', 'Voice websocket endpoint is disabled.'); } for (const key in headers) { @@ -1330,83 +1155,6 @@ class NodelinkServer extends EventEmitter { return rejectUpgrade(404, 'Not Found', 'Invalid path for WebSocket upgrade.'); } }); - this.socket?.on('/v4/websocket/voice', (socket, request, _clientInfo, _sessionId, guildId) => { - socket.guildId = guildId; - if (!this.options.voiceReceive?.enabled) { - try { - socket.close(1008, 'Voice receive disabled'); - } - catch { } - return; - } - logger('info', 'Voice', `Voice websocket connected from ${request.socket?.remoteAddress || 'unknown'} | guild ${guildId}`); - this.registerVoiceSocket(guildId, socket); - }); - this.socket?.on('/v4/websocket/youtube/live', (socket, request, _clientInfo, _sessionId, id) => { - let videoId = id; - socket.guildId = id; // Tag it with videoId or guildId equivalent - if (/^\d{17,20}$/.test(id)) { - const player = this.sessions.getPlayer(id); - if (player?.track?.info?.sourceName?.includes('youtube')) { - videoId = player.track.info.identifier; - } - } - else if (id.length > 50) { - try { - const decoded = decodeTrack(id); - if (decoded?.info?.sourceName?.includes('youtube')) { - videoId = decoded.info.identifier; - } - } - catch (_e) { } - } - if (!this.sourceWorkerManager) { - const yt = this.sources?.getSource('youtube'); - if (!yt) { - socket.close(1008, 'YouTube source not enabled'); - return; - } - const liveChatFn = yt.handleLiveChat; - if (typeof liveChatFn === 'function') { - liveChatFn.call(yt, socket, videoId); - } - else { - socket.close(1008, 'YouTube live chat not supported'); - } - return; - } - logger('info', 'YouTube-LiveChat', `Delegating live chat for video: ${videoId} to worker`); - const resShim = { - headersSent: false, - send: (data) => { - const payload = Buffer.isBuffer(data) - ? data - : Buffer.from(String(data)); - socket.sendFrame?.(payload, { - len: payload.length, - fin: true, - opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 - }); - }, - writeHead: (status) => { - if (status !== 200) - socket.close(1011, 'Worker failed'); - }, - write: (data) => { - const payload = Buffer.isBuffer(data) - ? data - : Buffer.from(String(data)); - socket.sendFrame?.(payload, { - len: payload.length, - fin: true, - opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 - }); - }, - end: () => socket.close(1000, 'Finished'), - on: (event, cb) => socket.on(event, cb) - }; - this.sourceWorkerManager.delegate(request, resShim, 'loadLiveChat', { videoId }, { isWebSocket: true }); - }); } /** * Starts listening on configured port and host @@ -1443,12 +1191,12 @@ class NodelinkServer extends EventEmitter { _startGlobalUpdater() { if (this._globalUpdater) return; - const updateInterval = Math.max(1, this.options?.playerUpdateInterval ?? 5000); - const statsSendInterval = Math.max(1, this.options?.statsUpdateInterval ?? 30000); - const metricsInterval = this.options?.metrics?.enabled + const updateInterval = Math.max(1, this.options?.playback.playerUpdateInterval ?? 5000); + const statsSendInterval = Math.max(1, this.options?.playback.statsUpdateInterval ?? 30000); + const metricsInterval = this.options?.api.metrics?.enabled ? 5000 : statsSendInterval; - const zombieThreshold = this.options?.zombieThresholdMs ?? 60000; + const zombieThreshold = this.options?.playback.zombieThresholdMs ?? 60000; this._globalUpdater = setInterval(() => { for (const session of this.sessions.values()) { if (!session.players) @@ -1540,16 +1288,7 @@ class NodelinkServer extends EventEmitter { */ async _cleanupWebSocketServer() { if (this._usingBunServer && this.server) { - try { - logger('info', 'WebSocket', 'Stopping Bun server...'); - await this.server.stop(true); - this.server.unref(); - logger('info', 'WebSocket', 'Bun server stopped successfully'); - } - catch (e) { - const error = e; - logger('error', 'WebSocket', `Error stopping Bun server: ${error?.message ?? String(e)}`); - } + await cleanupBunServer(this, this.server); return; } if (this.socket) { @@ -1726,7 +1465,7 @@ class NodelinkServer extends EventEmitter { if (startOptions.isClusterWorker) { logger('info', 'Server', 'Running as cluster worker — waiting for sockets from master.'); process.on('message', (msg, handle) => { - if (!msg || msg.type !== 'sticky-session') + if (msg?.type !== 'sticky-session') return; if (!handle) return; @@ -1773,8 +1512,8 @@ class NodelinkServer extends EventEmitter { _startMasterMetricsUpdater() { if (this._globalUpdater) return; - const statsSendInterval = Math.max(1, this.options?.statsUpdateInterval ?? 30000); - const metricsInterval = this.options?.metrics?.enabled + const statsSendInterval = Math.max(1, this.options?.playback.statsUpdateInterval ?? 30000); + const metricsInterval = this.options?.api.metrics?.enabled ? 5000 : statsSendInterval; let lastStatsSendTime = 0; @@ -1897,8 +1636,8 @@ process.on('unhandledRejection', (reason, promise) => { }); if (clusterEnabled && cluster.isPrimary) { if (config.sources?.youtube?.getOAuthToken) { - // dynamicly import OAuth (if enabled) - const OAuth = (await import("./sources/youtube/OAuth.js").catch((e) => { + // dynamically import OAuth (if enabled) + const OAuth = (await import('./sources/youtube/OAuth.js').catch((e) => { logger('error', 'youtube', `\x1b[1m\x1b[31mOAuth class not found Error: ${e.message}\x1b[0m`); process.exit(1); })).default; @@ -1944,6 +1683,8 @@ if (clusterEnabled && cluster.isPrimary) { process.stdout.write('\n \x1b[32m💚 Thank you for using NodeLink!\x1b[0m\n'); process.stdout.write(' \x1b[37mIf you have ideas, suggestions or want to report bugs, join us on Discord:\x1b[0m\n'); process.stdout.write(' \x1b[1m\x1b[34m➜\x1b[0m \x1b[36mhttps://discord.gg/fzjksWS65v\x1b[0m\n\n'); + process.stdout.write(' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mHaving issues? Use "git checkout dev" to see if it\'s fixed.\x1b[0m\n'); + process.stdout.write(' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mRead the FAQ & follow the support template in our Discord.\x1b[0m\n\n'); logger('info', 'Server', 'Shutdown signal received. Cleaning up resources...'); nserver._stopHeartbeat(); await nserver.credentialManager?.forceSave(); @@ -1971,7 +1712,7 @@ if (clusterEnabled && cluster.isPrimary) { }); } else if (clusterEnabled && cluster.isWorker) { - await import("./workers/main.js"); + await import('./workers/main.js'); } else { const serverInstancePromise = (async () => { @@ -1991,6 +1732,12 @@ else { await nserver.credentialManager?.forceSave(); await nserver.trackCacheManager?.forceSave(); nserver.sourceWorkerManager?.destroy?.(); + nserver.workerManager?.destroy?.(); + nserver.connectionManager?.destroy?.(); + nserver.proxyManager?.destroy?.(); + nserver.routePlanner?.dispose?.(); + nserver.credentialManager?.destroy?.(); + nserver.trackCacheManager?.destroy?.(); await nserver._cleanupWebSocketServer(); if (nserver.server?.listening) { await new Promise((resolve) => nserver.server.close(resolve)); @@ -2003,6 +1750,8 @@ else { process.stdout.write('\n \x1b[32m💚 Thank you for using NodeLink!\x1b[0m\n'); process.stdout.write(' \x1b[37mIf you have ideas, suggestions or want to report bugs, join us on Discord:\x1b[0m\n'); process.stdout.write(' \x1b[1m\x1b[34m➜\x1b[0m \x1b[36mhttps://discord.gg/fzjksWS65v\x1b[0m\n\n'); + process.stdout.write(' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mHaving issues? Use "git checkout dev" to see if it\'s fixed.\x1b[0m\n'); + process.stdout.write(' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mRead the FAQ & follow the support template in our Discord.\x1b[0m\n\n'); process.exit(0); }; process.once('SIGINT', shutdown); diff --git a/dist/src/lyrics/bilibili.js b/dist/src/lyrics/bilibili.js index 9acce379..0e314632 100644 --- a/dist/src/lyrics/bilibili.js +++ b/dist/src/lyrics/bilibili.js @@ -1,5 +1,5 @@ import crypto from 'node:crypto'; -import { logger, makeRequest } from "../utils.js"; +import { logger, makeRequest } from '../utils.js'; /** * WBI mixin index table used for signing. * @internal diff --git a/dist/src/lyrics/deezer.js b/dist/src/lyrics/deezer.js index 53b47ea8..d5f25066 100644 --- a/dist/src/lyrics/deezer.js +++ b/dist/src/lyrics/deezer.js @@ -1,4 +1,4 @@ -import { getBestMatch, logger, makeRequest } from "../utils.js"; +import { getBestMatch, logger, makeRequest } from '../utils.js'; /** * Deezer lyrics provider utilizing the Deezer GraphQL internal API. * Supports word-by-word and line-level synchronization. diff --git a/dist/src/lyrics/genius.js b/dist/src/lyrics/genius.js index 168beb04..9aa39eab 100644 --- a/dist/src/lyrics/genius.js +++ b/dist/src/lyrics/genius.js @@ -1,4 +1,4 @@ -import { logger, makeRequest } from "../utils.js"; +import { logger, makeRequest } from '../utils.js'; const CLEAN_PATTERNS = [ /\s*\([^)]*(?:official|lyrics?|video|audio|mv|visualizer|color\s*coded|hd|4k|prod\.)[^)]*\)/gi, /\s*\[[^\]]*(?:official|lyrics?|video|audio|mv|visualizer|color\s*coded|hd|4k|prod\.)[^\]]*\]/gi, diff --git a/dist/src/lyrics/letrasmus.js b/dist/src/lyrics/letrasmus.js index 104e8368..f5da9734 100644 --- a/dist/src/lyrics/letrasmus.js +++ b/dist/src/lyrics/letrasmus.js @@ -1,4 +1,4 @@ -import { http1makeRequest, logger } from "../utils.js"; +import { http1makeRequest, logger } from '../utils.js'; /** * Letras suggest endpoint for track discovery. * @internal diff --git a/dist/src/lyrics/lrclib.js b/dist/src/lyrics/lrclib.js index f2d06c64..5262fd0b 100644 --- a/dist/src/lyrics/lrclib.js +++ b/dist/src/lyrics/lrclib.js @@ -1,4 +1,4 @@ -import { logger, makeRequest } from "../utils.js"; +import { logger, makeRequest } from '../utils.js'; const CLEAN_PATTERNS = [ /\s*\([^)]*(?:official|lyrics?|video|audio|mv|visualizer|color\s*coded|hd|4k|prod\.)[^)]*\)/gi, /\s*\[[^\]]*(?:official|lyrics?|video|audio|mv|visualizer|color\s*coded|hd|4k|prod\.)[^\]]*\]/gi, diff --git a/dist/src/lyrics/monochrome.js b/dist/src/lyrics/monochrome.js index 34c5de90..6ed0c29a 100644 --- a/dist/src/lyrics/monochrome.js +++ b/dist/src/lyrics/monochrome.js @@ -1,4 +1,4 @@ -import { logger, makeRequest } from "../utils.js"; +import { logger, makeRequest } from '../utils.js'; /** * Monochrome lyrics provider. * @@ -18,10 +18,8 @@ export default class MonochromeLyrics { */ constructor(nodelink) { this.nodelink = nodelink; - const sources = nodelink.options?.sources; - const config = sources?.monochrome || { - enabled: false - }; + const sources = nodelink.options.sources; + const config = sources.monochrome; const defaultUrls = [ 'https://eu-central.monochrome.tf', 'https://us-west.monochrome.tf', diff --git a/dist/src/lyrics/musixmatch.js b/dist/src/lyrics/musixmatch.js index 0bf4aeec..72edd46e 100644 --- a/dist/src/lyrics/musixmatch.js +++ b/dist/src/lyrics/musixmatch.js @@ -2,7 +2,7 @@ import crypto from 'node:crypto'; import { readFile, unlink, writeFile } from 'node:fs/promises'; import os from 'node:os'; import path from 'node:path'; -import { http1makeRequest, logger } from "../utils.js"; +import { http1makeRequest, logger } from '../utils.js'; class HttpError extends Error { status; constructor(status, message) { diff --git a/dist/src/lyrics/yandexmusic.js b/dist/src/lyrics/yandexmusic.js index f1383eac..02903be5 100644 --- a/dist/src/lyrics/yandexmusic.js +++ b/dist/src/lyrics/yandexmusic.js @@ -1,5 +1,5 @@ import crypto from 'node:crypto'; -import { http1makeRequest, logger } from "../utils.js"; +import { http1makeRequest, logger } from '../utils.js'; /** * Base URL for Yandex Music API. * @internal diff --git a/dist/src/lyrics/youtube.js b/dist/src/lyrics/youtube.js index c8ec4ff7..c5343b62 100644 --- a/dist/src/lyrics/youtube.js +++ b/dist/src/lyrics/youtube.js @@ -1,4 +1,4 @@ -import { logger, makeRequest } from "../utils.js"; +import { logger, makeRequest } from '../utils.js'; /** * Decodes common HTML entities found in YouTube caption segments. * @param text - Raw caption text. diff --git a/dist/src/managers/baseCacheManager.js b/dist/src/managers/baseCacheManager.js new file mode 100644 index 00000000..1b6bc21c --- /dev/null +++ b/dist/src/managers/baseCacheManager.js @@ -0,0 +1,321 @@ +import crypto from 'node:crypto'; +import fs from 'node:fs/promises'; +import { logger } from '../utils.js'; +const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value); +const getErrorMessage = (error) => error instanceof Error ? error.message : String(error ?? 'Unknown error'); +const getErrorCode = (error) => { + if (!error || typeof error !== 'object' || !('code' in error)) { + return undefined; + } + const code = error.code; + return typeof code === 'string' ? code : undefined; +}; +/** + * Generic encrypted cache file store using AES-256-GCM. + * Handles atomic saves, TTL purging, and max entry eviction. + */ +export default class BaseCacheManager { + cacheName; + passwordHashKey; + salt; + key; + legacyKey; + filePath; + tempFilePath; + saveDelayMs; + cleanupIntervalMs; + maxEntries; + version; + cache; + saveTimeout; + cleanupInterval; + savePromise; + saveQueued; + lastLoadedAt; + lastSavedAt; + constructor(options) { + this.cacheName = options.name; + this.passwordHashKey = options.passwordHashKey; + this.salt = options.salt; + this.filePath = options.filePath; + this.tempFilePath = `${options.filePath}.tmp`; + this.saveDelayMs = options.saveDelayMs ?? 5000; + this.cleanupIntervalMs = options.cleanupIntervalMs ?? 60000; + this.maxEntries = options.maxEntries ?? 0; + this.version = options.version ?? 1; + this.key = this._deriveFastKey(this.passwordHashKey); + this.legacyKey = null; + this.cache = new Map(); + this.saveTimeout = null; + this.savePromise = null; + this.saveQueued = false; + this.lastLoadedAt = null; + this.lastSavedAt = null; + this.cleanupInterval = setInterval(() => { + const expiredCount = this._purgeExpired(); + const evictedCount = this._enforceMaxEntries(); + if (expiredCount > 0 || evictedCount > 0) + this.save(); + }, this.cleanupIntervalMs); + this.cleanupInterval.unref?.(); + } + async load() { + try { + const data = await fs.readFile(this.filePath); + if (data.length < 32) + return; + let payload; + let migratedFromLegacy = false; + try { + payload = this._decodePayload(data, this.key); + } + catch { + const legacyKey = this._getLegacyKey(); + payload = this._decodePayload(data, legacyKey); + migratedFromLegacy = true; + } + this.cache = new Map(Object.entries(payload.entries)); + const expiredCount = this._purgeExpired(); + const evictedCount = this._enforceMaxEntries(); + if (expiredCount > 0 || evictedCount > 0 || migratedFromLegacy) + this.save(); + this.lastLoadedAt = Date.now(); + logger('debug', this.cacheName, `Loaded ${this.cache.size} entries from disk.`); + } + catch (error) { + const code = getErrorCode(error); + if (code !== 'ENOENT') { + logger('error', this.cacheName, `Failed to load cache: ${getErrorMessage(error)}`); + } + this.cache = new Map(); + } + } + save() { + if (this.saveTimeout) + return; + this.saveTimeout = setTimeout(() => { + this.saveTimeout = null; + void this.forceSave(); + }, this.saveDelayMs); + } + async forceSave() { + if (this.saveTimeout) { + clearTimeout(this.saveTimeout); + this.saveTimeout = null; + } + try { + this._purgeExpired(); + this._enforceMaxEntries(); + await this._flushSaveQueue(); + logger('debug', this.cacheName, 'Force saved to disk.'); + } + catch (error) { + logger('error', this.cacheName, `Failed to force save: ${getErrorMessage(error)}`); + } + } + clear() { + if (this.cache.size === 0) + return; + this.cache.clear(); + this.save(); + } + /** + * Cleans up internal timers and resources. + */ + destroy() { + if (this.cleanupInterval) { + clearInterval(this.cleanupInterval); + this.cleanupInterval = null; + } + if (this.saveTimeout) { + clearTimeout(this.saveTimeout); + this.saveTimeout = null; + } + } + _getValidEntry(key) { + const entry = this.cache.get(key); + if (!entry) + return null; + if (entry.expiresAt && Date.now() > entry.expiresAt) { + this.cache.delete(key); + this.save(); + return null; + } + if (this.maxEntries > 0) { + this.cache.delete(key); + this.cache.set(key, entry); + } + return entry; + } + _deriveFastKey(password) { + return crypto + .createHash('sha256') + .update(`${this.salt}:${password}`) + .digest(); + } + _getLegacyKey() { + if (!this.legacyKey) { + this.legacyKey = crypto.scryptSync(this.passwordHashKey, this.salt, 32); + } + return this.legacyKey; + } + _purgeExpired() { + const now = Date.now(); + let expiredCount = 0; + for (const [key, entry] of this.cache.entries()) { + if (entry.expiresAt && now > entry.expiresAt) { + this.cache.delete(key); + expiredCount++; + } + } + return expiredCount; + } + _enforceMaxEntries() { + if (this.maxEntries <= 0 || this.cache.size <= this.maxEntries) + return 0; + let removed = 0; + while (this.cache.size > this.maxEntries) { + const oldestKey = this.cache.keys().next().value; + if (!oldestKey) + break; + this.cache.delete(oldestKey); + removed++; + } + return removed; + } + _decodePayload(data, key) { + const iv = data.subarray(0, 16); + const tag = data.subarray(16, 32); + const encrypted = data.subarray(32); + const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv); + decipher.setAuthTag(tag); + const decrypted = Buffer.concat([ + decipher.update(encrypted), + decipher.final() + ]).toString('utf8'); + const parsed = JSON.parse(decrypted); + return this._normalizePayload(parsed); + } + _normalizePayload(raw) { + const now = Date.now(); + if (isRecord(raw) && !('version' in raw) && !('entries' in raw)) { + return { + version: this.version, + savedAt: now, + entries: this._normalizeEntries(raw, now) + }; + } + if (isRecord(raw)) { + const payloadCandidate = raw; + const entriesValue = payloadCandidate.entries; + if (isRecord(entriesValue)) { + return { + version: payloadCandidate.version ?? this.version, + savedAt: typeof payloadCandidate.savedAt === 'number' + ? payloadCandidate.savedAt + : now, + entries: this._normalizeEntries(entriesValue, now) + }; + } + } + return { + version: this.version, + savedAt: now, + entries: {} + }; + } + _normalizeEntries(rawEntries, fallbackTime) { + const entries = {}; + for (const [key, value] of Object.entries(rawEntries)) { + entries[key] = this._normalizeEntry(value, fallbackTime); + } + return entries; + } + _normalizeEntry(rawValue, fallbackTime) { + if (isRecord(rawValue)) { + const entryCandidate = rawValue; + const value = Object.hasOwn(entryCandidate, 'value') + ? entryCandidate.value + : rawValue; + const createdAt = typeof entryCandidate.createdAt === 'number' + ? entryCandidate.createdAt + : fallbackTime; + const updatedAt = typeof entryCandidate.updatedAt === 'number' + ? entryCandidate.updatedAt + : createdAt; + const expiresAt = typeof entryCandidate.expiresAt === 'number' && + entryCandidate.expiresAt > 0 + ? entryCandidate.expiresAt + : null; + return { + value: value, + createdAt, + updatedAt, + expiresAt + }; + } + return { + value: rawValue, + createdAt: fallbackTime, + updatedAt: fallbackTime, + expiresAt: null + }; + } + _buildPayload() { + return { + version: this.version, + savedAt: Date.now(), + entries: Object.fromEntries(this.cache) + }; + } + async _flushSaveQueue() { + if (this.savePromise) { + this.saveQueued = true; + await this.savePromise; + if (this.saveQueued) { + this.saveQueued = false; + await this._flushSaveQueue(); + } + return; + } + const payload = this._buildPayload(); + this.savePromise = this._writeToDisk(payload); + try { + await this.savePromise; + } + finally { + this.savePromise = null; + } + if (this.saveQueued) { + this.saveQueued = false; + await this._flushSaveQueue(); + } + } + async _writeToDisk(payload) { + const plainText = JSON.stringify(payload); + const iv = crypto.randomBytes(16); + const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv); + const encrypted = Buffer.concat([ + cipher.update(plainText, 'utf8'), + cipher.final() + ]); + const tag = cipher.getAuthTag(); + const outBuffer = Buffer.concat([iv, tag, encrypted]); + await fs.mkdir('./.cache', { recursive: true }); + try { + await fs.writeFile(this.tempFilePath, outBuffer); + await fs.rename(this.tempFilePath, this.filePath); + } + catch (error) { + logger('debug', this.cacheName, `Atomic save failed, falling back to direct write: ${getErrorMessage(error)}`); + await fs.writeFile(this.filePath, outBuffer); + try { + await fs.unlink(this.tempFilePath); + } + catch (cleanupError) { + logger('debug', this.cacheName, `Failed to remove temp cache file: ${getErrorMessage(cleanupError)}`); + } + } + this.lastSavedAt = payload.savedAt; + } +} diff --git a/dist/src/managers/configValidationManager.js b/dist/src/managers/configValidationManager.js index 01a80231..7639c692 100644 --- a/dist/src/managers/configValidationManager.js +++ b/dist/src/managers/configValidationManager.js @@ -1,929 +1,250 @@ -const KNOWN_PLACEHOLDERS = new Set([ - 'your_token_here', - 'changeme', - 'change_me', - 'your-token-here', - 'insert_token_here', - 'placeholder', - 'PLACEHOLDER', - 'YOUR_TOKEN', - 'YOUR_API_KEY', - 'YOUR_CLIENT_ID', - 'YOUR_CLIENT_SECRET' -]); -const VALID_AUDIO_QUALITIES = new Set(['high', 'medium', 'low', 'lowest']); -const VALID_RESAMPLING_QUALITIES = new Set([ - 'best', - 'medium', - 'fastest', - 'zero', - 'linear' -]); -const VALID_FADING_CURVES = new Set([ - 'linear', - 'exponential', - 'sinusoidal', - 'start', - 'wash', - 'stop', - 'random', - 'baby' -]); -const VALID_FADING_TYPES = new Set(['volume', 'tape', 'both', 'scratch']); -const VALID_VOICE_FORMATS = new Set(['opus', 'pcm_s16le']); -const VALID_ROUTE_STRATEGIES = new Set([ - 'RotateOnBan', - 'RoundRobin', - 'LoadBalance' -]); -const VALID_METRICS_AUTH_TYPES = new Set(['Bearer', 'Basic']); +import { logger } from '../utils.js'; +import { validator } from '../validators.js'; +/** + * Validates the NodeLink configuration object using a schema-based approach. + * Supports the new hierarchical configuration structure. + */ export default class ConfigValidationManager { - options; - warnings = []; - constructor(options) { - this.options = options; - } + config; + constructor(config) { + this.config = config; + } + /** + * Performs a full validation of the configuration. + * @throws Error if validation fails. + */ validate() { - this.warnings = []; - const allRules = [ - ...this.validateServer(), - ...this.validateCluster(), - ...this.validateAudio(), - ...this.validatePlayback(), - ...this.validateSources(), - ...this.validateSearch(), - ...this.validateRoutePlanner(), - ...this.validateRateLimit(), - ...this.validateDosProtection(), - ...this.validateLogging(), - ...this.validateConnection(), - ...this.validateVoiceReceive(), - ...this.validateMix(), - ...this.validateMetrics(), - ...this.validateFilters() - ]; - const errors = []; - for (const rule of allRules) { - if (!rule.validate(rule.value)) { - errors.push(`Configuration error:\n` + - `- Property: ${rule.path}\n` + - `- Received: ${JSON.stringify(rule.value)}\n` + - `- Expected: ${rule.expected}`); - } - } - if (this.warnings.length > 0) { - const warningLines = this.warnings - .map((w) => ` ⚠ ${w.path}: ${w.message}`) - .join('\n'); - console.warn(`\n[NodeLink] Configuration warnings:\n${warningLines}\n`); - } - if (errors.length > 0) { - throw new Error(`Configuration errors:\n\n${errors.join('\n\n')}`); - } - } - validateServer() { - const server = this.options.server; - return [ - this.nonEmptyStringRule('server.host', server?.host), - this.intRangeRule('server.port', server?.port, 1, 65535), - this.nonEmptyStringRule('server.password', server?.password), - this.booleanRule('server.useBunServer', server?.useBunServer) - ]; - } - validateCluster() { - const cluster = this.options.cluster; - if (!cluster) - return []; - const workers = cluster.workers; - const rules = [ - this.booleanRule('cluster.enabled', cluster.enabled) - ]; - if (typeof cluster.enabled !== 'boolean') - return rules; - if (cluster.enabled === false) - return rules; - rules.push(this.nonNegativeIntRule('cluster.workers', workers), this.nonNegativeIntRule('cluster.minWorkers', cluster.minWorkers), { - path: 'cluster.minWorkers', - expected: workers === 0 - ? 'integer (auto-scaled workers, unknown value allowed)' - : `integer <= cluster.workers (${workers})`, - value: cluster.minWorkers, - validate: (v) => typeof v === 'number' && - Number.isInteger(v) && - Number.isInteger(workers) && - (workers === 0 || v <= workers) - }, this.positiveIntRule('cluster.commandTimeout', cluster.commandTimeout), this.positiveIntRule('cluster.fastCommandTimeout', cluster.fastCommandTimeout), this.nonNegativeIntRule('cluster.maxRetries', cluster.maxRetries)); - if (cluster.hibernation) { - rules.push(this.booleanRule('cluster.hibernation.enabled', cluster.hibernation.enabled), this.positiveIntRule('cluster.hibernation.timeoutMs', cluster.hibernation.timeoutMs)); - } - const ssw = cluster.specializedSourceWorker; - if (ssw) { - rules.push(this.booleanRule('cluster.specializedSourceWorker.enabled', ssw.enabled), this.positiveIntRule('cluster.specializedSourceWorker.count', ssw.count), this.positiveIntRule('cluster.specializedSourceWorker.microWorkers', ssw.microWorkers), this.positiveIntRule('cluster.specializedSourceWorker.tasksPerWorker', ssw.tasksPerWorker), this.booleanRule('cluster.specializedSourceWorker.silentLogs', ssw.silentLogs)); - } - const runtime = cluster.runtime; - if (runtime) { - rules.push(this.nonNegativeIntRule('cluster.runtime.workerMaxOldSpaceMb', runtime.workerMaxOldSpaceMb), this.nonNegativeIntRule('cluster.runtime.sourceWorkerMaxOldSpaceMb', runtime.sourceWorkerMaxOldSpaceMb), this.booleanRule('cluster.runtime.workerExposeGc', runtime.workerExposeGc), this.booleanRule('cluster.runtime.sourceWorkerExposeGc', runtime.sourceWorkerExposeGc), this.stringArrayRule('cluster.runtime.workerExecArgv', runtime.workerExecArgv), this.stringArrayRule('cluster.runtime.sourceWorkerExecArgv', runtime.sourceWorkerExecArgv)); - } - const scaling = cluster.scaling; - if (scaling) { - rules.push(this.positiveIntRule('cluster.scaling.maxPlayersPerWorker', scaling.maxPlayersPerWorker), this.positiveIntRule('cluster.scaling.checkIntervalMs', scaling.checkIntervalMs), this.positiveIntRule('cluster.scaling.idleWorkerTimeoutMs', scaling.idleWorkerTimeoutMs), this.positiveIntRule('cluster.scaling.queueLengthScaleUpFactor', scaling.queueLengthScaleUpFactor), this.positiveIntRule('cluster.scaling.lagPenaltyLimit', scaling.lagPenaltyLimit), { - path: 'cluster.scaling.scaleUpThreshold', - expected: 'number between 0 and 1 (exclusive)', - value: scaling.scaleUpThreshold, - validate: (v) => typeof v === 'number' && v > 0 && v < 1 - }, { - path: 'cluster.scaling.cpuPenaltyLimit', - expected: 'number between 0 and 1 (exclusive)', - value: scaling.cpuPenaltyLimit, - validate: (v) => typeof v === 'number' && v > 0 && v < 1 - }, this.floatMustBeBelow('cluster.scaling.scaleDownThreshold', scaling.scaleDownThreshold, scaling.scaleUpThreshold, 'cluster.scaling.scaleUpThreshold'), { - path: 'cluster.scaling.targetUtilization', - expected: `number between scaleDownThreshold (${scaling.scaleDownThreshold}) and scaleUpThreshold (${scaling.scaleUpThreshold})`, - value: scaling.targetUtilization, - validate: (v) => typeof scaling.scaleDownThreshold === 'number' && - typeof scaling.scaleUpThreshold === 'number' && - typeof v === 'number' && - v >= scaling.scaleDownThreshold && - v <= scaling.scaleUpThreshold - }); - } - const endpoint = cluster.endpoint; - if (endpoint) { - rules.push(this.booleanRule('cluster.endpoint.patchEnabled', endpoint.patchEnabled), this.booleanRule('cluster.endpoint.allowExternalPatch', endpoint.allowExternalPatch), this.nonEmptyStringRule('cluster.endpoint.code', endpoint.code)); - } - return rules; - } - validateAudio() { - const audio = this.options.audio; - const rules = [ - this.booleanRule('audio.loudnessNormalizer', audio?.loudnessNormalizer), - this.nonNegativeIntRule('audio.lookaheadMs', audio?.lookaheadMs), - { - path: 'audio.gateThresholdLUFS', - expected: 'number <= 0', - value: audio?.gateThresholdLUFS, - validate: (v) => typeof v === 'number' && v <= 0 - }, - this.enumRule('audio.quality', audio?.quality, VALID_AUDIO_QUALITIES), - this.enumRule('audio.resamplingQuality', audio?.resamplingQuality, VALID_RESAMPLING_QUALITIES) - ]; - const fading = audio?.fading; - if (fading) { - rules.push(this.booleanRule('audio.fading.enabled', fading.enabled)); - const fadingEvents = [ - 'trackStart', - 'trackEnd', - 'trackStop', - 'seek', - 'pause', - 'resume' - ]; - for (const event of fadingEvents) { - const ev = fading[event]; - if (!ev) - continue; - rules.push(this.nonNegativeIntRule(`audio.fading.${event}.duration`, ev.duration), this.enumRule(`audio.fading.${event}.curve`, ev.curve, VALID_FADING_CURVES), this.enumRule(`audio.fading.${event}.type`, ev.type, VALID_FADING_TYPES)); - } - const ducking = fading.ducking; - if (ducking) { - rules.push(this.booleanRule('audio.fading.ducking.enabled', ducking.enabled), this.nonNegativeIntRule('audio.fading.ducking.duration', ducking.duration), this.enumRule('audio.fading.ducking.curve', ducking.curve, VALID_FADING_CURVES), { - path: 'audio.fading.ducking.targetVolume', - expected: 'number between 0 and 1 (inclusive)', - value: ducking.targetVolume, - validate: (v) => typeof v === 'number' && v >= 0 && v <= 1 - }); - } - } - return rules; - } - validatePlayback() { - const trackStuck = this.options.trackStuckThresholdMs; - return [ - this.intRangeRule('playerUpdateInterval', this.options.playerUpdateInterval, 250, 60000), - this.positiveIntRule('statsUpdateInterval', this.options.statsUpdateInterval), - this.positiveIntRule('eventTimeoutMs', this.options.eventTimeoutMs), - this.booleanRule('enableHoloTracks', this.options.enableHoloTracks), - this.booleanRule('enableTrackStreamEndpoint', this.options.enableTrackStreamEndpoint), - this.booleanRule('enableLoadStreamEndpoint', this.options.enableLoadStreamEndpoint), - this.booleanRule('resolveExternalLinks', this.options.resolveExternalLinks), - this.booleanRule('fetchChannelInfo', this.options.fetchChannelInfo), - { - path: 'trackStuckThresholdMs', - expected: 'integer >= 1000 (milliseconds)', - value: trackStuck, - validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 1000 - }, - this.intMustExceed('zombieThresholdMs', this.options.zombieThresholdMs, trackStuck, 'trackStuckThresholdMs') - ]; - } - validateSources() { - const sources = this.options.sources; - if (!sources) - return []; - const rules = []; - const allSources = [ - 'youtube', - 'soundcloud', - 'spotify', - 'tidal', - 'applemusic', - 'audius', - 'jiosaavn', - 'eternalbox', - 'pipertts', - 'pandora', - 'yandexmusic', - 'monochrome', - 'gaana', - 'flowery', - 'lazypytts', - 'qobuz', - 'iheartradio', - 'vkmusic', - 'amazonmusic', - 'bluesky', - 'anghami', - 'rss', - 'songlink', - 'mixcloud', - 'audiomack', - 'deezer', - 'bandcamp', - 'local', - 'http', - 'vimeo', - 'telegram', - 'shazam', - 'bilibili', - 'genius', - 'pinterest', - 'google-tts', - 'instagram', - 'kwai', - 'twitch', - 'nicovideo', - 'reddit', - 'tumblr', - 'twitter', - 'lastfm', - 'letrasmus' - ]; - for (const name of allSources) { - const sourceConfig = sources[name]; - if (sourceConfig !== undefined) { - rules.push(this.booleanRule(`sources.${name}.enabled`, sourceConfig.enabled)); - } - } - rules.push(...this.validateSourceSpotify(sources.spotify), ...this.validateSourceAppleMusic(sources.applemusic), ...this.validateSourceTidal(sources.tidal), ...this.validateSourceAudius(sources.audius), ...this.validateSourceJiosaavn(sources.jiosaavn), ...this.validateSourceEternalbox(sources.eternalbox), ...this.validateSourceYoutube(sources.youtube), ...this.validateSourcePipertts(sources.pipertts), ...this.validateSourcePandora(sources.pandora), ...this.validateSourceQobuz(sources.qobuz), ...this.validateSourceLastfm(sources.lastfm), ...this.validateSourceBilibili(sources.bilibili), ...this.validateSourceYandexMusic(sources.yandexmusic), ...this.validateSourceGaana(sources.gaana), ...this.validateSourceFlowery(sources.flowery), ...this.validateSourceLazypytts(sources.lazypytts), ...this.validateSourceMonochrome(sources.monochrome)); - return rules; - } - validateSourceSpotify(spotify) { - if (typeof spotify !== 'object' || - spotify === null || - !spotify.enabled) - return []; - const s = spotify; - const rules = [ - this.nonNegativeIntRule('sources.spotify.playlistLoadLimit', s.playlistLoadLimit), - this.nonNegativeIntRule('sources.spotify.albumLoadLimit', s.albumLoadLimit), - this.positiveIntRule('sources.spotify.playlistPageLoadConcurrency', s.playlistPageLoadConcurrency), - this.positiveIntRule('sources.spotify.albumPageLoadConcurrency', s.albumPageLoadConcurrency), - this.booleanRule('sources.spotify.allowLocalFiles', s.allowLocalFiles), - { - path: 'sources.spotify.clientId', - expected: 'non-empty string when sources.spotify.clientSecret is set', - value: s.clientId, - validate: (v) => !s.clientSecret || (typeof v === 'string' && v.trim().length > 0) - }, - { - path: 'sources.spotify.clientSecret', - expected: 'non-empty string when sources.spotify.clientId is set', - value: s.clientSecret, - validate: (v) => !s.clientId || (typeof v === 'string' && v.trim().length > 0) + const schema = { + server: { + type: 'object', + props: { + host: { type: 'string', default: '0.0.0.0' }, + port: { + type: 'number', + integer: true, + min: 1, + max: 65535, + default: 3000 + }, + engine: { + type: 'string', + enum: ['default', 'bun'], + default: 'default', + optional: true + }, + password: { type: 'string', min: 1, optional: true }, + useBunServer: { type: 'boolean', default: false, optional: true } + } }, - this.placeholderWarningRule('sources.spotify.clientId', s.clientId), - this.placeholderWarningRule('sources.spotify.clientSecret', s.clientSecret) - ]; - if (s.externalAuthUrl) { - rules.push(this.urlRule('sources.spotify.externalAuthUrl', s.externalAuthUrl)); - } - return rules; - } - validateSourceAppleMusic(applemusic) { - if (typeof applemusic !== 'object' || - applemusic === null || - !applemusic.enabled) - return []; - const a = applemusic; - return [ - this.nonNegativeIntRule('sources.applemusic.playlistLoadLimit', a.playlistLoadLimit), - this.nonNegativeIntRule('sources.applemusic.albumLoadLimit', a.albumLoadLimit), - this.positiveIntRule('sources.applemusic.playlistPageLoadConcurrency', a.playlistPageLoadConcurrency), - this.positiveIntRule('sources.applemusic.albumPageLoadConcurrency', a.albumPageLoadConcurrency), - this.placeholderWarningRule('sources.applemusic.mediaApiToken', a.mediaApiToken, ['token_here']) - ]; - } - validateSourceTidal(tidal) { - if (typeof tidal !== 'object' || - tidal === null || - !tidal.enabled) - return []; - const t = tidal; - const rules = [ - this.nonNegativeIntRule('sources.tidal.playlistLoadLimit', t.playlistLoadLimit), - this.positiveIntRule('sources.tidal.playlistPageLoadConcurrency', t.playlistPageLoadConcurrency) - ]; - if (t.token !== undefined) { - rules.push({ - path: 'sources.tidal.token', - expected: 'string (non-whitespace if provided)', - value: t.token, - validate: (v) => typeof v === 'string' && (v === '' || v.trim().length > 0) - }, this.placeholderWarningRule('sources.tidal.token', t.token, [ - 'token_here' - ])); - } - return rules; - } - validateSourceAudius(audius) { - if (typeof audius !== 'object' || - audius === null || - !audius.enabled) - return []; - const au = audius; - return [ - { - path: 'sources.audius.appName', - expected: 'string', - value: au.appName, - validate: (v) => v === undefined || typeof v === 'string' + cluster: { + type: 'object', + props: { + enabled: { type: 'boolean', default: true }, + workers: { type: 'number', integer: true, min: 0 }, + minWorkers: { type: 'number', integer: true, min: 0, default: 1 }, + timeouts: { + type: 'object', + optional: true, + props: { + heavyMs: { + type: 'number', + integer: true, + min: 100, + default: 6000 + }, + fastMs: { type: 'number', integer: true, min: 100, default: 4000 } + } + } + } }, - { - path: 'sources.audius.apiKey', - expected: 'string', - value: au.apiKey, - validate: (v) => v === undefined || typeof v === 'string' + logging: { + type: 'object', + props: { + level: { type: 'string', default: 'info' }, + file: { + type: 'object', + props: { + enabled: { type: 'boolean', default: false }, + path: { type: 'string', default: 'logs' } + } + } + } }, - { - path: 'sources.audius.apiSecret', - expected: 'string', - value: au.apiSecret, - validate: (v) => v === undefined || typeof v === 'string' + connection: { + type: 'object', + props: { + interval: { type: 'number', integer: true, min: 1000 }, + timeout: { type: 'number', integer: true, min: 1000 } + } }, - this.nonNegativeIntRule('sources.audius.playlistLoadLimit', au.playlistLoadLimit), - this.nonNegativeIntRule('sources.audius.albumLoadLimit', au.albumLoadLimit), - this.placeholderWarningRule('sources.audius.apiKey', au.apiKey), - this.placeholderWarningRule('sources.audius.apiSecret', au.apiSecret) - ]; - } - validateSourceJiosaavn(jiosaavn) { - if (typeof jiosaavn !== 'object' || - jiosaavn === null || - !jiosaavn.enabled) - return []; - const j = jiosaavn; - return [ - this.nonNegativeIntRule('sources.jiosaavn.playlistLoadLimit', j.playlistLoadLimit), - this.nonNegativeIntRule('sources.jiosaavn.artistLoadLimit', j.artistLoadLimit) - ]; - } - validateSourceEternalbox(eternalbox) { - if (typeof eternalbox !== 'object' || - eternalbox === null || - !eternalbox.enabled) - return []; - const e = eternalbox; - return [ - this.urlRule('sources.eternalbox.baseUrl', e.baseUrl), - this.positiveIntRule('sources.eternalbox.searchResults', e.searchResults), - this.positiveIntRule('sources.eternalbox.maxBranches', e.maxBranches), - this.nonNegativeIntRule('sources.eternalbox.cacheMaxBytes', e.cacheMaxBytes), - this.booleanRule('sources.eternalbox.enrichSpotify', e.enrichSpotify), - this.booleanRule('sources.eternalbox.includeAnalysis', e.includeAnalysis), - this.booleanRule('sources.eternalbox.eternalStream', e.eternalStream), - this.booleanRule('sources.eternalbox.infiniteStream', e.infiniteStream), - this.nonNegativeIntRule('sources.eternalbox.maxReconnects', e.maxReconnects), - this.positiveIntRule('sources.eternalbox.reconnectDelayMs', e.reconnectDelayMs), - { - path: 'sources.eternalbox.minRandomBranchChance', - expected: 'number between 0 and 1 (inclusive)', - value: e.minRandomBranchChance, - validate: (v) => typeof v === 'number' && v >= 0 && v <= 1 + rateLimit: { + type: 'object', + props: { + enabled: { type: 'boolean', default: true }, + global: { type: 'object' }, + perIp: { type: 'object' } + } }, - { - path: 'sources.eternalbox.maxRandomBranchChance', - expected: 'number between 0 and 1 (inclusive)', - value: e.maxRandomBranchChance, - validate: (v) => typeof v === 'number' && v >= 0 && v <= 1 + dosProtection: { + type: 'object', + props: { + enabled: { type: 'boolean', default: true }, + thresholds: { type: 'object' }, + mitigation: { type: 'object' } + } }, - this.floatMustNotExceed('sources.eternalbox.minRandomBranchChance', e.minRandomBranchChance, e.maxRandomBranchChance, 'sources.eternalbox.maxRandomBranchChance') - ]; - } - validateSourceYoutube(youtube) { - if (typeof youtube !== 'object' || youtube === null) - return []; - const y = youtube; - if (!y.enabled || !y.cipher) - return []; - const cipher = y.cipher; - if (cipher.url === undefined) - return []; - return [this.urlRule('sources.youtube.cipher.url', cipher.url)]; - } - validateSourcePipertts(pipertts) { - if (typeof pipertts !== 'object' || - pipertts === null || - !pipertts.enabled) - return []; - const p = pipertts; - return [this.urlRule('sources.pipertts.url', p.url)]; - } - validateSourcePandora(pandora) { - if (typeof pandora !== 'object' || pandora === null) - return []; - const pa = pandora; - if (!pa.enabled || !pa.remoteTokenUrl) - return []; - return [this.urlRule('sources.pandora.remoteTokenUrl', pa.remoteTokenUrl)]; - } - validateSourceQobuz(qobuz) { - if (typeof qobuz !== 'object' || - qobuz === null || - !qobuz.enabled) - return []; - const q = qobuz; - return [this.placeholderWarningRule('sources.qobuz.userToken', q.userToken)]; - } - validateSourceLastfm(lastfm) { - if (typeof lastfm !== 'object' || - lastfm === null || - !lastfm.enabled) - return []; - const l = lastfm; - return [this.placeholderWarningRule('sources.lastfm.apiKey', l.apiKey)]; - } - validateSourceBilibili(bilibili) { - if (typeof bilibili !== 'object' || - bilibili === null || - !bilibili.enabled) - return []; - const b = bilibili; - return [ - this.placeholderWarningRule('sources.bilibili.sessdata', b.sessdata) - ]; - } - validateSourceYandexMusic(yandexmusic) { - if (typeof yandexmusic !== 'object' || - yandexmusic === null || - !yandexmusic.enabled) - return []; - const ym = yandexmusic; - return [ - this.nonNegativeIntRule('sources.yandexmusic.artistLoadLimit', ym.artistLoadLimit), - this.nonNegativeIntRule('sources.yandexmusic.albumLoadLimit', ym.albumLoadLimit), - this.nonNegativeIntRule('sources.yandexmusic.playlistLoadLimit', ym.playlistLoadLimit), - this.placeholderWarningRule('sources.yandexmusic.accessToken', ym.accessToken) - ]; - } - validateSourceGaana(gaana) { - if (typeof gaana !== 'object' || - gaana === null || - !gaana.enabled) - return []; - const g = gaana; - return [ - this.nonNegativeIntRule('sources.gaana.playlistLoadLimit', g.playlistLoadLimit), - this.nonNegativeIntRule('sources.gaana.albumLoadLimit', g.albumLoadLimit), - this.nonNegativeIntRule('sources.gaana.artistLoadLimit', g.artistLoadLimit) - ]; - } - validateSourceFlowery(flowery) { - if (typeof flowery !== 'object' || - flowery === null || - !flowery.enabled) - return []; - const fl = flowery; - return [ - this.positiveNumberRule('sources.flowery.speed', fl.speed), - this.nonNegativeIntRule('sources.flowery.silence', fl.silence), - this.booleanRule('sources.flowery.translate', fl.translate), - this.booleanRule('sources.flowery.enforceConfig', fl.enforceConfig) - ]; - } - validateSourceLazypytts(lazypytts) { - if (typeof lazypytts !== 'object' || - lazypytts === null || - !lazypytts.enabled) - return []; - const lp = lazypytts; - return [ - this.positiveIntRule('sources.lazypytts.maxTextLength', lp.maxTextLength), - this.booleanRule('sources.lazypytts.enforceConfig', lp.enforceConfig) - ]; - } - validateSourceMonochrome(monochrome) { - if (typeof monochrome !== 'object' || - monochrome === null || - !monochrome.enabled) - return []; - const m = monochrome; - return [ - this.stringArrayRule('sources.monochrome.instances', m.instances), - this.stringArrayRule('sources.monochrome.streamingInstances', m.streamingInstances), - { - path: 'sources.monochrome.quality', - expected: 'one of [HI_RES_LOSSLESS, LOSSLESS, HIGH, LOW]', - value: m.quality, - validate: (v) => ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'].includes(v) - } - ]; - } - validateSearch() { - const rules = [ - this.intRangeRule('maxSearchResults', this.options.maxSearchResults, 1, 100), - this.intRangeRule('maxAlbumPlaylistLength', this.options.maxAlbumPlaylistLength, 1, 500), - { - path: 'defaultSearchSource', - expected: 'string or non-empty string[] of enabled source names in config.sources', - value: this.options.defaultSearchSource, - validate: (v) => { - const sources = this.options.sources; - if (!sources) - return false; - const sourcesRecord = sources; - if (typeof v === 'string') - return (sourcesRecord[v]?.enabled === true); - if (Array.isArray(v)) { - if (v.length === 0) - return false; - return v.every((name) => typeof name === 'string' && - sourcesRecord[name]?.enabled === - true); + trustProxy: { type: 'boolean', default: false }, + network: { + type: 'object', + props: { + proxy: { + type: 'object', + props: { + enabled: { type: 'boolean', default: false }, + strategy: { + type: 'string', + enum: [ + 'RoundRobin', + 'LeastConnections', + 'LowestLatency', + 'WeightedHealth' + ] + } + } + }, + connection: { + type: 'object', + props: { + interval: { type: 'number', integer: true, min: 1000 }, + timeout: { type: 'number', integer: true, min: 1000 } + } } - return false; - } - } - ]; - const unified = this.options.unifiedSearchSources; - if (unified !== undefined) { - rules.push({ - path: 'unifiedSearchSources', - expected: 'non-empty string[] of enabled source names in config.sources', - value: unified, - validate: (v) => { - const sources = this.options.sources; - if (!sources || !Array.isArray(v) || v.length === 0) - return false; - const sourcesRecord = sources; - return v.every((name) => typeof name === 'string' && - sourcesRecord[name]?.enabled === true); - } - }); - } - return rules; - } - validateRoutePlanner() { - const routePlanner = this.options.routePlanner; - if (!routePlanner) - return []; - const rules = [ - this.enumRule('routePlanner.strategy', routePlanner.strategy, VALID_ROUTE_STRATEGIES) - ]; - if (routePlanner.bannedIpCooldown !== undefined) { - rules.push(this.positiveIntRule('routePlanner.bannedIpCooldown', routePlanner.bannedIpCooldown)); - } - return rules; - } - validateRateLimit() { - const rateLimit = this.options.rateLimit; - if (!rateLimit || rateLimit.enabled === false) - return []; - const rules = [ - this.booleanRule('rateLimit.enabled', rateLimit.enabled) - ]; - const sections = ['global', 'perIp', 'perUserId', 'perGuildId']; - let prevSection = null; - let prevCfg = null; - for (const section of sections) { - const cfg = rateLimit[section]; - if (!cfg) { - continue; - } - rules.push(this.positiveIntRule(`rateLimit.${section}.maxRequests`, cfg.maxRequests), this.positiveIntRule(`rateLimit.${section}.timeWindowMs`, cfg.timeWindowMs)); - if (prevSection !== null && prevCfg !== null) { - const capturedPrevSection = prevSection; - const capturedPrevCfg = prevCfg; - rules.push(this.intMustNotExceed(`rateLimit.${section}.maxRequests`, cfg.maxRequests, capturedPrevCfg.maxRequests, `rateLimit.${capturedPrevSection}.maxRequests`), this.intMustNotExceed(`rateLimit.${section}.timeWindowMs`, cfg.timeWindowMs, capturedPrevCfg.timeWindowMs, `rateLimit.${capturedPrevSection}.timeWindowMs`)); - } - prevSection = section; - prevCfg = cfg; - } - return rules; - } - validateDosProtection() { - const dos = this.options.dosProtection; - if (!dos) - return []; - const rules = [ - this.booleanRule('dosProtection.enabled', dos.enabled) - ]; - if (dos.thresholds) { - rules.push(this.positiveIntRule('dosProtection.thresholds.burstRequests', dos.thresholds.burstRequests), this.positiveIntRule('dosProtection.thresholds.timeWindowMs', dos.thresholds.timeWindowMs)); - } - if (dos.mitigation) { - rules.push(this.nonNegativeIntRule('dosProtection.mitigation.delayMs', dos.mitigation.delayMs), this.positiveIntRule('dosProtection.mitigation.blockDurationMs', dos.mitigation.blockDurationMs)); - } - return rules; - } - validateLogging() { - const logging = this.options.logging; - if (!logging) - return []; - const rules = []; - if (logging.file) { - rules.push(this.booleanRule('logging.file.enabled', logging.file.enabled), this.positiveIntRule('logging.file.ttlDays', logging.file.ttlDays)); - if (logging.file.enabled) { - rules.push(this.nonEmptyStringRule('logging.file.path', logging.file.path)); - } - } - if (logging.debug) { - const debugFields = [ - 'all', - 'request', - 'session', - 'player', - 'filters', - 'sources', - 'lyrics', - 'youtube', - 'youtube-cipher', - 'sabr', - 'potoken' - ]; - for (const field of debugFields) { - if (logging.debug[field] !== undefined) { - rules.push(this.booleanRule(`logging.debug.${field}`, logging.debug[field])); } - } - } - return rules; - } - validateConnection() { - const connection = this.options.connection; - if (!connection) - return []; - const rules = [ - this.booleanRule('connection.logAllChecks', connection.logAllChecks), - this.positiveIntRule('connection.interval', connection.interval), - this.positiveIntRule('connection.timeout', connection.timeout) - ]; - if (connection.thresholds) { - rules.push(this.positiveNumberRule('connection.thresholds.bad', connection.thresholds.bad), this.positiveNumberRule('connection.thresholds.average', connection.thresholds.average), this.floatMustBeBelow('connection.thresholds.bad', connection.thresholds.bad, connection.thresholds.average, 'connection.thresholds.average')); - } - return rules; - } - validateVoiceReceive() { - const voiceReceive = this.options.voiceReceive; - if (!voiceReceive) - return []; - return [ - this.booleanRule('voiceReceive.enabled', voiceReceive.enabled), - this.enumRule('voiceReceive.format', voiceReceive.format, VALID_VOICE_FORMATS) - ]; - } - validateMix() { - const mix = this.options.mix; - if (!mix) - return []; - return [ - this.booleanRule('mix.enabled', mix.enabled), - this.positiveIntRule('mix.maxLayersMix', mix.maxLayersMix), - this.booleanRule('mix.autoCleanup', mix.autoCleanup), - { - path: 'mix.defaultVolume', - expected: 'number between 0 and 1 (inclusive)', - value: mix.defaultVolume, - validate: (v) => typeof v === 'number' && v >= 0 && v <= 1 - } - ]; - } - validateMetrics() { - const metrics = this.options.metrics; - if (!metrics) - return []; - const rules = [ - this.booleanRule('metrics.enabled', metrics.enabled) - ]; - if (metrics.authorization) { - rules.push(this.enumRule('metrics.authorization.type', metrics.authorization.type, VALID_METRICS_AUTH_TYPES)); - } - return rules; - } - validateFilters() { - const filters = this.options.filters; - if (filters === undefined) - return []; - if (filters === null || typeof filters !== 'object') { - return [ - { - path: 'filters', - expected: 'object with an enabled key', - value: filters, - validate: () => false + }, + search: { + type: 'object', + props: { + maxResults: { + type: 'number', + integer: true, + min: 1, + max: 100, + default: 10 + }, + defaultSource: { + type: 'multi', + rules: [{ type: 'array', items: 'string' }, { type: 'string' }] + }, + unifiedSources: { type: 'array', items: 'string', optional: true }, + resolveExternalLinks: { type: 'boolean', default: false }, + fetchChannelInfo: { type: 'boolean', default: false } } - ]; - } - if (!('enabled' in filters)) { - return [ - { - path: 'filters.enabled', - expected: 'object of filter flags', - value: undefined, - validate: () => false + }, + playback: { + type: 'object', + props: { + maxPlaylistLength: { + type: 'number', + integer: true, + min: 0, + default: 100 + }, + playerUpdateInterval: { + type: 'number', + integer: true, + min: 100, + default: 2000, + optional: true + }, + statsUpdateInterval: { + type: 'number', + integer: true, + min: 100, + default: 30000, + optional: true + }, + trackStuckThresholdMs: { + type: 'number', + integer: true, + min: 100, + default: 10000, + optional: true + }, + eventTimeoutMs: { + type: 'number', + integer: true, + min: 100, + default: 3000, + optional: true + }, + zombieThresholdMs: { + type: 'number', + integer: true, + min: 100, + default: 300000, + optional: true + }, + sponsorblock: { + type: 'object', + optional: true, + props: { + enabled: { type: 'boolean', default: false }, + api: { type: 'string', optional: true }, + categories: { type: 'array', items: 'string', optional: true }, + actionTypes: { type: 'array', items: 'string', optional: true } + } + }, + filters: { type: 'object', optional: true }, + audio: { + type: 'object', + optional: true, + props: { + quality: { + type: 'string', + enum: ['high', 'medium', 'low', 'lowest'] + }, + encryption: { type: 'string', optional: true }, + resamplingQuality: { type: 'string', optional: true }, + loudnessNormalizer: { type: 'boolean', optional: true }, + fading: { type: 'object', optional: true }, + crossfade: { type: 'object', optional: true } + } + }, + voiceReceive: { type: 'object', optional: true }, + mix: { type: 'object', optional: true } } - ]; - } - if (filters.enabled === null || typeof filters.enabled !== 'object') { - return [ - { - path: 'filters.enabled', - expected: 'object of filter flags', - value: filters.enabled, - validate: () => false + }, + api: { + type: 'object', + props: { + enableTrackStreamEndpoint: { type: 'boolean', default: false }, + enableLoadStreamEndpoint: { type: 'boolean', default: false }, + metrics: { type: 'object', optional: true } } - ]; - } - if (Object.keys(filters.enabled).length === 0) - return []; - const filterFields = [ - 'tremolo', - 'vibrato', - 'lowpass', - 'highpass', - 'rotation', - 'karaoke', - 'distortion', - 'channelMix', - 'equalizer', - 'chorus', - 'compressor', - 'echo', - 'phaser', - 'timescale' - ]; - return filterFields - .filter((f) => filters.enabled[f] !== undefined) - .map((f) => this.booleanRule(`filters.enabled.${f}`, filters.enabled[f])); - } - placeholderWarningRule(path, value, except = []) { - return { - path, - expected: 'non-placeholder value', - value, - validate: (v) => { - if (typeof v === 'string' && - KNOWN_PLACEHOLDERS.has(v) && - !except.includes(v)) { - this.warnings.push({ - path, - message: `Value "${v}" looks like an unfilled placeholder. The source may fail to authenticate at runtime.` - }); + }, + experimental: { + type: 'object', + props: { + enableHoloTracks: { type: 'boolean', default: false } } - return true; - } - }; - } - nonNegativeIntRule(path, value) { - return { - path, - expected: 'integer >= 0', - value, - validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= 0 - }; - } - positiveIntRule(path, value) { - return { - path, - expected: 'integer > 0', - value, - validate: (v) => typeof v === 'number' && Number.isInteger(v) && v > 0 - }; - } - intRangeRule(path, value, min, max) { - return { - path, - expected: `integer between ${min} and ${max}`, - value, - validate: (v) => typeof v === 'number' && Number.isInteger(v) && v >= min && v <= max - }; - } - booleanRule(path, value) { - return { - path, - expected: 'boolean', - value, - validate: (v) => typeof v === 'boolean' - }; - } - nonEmptyStringRule(path, value) { - return { - path, - expected: 'non-empty string', - value, - validate: (v) => typeof v === 'string' && v.trim().length > 0 - }; - } - enumRule(path, value, allowed) { - const label = [...allowed].join(', '); - return { - path, - expected: `one of [${label}]`, - value, - validate: (v) => allowed.has(v) + }, + sources: { type: 'object' }, + lyrics: { type: 'object' }, + meanings: { type: 'object' }, + metrics: { type: 'object' }, + mix: { type: 'object' }, + plugins: { type: 'array', items: 'object', optional: true }, + pluginConfig: { type: 'object', optional: true } }; - } - urlRule(path, value) { - return { - path, - expected: 'valid http or https URL (e.g. https://example.com)', - value, - validate: (v) => { - if (typeof v !== 'string' || v.trim().length === 0) - return false; - if (v !== v.trim()) { - this.warnings.push({ - path, - message: `URL value has leading or trailing whitespace. This may cause issues at runtime.` - }); - } - try { - const url = new URL(v.trim()); - return url.protocol === 'http:' || url.protocol === 'https:'; - } - catch { - return false; - } + const check = validator.compile(schema); + const result = check(this.config); + if (result !== true) { + const errors = Array.isArray(result) ? result : []; + for (const error of errors) { + logger('error', 'Config', `Validation error at ${error.field}: ${error.message}`); } - }; - } - intMustExceed(path, value, dependency, dependencyPath) { - return { - path, - expected: `integer > ${dependencyPath} (${dependency})`, - value, - validate: (v) => typeof v === 'number' && - Number.isInteger(v) && - typeof dependency === 'number' && - Number.isInteger(dependency) && - v > dependency - }; - } - intMustNotExceed(path, value, dependency, dependencyPath) { - return { - path, - expected: `integer <= ${dependencyPath} (${dependency})`, - value, - validate: (v) => typeof v === 'number' && - Number.isInteger(v) && - typeof dependency === 'number' && - Number.isInteger(dependency) && - v <= dependency - }; - } - floatMustNotExceed(path, value, dependency, dependencyPath) { - return { - path, - expected: `number <= ${dependencyPath} (${dependency})`, - value, - validate: (v) => typeof v === 'number' && - typeof dependency === 'number' && - v <= dependency - }; - } - floatMustBeBelow(path, value, dependency, dependencyPath) { - return { - path, - expected: `number < ${dependencyPath} (${dependency})`, - value, - validate: (v) => typeof v === 'number' && - typeof dependency === 'number' && - v < dependency - }; - } - positiveNumberRule(path, value) { - return { - path, - expected: 'number > 0', - value, - validate: (v) => typeof v === 'number' && v > 0 - }; - } - stringArrayRule(path, value) { - return { - path, - expected: 'array of strings', - value, - validate: (v) => Array.isArray(v) && v.every((item) => typeof item === 'string') - }; + throw new Error(`Configuration validation failed: ${errors.map((e) => e.message).join(', ')}`); + } + logger('info', 'Config', 'Configuration validated successfully.'); } } diff --git a/dist/src/managers/connectionManager.js b/dist/src/managers/connectionManager.js index 2c5f7547..f7e894f6 100644 --- a/dist/src/managers/connectionManager.js +++ b/dist/src/managers/connectionManager.js @@ -3,8 +3,8 @@ import dns from 'node:dns'; import os from 'node:os'; import { performance } from 'node:perf_hooks'; import { promisify } from 'node:util'; -import { GatewayEvents } from "../constants.js"; -import { http1makeRequest, logger } from "../utils.js"; +import { GatewayEvents } from '../constants.js'; +import { http1makeRequest, logger } from '../utils.js'; const execAsync = promisify(exec); const dnsLookup = promisify(dns.lookup); const DEFAULT_TEST_ENDPOINTS = [ @@ -54,7 +54,8 @@ export default class ConnectionManager { _lastPingMs; constructor(nodelink) { this.nodelink = nodelink; - this.config = nodelink.options.connection || {}; + this.config = + nodelink.options.network?.connection || nodelink.options.connection || {}; this.interval = null; this.status = 'unknown'; this.metrics = { timestamp: Date.now() }; @@ -63,15 +64,15 @@ export default class ConnectionManager { this._lastSpeedTestTime = 0; this._lastPingMs = undefined; } - /** - * Starts the periodic connection monitor. - */ start() { const checkInterval = Math.max(1, this.config.interval || 300000); if (checkInterval > 0) { logger('info', 'ConnectionManager', `Starting connection checks every ${checkInterval}ms.`); - this.checkConnection(); - this.interval = setInterval(() => this.checkConnection(), checkInterval); + // Delay the first check so it doesn't feel like part of the startup latency + setTimeout(() => { + this.checkConnection().catch(() => { }); + }, 5000); + this.interval = setInterval(() => this.checkConnection().catch(() => { }), checkInterval); } } /** @@ -83,6 +84,12 @@ export default class ConnectionManager { this.interval = null; } } + /** + * Stops the monitor and releases resources. + */ + destroy() { + this.stop(); + } /** * Runs a full connectivity check and updates metrics. */ diff --git a/dist/src/managers/credentialManager.js b/dist/src/managers/credentialManager.js index ff0e98a7..4e97be77 100644 --- a/dist/src/managers/credentialManager.js +++ b/dist/src/managers/credentialManager.js @@ -1,20 +1,10 @@ -import crypto from 'node:crypto'; -import fs from 'node:fs/promises'; -import { logger } from "../utils.js"; +import BaseCacheManager from './baseCacheManager.js'; const CREDENTIALS_SALT = 'nodelink-salt'; const CREDENTIALS_VERSION = 1; const DEFAULT_SAVE_DELAY_MS = 1000; const DEFAULT_CREDENTIALS_PATH = './.cache/credentials.bin'; const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 1000; -const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value); -const getErrorMessage = (error) => error instanceof Error ? error.message : String(error ?? 'Unknown error'); -const getErrorCode = (error) => { - if (!error || typeof error !== 'object' || !('code' in error)) { - return undefined; - } - const code = error.code; - return typeof code === 'string' ? code : undefined; -}; +const _isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value); /** * Encrypted credential store with TTL support and debounced persistence. * @remarks @@ -28,107 +18,24 @@ const getErrorCode = (error) => { * ``` * @public */ -export default class CredentialManager { +export default class CredentialManager extends BaseCacheManager { nodelink; - password; - key; - legacyKey; - filePath; - tempFilePath; - saveDelayMs; - credentials; - saveTimeout; - cleanupInterval; - savePromise; - saveQueued; - lastLoadedAt; - lastSavedAt; /** * Creates a new credential manager instance. * @param nodelink - NodeLink runtime used to derive the encryption key. */ constructor(nodelink) { + const password = CredentialManager._resolvePassword(nodelink.options); + super({ + name: 'Credentials', + passwordHashKey: password, + salt: CREDENTIALS_SALT, + filePath: DEFAULT_CREDENTIALS_PATH, + saveDelayMs: DEFAULT_SAVE_DELAY_MS, + cleanupIntervalMs: DEFAULT_CLEANUP_INTERVAL_MS, + version: CREDENTIALS_VERSION + }); this.nodelink = nodelink; - this.password = this._resolvePassword(nodelink.options); - this.key = this._deriveFastKey(this.password); - this.legacyKey = null; - this.filePath = DEFAULT_CREDENTIALS_PATH; - this.tempFilePath = `${DEFAULT_CREDENTIALS_PATH}.tmp`; - this.saveDelayMs = DEFAULT_SAVE_DELAY_MS; - this.credentials = new Map(); - this.saveTimeout = null; - this.cleanupInterval = setInterval(() => { - const expiredCount = this._purgeExpired(); - if (expiredCount > 0) - this.save(); - }, DEFAULT_CLEANUP_INTERVAL_MS); - this.cleanupInterval.unref?.(); - this.savePromise = null; - this.saveQueued = false; - this.lastLoadedAt = null; - this.lastSavedAt = null; - } - /** - * Loads and decrypts credential data from disk. - * @remarks Purges expired entries and persists if cleanup occurs. - */ - async load() { - try { - const data = await fs.readFile(this.filePath); - if (data.length < 32) - return; - let payload; - let migratedFromLegacy = false; - try { - payload = this._decodePayload(data, this.key); - } - catch { - const legacyKey = this._getLegacyKey(); - payload = this._decodePayload(data, legacyKey); - migratedFromLegacy = true; - } - this.credentials = new Map(Object.entries(payload.entries)); - const expiredCount = this._purgeExpired(); - if (expiredCount > 0 || migratedFromLegacy) - this.save(); - this.lastLoadedAt = Date.now(); - logger('debug', 'Credentials', `Loaded ${this.credentials.size} encrypted credentials from disk.`); - } - catch (error) { - const code = getErrorCode(error); - if (code !== 'ENOENT') { - logger('error', 'Credentials', `Failed to decrypt credentials: ${getErrorMessage(error)}`); - } - this.credentials = new Map(); - } - } - /** - * Debounces credential persistence to disk. - */ - save() { - if (this.saveTimeout) - return; - this.saveTimeout = setTimeout(() => { - this.saveTimeout = null; - void this.forceSave(); - }, this.saveDelayMs); - } - /** - * Forces credentials to be written immediately. - */ - async forceSave() { - if (this.saveTimeout) { - clearTimeout(this.saveTimeout); - this.saveTimeout = null; - } - try { - this._purgeExpired(); - await this._flushSaveQueue(); - logger('debug', 'Credentials', 'Force saved credentials to disk.'); - } - catch (error) { - logger('error', 'Credentials', `Failed to force save credentials: ${getErrorMessage(error)}`); - } } /** * Retrieves a credential value by key. @@ -160,9 +67,9 @@ export default class CredentialManager { */ set(key, value, ttlMs = 0) { const now = Date.now(); - const current = this.credentials.get(key); + const current = this.cache.get(key); const expiresAt = ttlMs > 0 ? now + ttlMs : null; - this.credentials.set(key, { + this.cache.set(key, { value, createdAt: current?.createdAt ?? now, updatedAt: now, @@ -176,7 +83,7 @@ export default class CredentialManager { * @returns True if an entry was removed. */ delete(key) { - const existed = this.credentials.delete(key); + const existed = this.cache.delete(key); if (existed) this.save(); return existed; @@ -188,215 +95,28 @@ export default class CredentialManager { has(key) { return this._getValidEntry(key) !== null; } - /** - * Clears all stored credentials. - */ - clear() { - if (this.credentials.size === 0) - return; - this.credentials.clear(); - this.save(); - } /** * Returns runtime statistics for credential storage. */ getStats() { const now = Date.now(); - const expiredEntries = this._countExpired(now); + let expiredEntries = 0; + for (const entry of this.cache.values()) { + if (entry.expiresAt && now > entry.expiresAt) + expiredEntries++; + } return { - totalEntries: this.credentials.size, + totalEntries: this.cache.size, expiredEntries, lastLoadedAt: this.lastLoadedAt ?? undefined, lastSavedAt: this.lastSavedAt ?? undefined }; } - _resolvePassword(options) { - const optionsCandidate = options; - const serverCandidate = optionsCandidate.server; - const server = isRecord(serverCandidate) - ? serverCandidate - : null; - const password = server && typeof server.password === 'string' ? server.password : null; + static _resolvePassword(options) { + const password = options.server?.password; if (!password) { throw new Error('CredentialManager requires options.server.password'); } return password; } - _deriveFastKey(password) { - return crypto - .createHash('sha256') - .update(`${CREDENTIALS_SALT}:${password}`) - .digest(); - } - _getLegacyKey() { - if (!this.legacyKey) { - this.legacyKey = crypto.scryptSync(this.password, CREDENTIALS_SALT, 32); - } - return this.legacyKey; - } - _getValidEntry(key) { - const entry = this.credentials.get(key); - if (!entry) - return null; - if (entry.expiresAt && Date.now() > entry.expiresAt) { - this.credentials.delete(key); - this.save(); - return null; - } - return entry; - } - _purgeExpired() { - const now = Date.now(); - let expiredCount = 0; - for (const [key, entry] of this.credentials.entries()) { - if (entry.expiresAt && now > entry.expiresAt) { - this.credentials.delete(key); - expiredCount++; - } - } - return expiredCount; - } - _countExpired(now) { - let expiredCount = 0; - for (const entry of this.credentials.values()) { - if (entry.expiresAt && now > entry.expiresAt) - expiredCount++; - } - return expiredCount; - } - _decodePayload(data, key) { - const iv = data.subarray(0, 16); - const tag = data.subarray(16, 32); - const encrypted = data.subarray(32); - const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv); - decipher.setAuthTag(tag); - const decrypted = Buffer.concat([ - decipher.update(encrypted), - decipher.final() - ]).toString('utf8'); - const parsed = JSON.parse(decrypted); - return this._normalizePayload(parsed); - } - _normalizePayload(raw) { - const now = Date.now(); - if (isRecord(raw)) { - const payloadCandidate = raw; - const entriesValue = payloadCandidate.entries; - if (isRecord(entriesValue)) { - const entries = this._normalizeEntries(entriesValue, now); - const savedAt = typeof payloadCandidate.savedAt === 'number' - ? payloadCandidate.savedAt - : now; - return { - version: CREDENTIALS_VERSION, - savedAt, - entries - }; - } - return { - version: CREDENTIALS_VERSION, - savedAt: now, - entries: this._normalizeEntries(raw, now) - }; - } - return { - version: CREDENTIALS_VERSION, - savedAt: now, - entries: {} - }; - } - _normalizeEntries(rawEntries, fallbackTime) { - const entries = {}; - for (const [key, value] of Object.entries(rawEntries)) { - entries[key] = this._normalizeEntry(value, fallbackTime); - } - return entries; - } - _normalizeEntry(rawValue, fallbackTime) { - if (isRecord(rawValue)) { - const entryCandidate = rawValue; - const value = Object.hasOwn(entryCandidate, 'value') - ? entryCandidate.value - : rawValue; - const createdAt = typeof entryCandidate.createdAt === 'number' - ? entryCandidate.createdAt - : fallbackTime; - const updatedAt = typeof entryCandidate.updatedAt === 'number' - ? entryCandidate.updatedAt - : createdAt; - const expiresAt = typeof entryCandidate.expiresAt === 'number' && - entryCandidate.expiresAt > 0 - ? entryCandidate.expiresAt - : null; - return { - value, - createdAt, - updatedAt, - expiresAt - }; - } - return { - value: rawValue, - createdAt: fallbackTime, - updatedAt: fallbackTime, - expiresAt: null - }; - } - _buildPayload() { - return { - version: CREDENTIALS_VERSION, - savedAt: Date.now(), - entries: Object.fromEntries(this.credentials) - }; - } - async _flushSaveQueue() { - if (this.savePromise) { - this.saveQueued = true; - await this.savePromise; - if (this.saveQueued) { - this.saveQueued = false; - await this._flushSaveQueue(); - } - return; - } - const payload = this._buildPayload(); - this.savePromise = this._writeToDisk(payload); - try { - await this.savePromise; - } - finally { - this.savePromise = null; - } - if (this.saveQueued) { - this.saveQueued = false; - await this._flushSaveQueue(); - } - } - async _writeToDisk(payload) { - const plainText = JSON.stringify(payload); - const iv = crypto.randomBytes(16); - const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv); - const encrypted = Buffer.concat([ - cipher.update(plainText, 'utf8'), - cipher.final() - ]); - const tag = cipher.getAuthTag(); - const outBuffer = Buffer.concat([iv, tag, encrypted]); - await fs.mkdir('./.cache', { recursive: true }); - try { - await fs.writeFile(this.tempFilePath, outBuffer); - await fs.rename(this.tempFilePath, this.filePath); - } - catch (error) { - logger('debug', 'Credentials', `Atomic save failed, falling back to direct write: ${getErrorMessage(error)}`); - await fs.writeFile(this.filePath, outBuffer); - try { - await fs.unlink(this.tempFilePath); - } - catch (cleanupError) { - logger('debug', 'Credentials', `Failed to remove temp credentials file: ${getErrorMessage(cleanupError)}`); - } - } - this.lastSavedAt = payload.savedAt; - } } diff --git a/dist/src/managers/dosProtectionManager.js b/dist/src/managers/dosProtectionManager.js index ebe3465e..e7ca32e2 100644 --- a/dist/src/managers/dosProtectionManager.js +++ b/dist/src/managers/dosProtectionManager.js @@ -1,4 +1,4 @@ -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; const DEFAULT_CONFIG = { enabled: true, thresholds: { @@ -40,7 +40,9 @@ export default class DosProtectionManager { */ constructor(nodelink) { this.nodelink = nodelink; - this.config = this._resolveConfig(nodelink.options?.dosProtection); + this.config = this._resolveConfig(nodelink.options?.api?.dosProtection ?? + nodelink.options?.security?.dosProtection ?? + nodelink.options?.dosProtection); this.ipRequestCounts = new Map(); this.cleanupInterval = setInterval(() => this._cleanup(), this._resolveCleanupInterval()); this.cleanupInterval.unref?.(); diff --git a/dist/src/managers/groupManager.js b/dist/src/managers/groupManager.js new file mode 100644 index 00000000..bad288de --- /dev/null +++ b/dist/src/managers/groupManager.js @@ -0,0 +1,152 @@ +import { logger } from '../utils.js'; +/** + * Manages groups of players within a session for multi-guild synchronization. + * + * @remarks + * A group is a pure orchestration layer — it does not share streams, decoders, + * or buffers between players. Each player in a group keeps its own independent + * audio pipeline (decoder, FlowController, OpusEncoder, voice connection). + * + * The group provides a single API surface to apply the same operations + * (play, pause, seek, volume, filters, etc.) to all member players at once, + * while still allowing individual player control. + * + * This is designed for radio bots that need to keep N guilds synchronized + * on the same track and position. + */ +export default class GroupManager { + /** + * Map of group ID to PlayerGroup. + */ + groups = new Map(); + /** + * Creates a new player group. + * + * @param id - Unique group identifier. + * @param guildIds - Initial set of guild IDs to include. + * @returns The created group. + * @throws Error if a group with the same ID already exists. + */ + create(id, guildIds = []) { + if (this.groups.has(id)) { + throw new Error(`Group '${id}' already exists`); + } + const group = { + id, + guildIds: new Set(guildIds), + createdAt: Date.now() + }; + this.groups.set(id, group); + logger('debug', 'GroupManager', `Group '${id}' created with ${guildIds.length} player(s)`); + return group; + } + /** + * Retrieves a group by ID. + * + * @param id - Group identifier. + * @returns The group, or `undefined` if not found. + */ + get(id) { + return this.groups.get(id); + } + /** + * Checks whether a group exists. + * + * @param id - Group identifier. + * @returns `true` when the group exists. + */ + has(id) { + return this.groups.has(id); + } + /** + * Deletes a group. Does not destroy the member players. + * + * @param id - Group identifier. + * @returns `true` if the group existed and was deleted. + */ + delete(id) { + const existed = this.groups.delete(id); + if (existed) { + logger('debug', 'GroupManager', `Group '${id}' deleted`); + } + return existed; + } + /** + * Adds a guild to a group. + * + * @param groupId - Target group identifier. + * @param guildId - Guild to add. + * @throws Error if the group does not exist. + */ + addPlayer(groupId, guildId) { + const group = this.groups.get(groupId); + if (!group) + throw new Error(`Group '${groupId}' not found`); + group.guildIds.add(guildId); + logger('debug', 'GroupManager', `Added guild ${guildId} to group '${groupId}' (${group.guildIds.size} member(s))`); + } + /** + * Removes a guild from a group. + * + * @param groupId - Target group identifier. + * @param guildId - Guild to remove. + * @throws Error if the group does not exist. + */ + removePlayer(groupId, guildId) { + const group = this.groups.get(groupId); + if (!group) + throw new Error(`Group '${groupId}' not found`); + group.guildIds.delete(guildId); + logger('debug', 'GroupManager', `Removed guild ${guildId} from group '${groupId}' (${group.guildIds.size} member(s))`); + } + /** + * Returns the guild IDs for a group. + * + * @param groupId - Target group identifier. + * @returns Array of guild IDs, or empty array if group not found. + */ + getGuildIds(groupId) { + const group = this.groups.get(groupId); + return group ? Array.from(group.guildIds) : []; + } + /** + * Lists all groups as JSON. + * + * @returns Array of serialized group states. + */ + list() { + return Array.from(this.groups.values()).map((g) => this._toJSON(g)); + } + /** + * Serializes a specific group to JSON. + * + * @param groupId - Target group identifier. + * @returns Serialized group state, or `null` if not found. + */ + toJSON(groupId) { + const group = this.groups.get(groupId); + return group ? this._toJSON(group) : null; + } + /** + * Destroys all groups. Called during session cleanup. + */ + destroy() { + this.groups.clear(); + } + /** + * Returns the number of groups. + */ + get size() { + return this.groups.size; + } + /** + * Internal JSON serialization helper. + */ + _toJSON(group) { + return { + id: group.id, + guildIds: Array.from(group.guildIds), + createdAt: group.createdAt + }; + } +} diff --git a/dist/src/managers/lyricsManager.js b/dist/src/managers/lyricsManager.js index 7ec0e435..bb0a1648 100644 --- a/dist/src/managers/lyricsManager.js +++ b/dist/src/managers/lyricsManager.js @@ -9,8 +9,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte import fs from 'node:fs/promises'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import { alignLyrics } from "../modules/lyricsAligner.js"; -import { logger } from "../utils.js"; +import { alignLyrics } from '../modules/lyricsAligner.js'; +import { logger } from '../utils.js'; const getErrorMessage = (error) => error instanceof Error ? error.message : String(error); const isTrackInfoLike = (value) => typeof value === 'object' && value !== null; const getTrackInfoFromResolve = (result, fallback) => { @@ -135,8 +135,13 @@ export default class LyricsManager { } } } - for (const [name, source] of this.lyricsSources) { - if (name === sourceName) + const sources = new Set([ + ...(this.nodelink.options.lyrics?.preferredSources ?? []), + ...this.lyricsSources.keys() + ]); + for (const name of sources) { + const source = this.lyricsSources.get(name); + if (!source || name === sourceName) continue; logger('debug', 'Lyrics', `Trying lyrics source ${name} for ${trackInfo?.title || 'Unknown Title'}.`); const lyrics = await source.getLyrics(trackInfo, language); diff --git a/dist/src/managers/meaningManager.js b/dist/src/managers/meaningManager.js index 5dd4897c..95bb6aab 100644 --- a/dist/src/managers/meaningManager.js +++ b/dist/src/managers/meaningManager.js @@ -9,7 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte import fs from 'node:fs/promises'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; /** * Checks whether a meaning source is enabled in config. * @param meaningsConfig - Meanings configuration bucket. diff --git a/dist/src/managers/playerManager.js b/dist/src/managers/playerManager.js index 164aa113..9b5c83bc 100644 --- a/dist/src/managers/playerManager.js +++ b/dist/src/managers/playerManager.js @@ -1,4 +1,4 @@ -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; /** * Session-scoped manager that controls player lifecycle and player commands. * @@ -224,7 +224,7 @@ export default class PlayerManager { eventQueue: session.eventQueue, isPaused: session.isPaused }; - const { Player } = await import("../playback/player.js"); + const { Player } = await import('../playback/player.js'); logger('debug', 'PlayerManager', `Creating new player for guild ${guildId} (session: ${this.sessionId})`); const player = new Player({ nodelink: this.nodelink, @@ -499,7 +499,7 @@ export default class PlayerManager { /** * Returns current SponsorBlock state for a player. */ - getSponsorBlock(guildId) { + async getSponsorBlock(guildId) { if (this.isCluster) { return this.runClusterPlayerCommand(guildId, 'getSponsorBlock', []); } diff --git a/dist/src/managers/pluginManager.js b/dist/src/managers/pluginManager.js index 389c71cd..3e2e979c 100644 --- a/dist/src/managers/pluginManager.js +++ b/dist/src/managers/pluginManager.js @@ -10,7 +10,7 @@ import fs from 'node:fs/promises'; import { createRequire } from 'node:module'; import path from 'node:path'; import { pathToFileURL } from 'node:url'; -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; /** * CommonJS resolver used to resolve npm package entry points. * @internal @@ -43,6 +43,10 @@ export default class PluginManager { loadedPlugins; /** Registered plugin hooks. */ hooks; + /** Tracks which hooks belong to which plugin for cleanup. */ + pluginHooks; + /** Tracks the current plugin being initialized to associate hooks correctly. */ + executingPluginName = null; /** * Creates a new plugin manager instance. * @param nodelink - NodeLink runtime context. @@ -56,6 +60,7 @@ export default class PluginManager { this.pluginsDir = path.join(process.cwd(), 'plugins'); this.loadedPlugins = new Map(); this.hooks = new Map(); + this.pluginHooks = new Map(); } /** * Loads and executes all configured plugins for the current process context. @@ -81,11 +86,52 @@ export default class PluginManager { * @public */ registerHook(name, callback) { + if (this.executingPluginName) { + if (!this.pluginHooks.has(this.executingPluginName)) { + this.pluginHooks.set(this.executingPluginName, new Set()); + } + this.pluginHooks.get(this.executingPluginName)?.add({ name, callback }); + } if (!this.hooks.has(name)) { this.hooks.set(name, []); } this.hooks.get(name)?.push(callback); } + /** + * Unloads a plugin by removing its hooks and cache entry. + * @param name - The name of the plugin to unload. + * @public + */ + unloadPlugin(name) { + const pluginHooks = this.pluginHooks.get(name); + if (pluginHooks) { + for (const { name: hookName, callback } of pluginHooks) { + const list = this.hooks.get(hookName); + if (list) { + const index = list.indexOf(callback); + if (index !== -1) + list.splice(index, 1); + } + } + this.pluginHooks.delete(name); + } + this.loadedPlugins.delete(name); + logger('info', 'PluginManager', `Unloaded plugin: ${name}`); + } + /** + * Reloads a specific plugin. + * @param name - Name of the plugin. + * @param contextType - Process context. + * @public + */ + async reloadPlugin(name, contextType) { + const def = this.config.find((d) => d.name === name); + if (!def) { + throw new Error(`Plugin '${name}' not found in configuration.`); + } + this.unloadPlugin(name); + await this._loadPlugin(def, contextType, true); + } /** * Synchronously executes all callbacks registered for a hook. * @param name - The name of the hook to trigger. @@ -246,13 +292,14 @@ export default class PluginManager { * Loads a single plugin definition and executes its entrypoint. * @param def - Plugin definition from config. * @param contextType - Current runtime context identifier. + * @param forceReload - Whether to bypass cache and use timestamp for reloading. * @internal */ - async _loadPlugin(def, contextType) { + async _loadPlugin(def, contextType, forceReload = false) { const { name, source, path: localPath, package: packageName } = def; if (!name || name.trim().length === 0) return; - if (this.loadedPlugins.has(name)) { + if (!forceReload && this.loadedPlugins.has(name)) { const cached = this.loadedPlugins.get(name); if (!cached) return; @@ -337,7 +384,10 @@ export default class PluginManager { } if (!entryPoint) return; - const fileUrl = pathToFileURL(entryPoint).href; + let fileUrl = pathToFileURL(entryPoint).href; + if (forceReload) { + fileUrl += `?t=${Date.now()}`; + } const importedModule = await import(__rewriteRelativeImportExtension(fileUrl)); const pluginModule = this._coercePluginModule(importedModule); if (!pluginModule) { @@ -349,7 +399,13 @@ export default class PluginManager { module: pluginModule, meta: pluginMeta }); - await this._executePlugin(pluginModule, name, contextType, pluginMeta); + this.executingPluginName = name; + try { + await this._executePlugin(pluginModule, name, contextType, pluginMeta); + } + finally { + this.executingPluginName = null; + } const author = `\x1b[36m${pluginMeta.author}\x1b[0m`; const pluginName = `\x1b[1m\x1b[32m${name}\x1b[0m`; const version = `\x1b[33mv${pluginMeta.version}\x1b[0m`; @@ -357,7 +413,7 @@ export default class PluginManager { ? ` | \x1b[34mTopic:\x1b[0m ${pluginMeta.topic}` : ''; const creditString = `[${author}] ${pluginName} ${version}${topic}`; - logger('info', 'PluginManager', `Loaded: ${creditString}`); + logger('info', 'PluginManager', `${forceReload ? 'Reloaded' : 'Loaded'}: ${creditString}`); } catch (error) { const message = error instanceof Error ? error.message : String(error); diff --git a/dist/src/managers/proxyManager.js b/dist/src/managers/proxyManager.js new file mode 100644 index 00000000..f5218b8a --- /dev/null +++ b/dist/src/managers/proxyManager.js @@ -0,0 +1,378 @@ +import { logger } from '../utils.js'; +const DEFAULT_CONFIG = { + enabled: false, + strategy: 'WeightedHealth', + disabledSources: [], + maxConsecutiveFailures: 3, + cooldownDurationMs: 60 * 1000 * 5, // 5 minutes + latencyWeight: 0.2 // EMA alpha +}; +const isRecord = (val) => typeof val === 'object' && val !== null && !Array.isArray(val); +export default class ProxyManager { + config; + targets; + states; + roundRobinIndex = 0; + constructor(options) { + this.targets = new Map(); + this.states = new Map(); + const network = isRecord(options.network) ? options.network : {}; + const rawConfig = isRecord(network.proxy) ? network.proxy : {}; + this.config = this.parseConfig(rawConfig); + this.extractTargets(rawConfig, options); + } + /** + * Evaluates if a given source is allowed to use proxies. + */ + isEnabledForSource(sourceName) { + if (!this.config.enabled) + return false; + if (this.config.disabledSources.includes(sourceName.toLowerCase())) + return false; + return this.targets.size > 0; + } + /** + * Selects the most optimal proxy based on the configured Load Balancing strategy. + * Employs a Circuit Breaker pattern to avoid dead proxies. + * + * @param sourceName - The identifier of the requesting source (e.g. 'youtube', 'bilibili') + * @returns A safe snapshot of the selected proxy, or `undefined` if none available. + */ + getBestProxy(sourceName) { + if (!this.isEnabledForSource(sourceName)) + return undefined; + this.processCooldowns(); + const availableIds = Array.from(this.states.entries()) + .filter(([_, state]) => state.status === 'UP') + .map(([id]) => id); + if (availableIds.length === 0) { + logger('warn', 'ProxyManager', `No healthy proxies available for source '${sourceName}'. All proxies are DOWN or in COOLDOWN.`); + return undefined; + } + let selectedId; + switch (this.config.strategy) { + case 'RoundRobin': + selectedId = this.selectRoundRobin(availableIds); + break; + case 'LeastConnections': + selectedId = this.selectLeastConnections(availableIds); + break; + case 'LowestLatency': + selectedId = this.selectLowestLatency(availableIds); + break; + case 'WeightedHealth': + selectedId = this.selectWeightedHealth(availableIds); + break; + default: + selectedId = this.selectWeightedHealth(availableIds); + } + if (!selectedId) + return undefined; + const state = this.states.get(selectedId); + const target = this.targets.get(selectedId); + if (!state || !target) + return undefined; + state.activeConnections++; + return { + target: { ...target }, + state: { ...state } + }; + } + /** + * Reports the resolution of a request utilizing a proxy. + * Updates health metrics, calculates exponential moving average latency, + * and trips the circuit breaker if thresholds are met. + */ + report(proxyUrl, success, statusCode, latencyMs = 0) { + const id = this.findIdByUrl(proxyUrl); + if (!id) + return; + const state = this.states.get(id); + if (!state) + return; + if (state.activeConnections > 0) { + state.activeConnections--; + } + if (success) { + this.handleSuccess(state, latencyMs); + } + else { + this.handleFailure(state, statusCode); + } + } + /** + * Allows adding dynamic proxies in runtime. + */ + addProxy(url, protocol = 'http') { + try { + const parsed = this.parseProxyUrl(url, protocol); + if (!this.targets.has(parsed.id)) { + this.targets.set(parsed.id, parsed); + this.states.set(parsed.id, this.createInitialState()); + logger('info', 'ProxyManager', `Dynamically added proxy: ${parsed.host}:${parsed.port}`); + } + } + catch (err) { + logger('error', 'ProxyManager', `Failed to add proxy ${url}: ${err instanceof Error ? err.message : String(err)}`); + } + } + /** + * Cleans up proxy manager resources. + */ + destroy() { + this.targets.clear(); + this.states.clear(); + } + handleSuccess(state, latencyMs) { + state.totalSuccesses++; + state.consecutiveFailures = 0; + state.lastSuccessAt = Date.now(); + if (latencyMs > 0) { + if (state.movingAverageLatency === 0) { + state.movingAverageLatency = latencyMs; + } + else { + const alpha = this.config.latencyWeight; + state.movingAverageLatency = + alpha * latencyMs + (1 - alpha) * state.movingAverageLatency; + } + } + if (state.status === 'DOWN' || state.status === 'COOLDOWN') { + state.status = 'UP'; + state.cooldownEndsAt = null; + } + } + handleFailure(state, statusCode) { + state.totalFailures++; + state.consecutiveFailures++; + state.lastFailureAt = Date.now(); + // Status code severity analysis + let failureWeight = 1; + if (statusCode === 403 || statusCode === 429) { + failureWeight = 3; // Severe rate limit or ban + } + else if (statusCode >= 500) { + failureWeight = 2; // Server side error + } + state.consecutiveFailures += failureWeight - 1; + if (state.consecutiveFailures >= this.config.maxConsecutiveFailures) { + this.tripCircuitBreaker(state); + } + } + tripCircuitBreaker(state) { + state.status = 'COOLDOWN'; + state.cooldownEndsAt = Date.now() + this.config.cooldownDurationMs; + logger('warn', 'ProxyManager', `Circuit breaker tripped for proxy. Cooling down for ${this.config.cooldownDurationMs / 1000}s.`); + } + processCooldowns() { + const now = Date.now(); + for (const state of this.states.values()) { + if (state.status === 'COOLDOWN' && + state.cooldownEndsAt && + now >= state.cooldownEndsAt) { + // Half-open state: transition back to UP to test it. If it fails once, it will trip again quickly. + state.status = 'UP'; + state.cooldownEndsAt = null; + // We reduce consecutive failures so it gets one more chance before tripping again + state.consecutiveFailures = Math.max(0, this.config.maxConsecutiveFailures - 1); + logger('info', 'ProxyManager', 'Proxy exited cooldown and is entering half-open state.'); + } + } + } + selectRoundRobin(availableIds) { + if (this.roundRobinIndex >= availableIds.length) { + this.roundRobinIndex = 0; + } + const selected = availableIds[this.roundRobinIndex]; + this.roundRobinIndex = (this.roundRobinIndex + 1) % availableIds.length; + return selected || availableIds[0] || ''; + } + selectLeastConnections(availableIds) { + return availableIds.reduce((prevId, currId) => { + const prevConnections = this.states.get(prevId)?.activeConnections ?? 0; + const currConnections = this.states.get(currId)?.activeConnections ?? 0; + return currConnections < prevConnections ? currId : prevId; + }); + } + selectLowestLatency(availableIds) { + return availableIds.reduce((prevId, currId) => { + const prevLatency = this.states.get(prevId)?.movingAverageLatency || Infinity; + const currLatency = this.states.get(currId)?.movingAverageLatency || Infinity; + // If both are 0 (untested), fallback to random or first + if (prevLatency === Infinity && currLatency === Infinity) + return prevId; + return currLatency < prevLatency ? currId : prevId; + }); + } + selectWeightedHealth(availableIds) { + // Sort by a composite score: (failures * high_penalty) + (active_connections * medium_penalty) + latency + const sorted = [...availableIds].sort((a, b) => { + const stateA = this.states.get(a); + const stateB = this.states.get(b); + if (!stateA || !stateB) + return 0; + const scoreA = stateA.consecutiveFailures * 1000 + + stateA.activeConnections * 100 + + (stateA.movingAverageLatency || 500); + const scoreB = stateB.consecutiveFailures * 1000 + + stateB.activeConnections * 100 + + (stateB.movingAverageLatency || 500); + return scoreA - scoreB; + }); + // Pick from the top 3 randomly to distribute load while still preferring healthy proxies + const poolSize = Math.min(3, sorted.length); + const randomIndex = Math.floor(Math.random() * poolSize); + return sorted[randomIndex] || availableIds[0] || ''; + } + findIdByUrl(url) { + for (const [id, target] of this.targets.entries()) { + if (target.url === url) + return id; + } + return undefined; + } + parseConfig(raw) { + const disabledSourcesCandidate = Array.isArray(raw.disabledSources) + ? raw.disabledSources + .filter((s) => typeof s === 'string') + .map((s) => s.toLowerCase()) + : DEFAULT_CONFIG.disabledSources; + let strategy = DEFAULT_CONFIG.strategy; + if (typeof raw.strategy === 'string') { + const s = raw.strategy; + if ([ + 'RoundRobin', + 'LeastConnections', + 'LowestLatency', + 'WeightedHealth' + ].includes(s)) { + strategy = s; + } + } + return { + enabled: typeof raw.enabled === 'boolean' ? raw.enabled : DEFAULT_CONFIG.enabled, + strategy, + disabledSources: disabledSourcesCandidate, + maxConsecutiveFailures: typeof raw.maxConsecutiveFailures === 'number' + ? raw.maxConsecutiveFailures + : DEFAULT_CONFIG.maxConsecutiveFailures, + cooldownDurationMs: typeof raw.cooldownDurationMs === 'number' + ? raw.cooldownDurationMs + : DEFAULT_CONFIG.cooldownDurationMs, + latencyWeight: typeof raw.latencyWeight === 'number' + ? raw.latencyWeight + : DEFAULT_CONFIG.latencyWeight + }; + } + extractTargets(rawConfig, fullOptions) { + // 1. Check global proxy object (single) + if (typeof rawConfig.url === 'string' && rawConfig.url.length > 0) { + try { + const parsed = this.parseProxyUrl(rawConfig.url, rawConfig.protocol || 'http', rawConfig.username, rawConfig.password, rawConfig.type); + this.targets.set(parsed.id, parsed); + } + catch (err) { + logger('error', 'ProxyManager', `Invalid global proxy URL: ${getErrorMessage(err)}`); + } + } + // 2. Check global proxy list + if (Array.isArray(rawConfig.list)) { + for (const item of rawConfig.list) { + try { + if (typeof item === 'string') { + const parsed = this.parseProxyUrl(item); + this.targets.set(parsed.id, parsed); + } + else if (isRecord(item) && typeof item.url === 'string') { + const parsed = this.parseProxyUrl(item.url, item.protocol, item.username, item.password, item.type); + this.targets.set(parsed.id, parsed); + } + } + catch (err) { + logger('error', 'ProxyManager', `Invalid proxy in list: ${getErrorMessage(err)}`); + } + } + } + // 3. Fallback: Migrate old YouTube proxies into the global pool if global list is empty + if (this.targets.size === 0) { + const sources = isRecord(fullOptions.sources) ? fullOptions.sources : {}; + const yt = isRecord(sources.youtube) ? sources.youtube : {}; + if (Array.isArray(yt.proxies)) { + for (const item of yt.proxies) { + try { + if (typeof item === 'string') { + const parsed = this.parseProxyUrl(item); + this.targets.set(parsed.id, parsed); + } + else if (isRecord(item) && typeof item.url === 'string') { + const parsed = this.parseProxyUrl(item.url, undefined, undefined, undefined, item.type); + this.targets.set(parsed.id, parsed); + } + } + catch (err) { + logger('error', 'ProxyManager', `Invalid youtube fallback proxy: ${getErrorMessage(err)}`); + } + } + } + // If we inherited proxies from youtube, implicitly enable the global manager + if (this.targets.size > 0 && typeof rawConfig.enabled !== 'boolean') { + this.config.enabled = true; + logger('info', 'ProxyManager', `Automatically enabled global ProxyManager using inherited YouTube proxies. (${this.targets.size} found)`); + } + } + for (const id of this.targets.keys()) { + this.states.set(id, this.createInitialState()); + } + } + parseProxyUrl(urlString, defaultProtocol = 'http', explicitUsername, explicitPassword, explicitType) { + let toParse = urlString; + if (!toParse.includes('://')) { + toParse = `${defaultProtocol}://${toParse}`; + } + const url = new URL(toParse); + let protocol = url.protocol.replace(':', ''); + if (!['http', 'https', 'socks4', 'socks5'].includes(protocol)) { + protocol = 'http'; + } + const username = explicitUsername || + (url.username ? decodeURIComponent(url.username) : undefined); + const password = explicitPassword || + (url.password ? decodeURIComponent(url.password) : undefined); + const host = url.hostname; + const port = url.port + ? parseInt(url.port, 10) + : protocol === 'https' + ? 443 + : 80; + const typeStr = explicitType === 'reverse' ? 'reverse' : 'forward'; + const id = `${protocol}://${host}:${port}`; + return { + id, + url: toParse, + protocol, + type: typeStr, + host, + port, + username, + password + }; + } + createInitialState() { + return { + status: 'UP', + consecutiveFailures: 0, + totalFailures: 0, + totalSuccesses: 0, + activeConnections: 0, + movingAverageLatency: 0, + lastFailureAt: null, + lastSuccessAt: null, + cooldownEndsAt: null + }; + } +} +function getErrorMessage(error) { + if (error instanceof Error) + return error.message; + return String(error); +} diff --git a/dist/src/managers/rateLimitManager.js b/dist/src/managers/rateLimitManager.js index 051d50cc..366af899 100644 --- a/dist/src/managers/rateLimitManager.js +++ b/dist/src/managers/rateLimitManager.js @@ -1,4 +1,4 @@ -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; const DEFAULT_PER_USER = { maxRequests: 50, timeWindowMs: 5000 @@ -48,7 +48,9 @@ export default class RateLimitManager { */ constructor(nodelink) { this.nodelink = nodelink; - this.config = this._resolveConfig(nodelink.options?.rateLimit); + this.config = this._resolveConfig(nodelink.options?.api?.rateLimit ?? + nodelink.options?.security?.rateLimit ?? + nodelink.options?.rateLimit); this.store = new Map(); this.cleanupInterval = setInterval(() => this._cleanup(), this._resolveCleanupInterval()); this.cleanupInterval.unref?.(); diff --git a/dist/src/managers/routePlannerManager.js b/dist/src/managers/routePlannerManager.js index a4cb38a5..315ce195 100644 --- a/dist/src/managers/routePlannerManager.js +++ b/dist/src/managers/routePlannerManager.js @@ -1,4 +1,27 @@ -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; +const normalizeIpBlocks = (blocks) => { + if (!Array.isArray(blocks)) + return []; + return blocks + .map((block) => { + if (typeof block === 'string') + return { cidr: block }; + if (block && + typeof block === 'object' && + typeof block.cidr === 'string') { + return block; + } + return null; + }) + .filter((block) => block !== null); +}; +const resolveConfig = (nodelink) => { + const cfg = nodelink.options.network.routePlanner; + return { + ...cfg, + ipBlocks: normalizeIpBlocks(cfg.ipBlocks) + }; +}; const BIGINT_MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER); /** * Provides outbound IP selection and ban tracking for route-planned requests. @@ -24,7 +47,7 @@ export default class RoutePlannerManager { */ constructor(nodelink) { this.nodelink = nodelink; - this.config = nodelink.options.routePlanner ?? {}; + this.config = resolveConfig(nodelink); this.blocks = []; this.bannedIps = new Map(); this.bannedBlocks = new Map(); @@ -40,6 +63,12 @@ export default class RoutePlannerManager { get ipBlocks() { return this.blocks; } + /** + * Compatibility alias used by shutdown paths. + */ + dispose() { + this.freeAll(); + } /** * Converts an IPv4 or IPv6 address string to bigint form. * @param ip - IP address string. diff --git a/dist/src/managers/sessionManager.js b/dist/src/managers/sessionManager.js index 70105b51..ec287aec 100644 --- a/dist/src/managers/sessionManager.js +++ b/dist/src/managers/sessionManager.js @@ -1,4 +1,5 @@ -import { generateRandomLetters, logger } from "../utils.js"; +import { generateRandomLetters, logger } from '../utils.js'; +import GroupManager from './groupManager.js'; /** * Manages active and resumable WebSocket sessions for NodeLink. * Handles the full lifecycle of a session, including creation, pausing for resumption, @@ -57,6 +58,7 @@ export default class SessionManager { userId: request.headers['user-id'], socket, players, + groups: new GroupManager(), resuming: false, timeout: 60, isPaused: false, @@ -160,9 +162,17 @@ export default class SessionManager { } else { for (const player of players.players.values()) { - player.destroy?.(); + try { + player.destroy?.(); + } + catch (error) { + const message = error instanceof Error ? error.message : String(error); + logger('error', 'SessionManager', `Failed to destroy player for guild ${player.guildId} during session destruction: ${message}`); + } } + players.players.clear(); } + session.groups.destroy(); session.socket?.destroy?.(); } /** diff --git a/dist/src/managers/sourceManager.js b/dist/src/managers/sourceManager.js index ac97e2f9..72f3d17e 100644 --- a/dist/src/managers/sourceManager.js +++ b/dist/src/managers/sourceManager.js @@ -6,16 +6,19 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte } return path; }; +import { AsyncLocalStorage } from 'node:async_hooks'; import fs from 'node:fs/promises'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import { logger } from "../utils.js"; +import { getBestMatch, logger } from '../utils.js'; /** * Central manager for audio source providers. * Handles source discovery, dynamic loading, and request routing based on URL patterns or aliases. * @public */ export default class SourcesManager { + /** Source instances active in the current track URL resolution chain. */ + resolvingSources = new AsyncLocalStorage(); /** The parent NodeLink instance context. */ nodelink; /** Map of primary source instances keyed by their unique identifier. */ @@ -54,12 +57,8 @@ export default class SourcesManager { const processSource = async (name, mod) => { const isYouTube = name === 'youtube' || name.includes('YouTube.ts'); const sourceKey = isYouTube ? 'youtube' : name; - const youtubeKey = 'youtube'; const sourceConfig = this.nodelink.options.sources; - const enabled = isYouTube - ? sourceConfig?.[youtubeKey] - ?.enabled - : !!sourceConfig?.[sourceKey]?.enabled; + const enabled = sourceConfig[sourceKey]?.enabled; if (!enabled) return; const importedModule = mod; @@ -103,9 +102,13 @@ export default class SourcesManager { }; try { await fs.access(sourcesDir); - const enabledSourceKeys = Object.entries(this.nodelink.options.sources || {}) - .filter(([, cfg]) => !!cfg?.enabled) - .map(([key]) => key.toLowerCase()); + const sources = this.nodelink.options.sources; + const enabledSourceKeys = Object.keys(sources) + .filter((key) => { + const config = sources[key]; + return config?.enabled; + }) + .map((key) => key.toLowerCase()); const uniqueEnabled = Array.from(new Set(enabledSourceKeys)); const sourceEntries = uniqueEnabled.map((sourceKey) => { const fileCandidates = sourceKey === 'youtube' @@ -221,10 +224,16 @@ export default class SourcesManager { * @public */ async searchWithDefault(query) { - const defaultSources = Array.isArray(this.nodelink.options.defaultSearchSource) - ? this.nodelink.options.defaultSearchSource - : [this.nodelink.options.defaultSearchSource]; + const configuredDefaultSource = this.nodelink.options.search.defaultSource; + const defaultSources = Array.isArray(configuredDefaultSource) + ? configuredDefaultSource + : [configuredDefaultSource]; + const activeSources = this.resolvingSources.getStore(); for (const source of defaultSources) { + const instance = activeSources && + (this.searchAliasMap.get(source) ?? this.sourceMap.get(source)); + if (instance && activeSources.has(instance)) + continue; try { const result = await this.search(source, query); if (result.loadType === 'search' && @@ -246,9 +255,7 @@ export default class SourcesManager { * @public */ async unifiedSearch(query) { - const searchSources = (this.nodelink.options.unifiedSearchSources || [ - 'youtube' - ]); + const searchSources = this.nodelink.options.search.unifiedSources; logger('debug', 'Sources', `Performing unified search for "${query}" on [${searchSources.join(', ')}]`); const searchPromises = searchSources.map((sourceName) => this._instrumentedSourceCall(sourceName, 'search', query).catch((e) => { logger('warn', 'Sources', `A source (${sourceName}) failed during unified search: ${e.message}`); @@ -326,15 +333,56 @@ export default class SourcesManager { * @param track - The normalized track metadata. * @param itag - Optional YouTube-specific itag override. * @param isRecovering - Whether this is a recovery attempt. + * @param isUpscaling - Whether this is an upscale attempt. * @returns A promise resolving to the URL result. * @public */ - async getTrackUrl(track, itag, isRecovering) { + async getTrackUrl(track, itag, isRecovering, isUpscaling) { const instance = this.sourceMap.get(track.sourceName); if (!instance?.getTrackUrl) { throw new Error(`Source ${track.sourceName} not found or does not support getTrackUrl`); } - return (await instance.getTrackUrl(track, itag, isRecovering)); + const sourceGetTrackUrl = instance.getTrackUrl; + const activeSources = this.resolvingSources.getStore(); + if (activeSources?.has(instance)) { + return { + exception: { + message: `Circular track URL resolution detected for source ${track.sourceName}.`, + severity: 'fault' + } + }; + } + const nextActiveSources = new Set(activeSources).add(instance); + return this.resolvingSources.run(nextActiveSources, async () => { + // ISRC Upscale: If track has ISRC and is from YouTube, try high-quality sources first. + if (track.isrc && + !isUpscaling && + !isRecovering && + (track.sourceName === 'youtube' || track.sourceName === 'ytmusic')) { + const hqSources = ['tidal', 'qobuz', 'applemusic', 'deezer']; + for (const source of hqSources) { + const hqSource = this.sources.get(source); + if (!hqSource || nextActiveSources.has(hqSource)) + continue; + try { + const searchResult = await this.search(source, track.isrc); + if (searchResult.loadType === 'search' && + Array.isArray(searchResult.data) && + searchResult.data.length > 0) { + const match = getBestMatch(searchResult.data, track); + if (match) { + logger('info', 'Sources', `ISRC Upscale: found match for ${track.isrc} on ${source}. Using high-quality source.`); + return await this.getTrackUrl(match.info, undefined, false, true); + } + } + } + catch (e) { + logger('debug', 'Sources', `ISRC Upscale attempt failed for ${source}: ${e.message}`); + } + } + } + return (await sourceGetTrackUrl.call(instance, track, itag, isRecovering)); + }); } /** * Retrieves an audio stream for a resolved track URL. diff --git a/dist/src/managers/sourceWorkerManager.js b/dist/src/managers/sourceWorkerManager.js index 08ecf1af..57712796 100644 --- a/dist/src/managers/sourceWorkerManager.js +++ b/dist/src/managers/sourceWorkerManager.js @@ -5,7 +5,7 @@ import net from 'node:net'; import os from 'node:os'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); const hasSocketSend = (res) => typeof res.send === 'function'; @@ -50,7 +50,7 @@ const buildSourceWorkerExecArgv = (options = null) => { const runtime = options?.cluster?.runtime || {}; const env = process.env; for (const arg of Array.from(args)) { - if (arg.startsWith('--max-old-space-size=')) + if (arg.startsWith('--max-old-space-size=') || arg === '--expose-gc') args.delete(arg); } const maxOldSpaceMb = parsePositiveInt(env.NODELINK_SOURCE_WORKER_MAX_OLD_SPACE_MB ?? diff --git a/dist/src/managers/statsManager.js b/dist/src/managers/statsManager.js index 3efa7586..9f29f281 100644 --- a/dist/src/managers/statsManager.js +++ b/dist/src/managers/statsManager.js @@ -1,4 +1,4 @@ -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; const MAX_ENDPOINT_ENTRIES = 500; const MAX_ENDPOINT_LENGTH = 200; const safeNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value : 0; @@ -103,7 +103,7 @@ export default class StatsManager { async initialize() { if (this.initialized) return; - const metricsEnabled = this.nodelink.options.metrics?.enabled ?? false; + const metricsEnabled = this.nodelink.options.api.metrics?.enabled ?? false; if (!metricsEnabled) { this.initialized = true; return; @@ -441,6 +441,13 @@ export default class StatsManager { this.initialized = true; logger('info', 'StatsManager', 'Prometheus metrics initialized.'); } + /** + * Returns the Prometheus registry for custom metric registration. + * @public + */ + getRegistry() { + return this.promRegister; + } /** * Returns a deep-copied snapshot of internal counters. */ diff --git a/dist/src/managers/trackCacheManager.js b/dist/src/managers/trackCacheManager.js index 3c035577..0f5b847d 100644 --- a/dist/src/managers/trackCacheManager.js +++ b/dist/src/managers/trackCacheManager.js @@ -1,21 +1,11 @@ -import crypto from 'node:crypto'; -import fs from 'node:fs/promises'; -import { logger } from "../utils.js"; +import BaseCacheManager from './baseCacheManager.js'; const TRACK_CACHE_SALT = 'nodelink-track-salt'; const DEFAULT_CACHE_FILE = './.cache/tracks.bin'; const DEFAULT_SAVE_DELAY_MS = 5000; const DEFAULT_TTL_MS = 1000 * 60 * 60 * 6; const DEFAULT_MAX_ENTRIES = 5000; const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 1000; -const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value); -const getErrorMessage = (error) => error instanceof Error ? error.message : String(error ?? 'Unknown error'); -const getErrorCode = (error) => { - if (!error || typeof error !== 'object' || !('code' in error)) { - return undefined; - } - const code = error.code; - return typeof code === 'string' ? code : undefined; -}; +const _isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value); /** * Encrypted cache for resolved track metadata and URLs. * @remarks Uses AES-256-GCM and purges expired entries on load and access. @@ -28,103 +18,25 @@ const getErrorCode = (error) => { * ``` * @public */ -export default class TrackCacheManager { +export default class TrackCacheManager extends BaseCacheManager { nodelink; - password; - key; - legacyKey; - filePath; - maxEntries; - cleanupIntervalMs; - cache; - saveTimeout; - cleanupInterval; /** * Creates a new track cache manager instance. * @param nodelink - NodeLink runtime context. */ constructor(nodelink) { + const password = TrackCacheManager._resolvePassword(nodelink.options); + const cacheOptions = TrackCacheManager._resolveCacheOptions(nodelink.options); + super({ + name: 'TrackCache', + passwordHashKey: password, + salt: TRACK_CACHE_SALT, + filePath: DEFAULT_CACHE_FILE, + saveDelayMs: DEFAULT_SAVE_DELAY_MS, + cleanupIntervalMs: cacheOptions.cleanupIntervalMs, + maxEntries: cacheOptions.maxEntries + }); this.nodelink = nodelink; - this.password = this._resolvePassword(nodelink.options); - this.key = this._deriveFastKey(this.password); - this.legacyKey = null; - const cacheOptions = this._resolveCacheOptions(nodelink.options); - this.filePath = DEFAULT_CACHE_FILE; - this.maxEntries = cacheOptions.maxEntries; - this.cleanupIntervalMs = cacheOptions.cleanupIntervalMs; - this.cache = new Map(); - this.saveTimeout = null; - this.cleanupInterval = setInterval(() => { - const expiredCount = this._purgeExpired(); - const evictedCount = this._enforceMaxEntries(); - if (expiredCount > 0 || evictedCount > 0) - this.save(); - }, this.cleanupIntervalMs); - this.cleanupInterval.unref?.(); - } - /** - * Loads cached tracks from disk. - */ - async load() { - try { - const data = await fs.readFile(this.filePath); - if (data.length < 32) - return; - let store; - let migratedFromLegacy = false; - try { - store = this._decodeStore(data, this.key); - } - catch { - const legacyKey = this._getLegacyKey(); - store = this._decodeStore(data, legacyKey); - migratedFromLegacy = true; - } - this.cache = new Map(Object.entries(store)); - const expiredCount = this._purgeExpired(); - const evictedCount = this._enforceMaxEntries(); - if (expiredCount > 0 || evictedCount > 0 || migratedFromLegacy) - this.save(); - logger('debug', 'TrackCache', `Loaded ${this.cache.size} cached tracks from disk.`); - } - catch (error) { - const code = getErrorCode(error); - if (code !== 'ENOENT') { - logger('error', 'TrackCache', `Failed to load track cache: ${getErrorMessage(error)}`); - } - this.cache = new Map(); - } - } - /** - * Debounces cache persistence. - */ - save() { - if (this.saveTimeout) - return; - this.saveTimeout = setTimeout(() => { - this.saveTimeout = null; - void this.forceSave(); - }, DEFAULT_SAVE_DELAY_MS); - } - /** - * Forces the cache to be written to disk immediately. - */ - async forceSave() { - try { - const plainText = JSON.stringify(Object.fromEntries(this.cache)); - const iv = crypto.randomBytes(16); - const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv); - const encrypted = Buffer.concat([ - cipher.update(plainText, 'utf8'), - cipher.final() - ]); - const tag = cipher.getAuthTag(); - await fs.mkdir('./.cache', { recursive: true }); - await fs.writeFile(this.filePath, Buffer.concat([iv, tag, encrypted])); - } - catch (error) { - logger('error', 'TrackCache', `Failed to save track cache: ${getErrorMessage(error)}`); - } } /** * Retrieves a cached value by source/identifier. @@ -133,17 +45,8 @@ export default class TrackCacheManager { */ get(source, identifier) { const key = `${source}:${identifier}`; - const entry = this.cache.get(key); - if (!entry) - return null; - if (entry.expiresAt && Date.now() > entry.expiresAt) { - this.cache.delete(key); - this.save(); - return null; - } - this.cache.delete(key); - this.cache.set(key, entry); - return entry.value; + const entry = this._getValidEntry(key); + return entry ? entry.value : null; } /** * Stores a cached value with a TTL. @@ -154,27 +57,32 @@ export default class TrackCacheManager { */ set(source, identifier, value, ttlMs = DEFAULT_TTL_MS) { const key = `${source}:${identifier}`; - if (this.cache.has(key)) { - this.cache.delete(key); - } + const now = Date.now(); this.cache.set(key, { value, - expiresAt: ttlMs > 0 ? Date.now() + ttlMs : null + createdAt: now, + updatedAt: now, + expiresAt: ttlMs > 0 ? now + ttlMs : null }); this._enforceMaxEntries(); this.save(); } - _resolveCacheOptions(options) { - const directCandidate = options.trackCache; - const rootCache = isRecord(directCandidate) ? directCandidate : null; - const nestedCandidate = options.cache; - const nestedCache = isRecord(nestedCandidate) - ? nestedCandidate.track - : null; - const nestedTrackCache = isRecord(nestedCache) ? nestedCache : null; - const selected = rootCache ?? nestedTrackCache; - const maxEntriesRaw = selected?.maxEntries; - const cleanupIntervalRaw = selected?.cleanupIntervalMs; + /** + * Deletes a cached value by source/identifier. + * @param source - Source name (e.g., "youtube"). + * @param identifier - Track identifier. + */ + delete(source, identifier) { + const key = `${source}:${identifier}`; + const deleted = this.cache.delete(key); + if (deleted) + this.save(); + return deleted; + } + static _resolveCacheOptions(options) { + const playback = options.playback; + const maxEntriesRaw = playback.maxPlaylistLength; + const cleanupIntervalRaw = playback.statsUpdateInterval; const maxEntries = typeof maxEntriesRaw === 'number' && Number.isFinite(maxEntriesRaw) ? Math.max(100, Math.floor(maxEntriesRaw)) : DEFAULT_MAX_ENTRIES; @@ -184,93 +92,11 @@ export default class TrackCacheManager { : DEFAULT_CLEANUP_INTERVAL_MS; return { maxEntries, cleanupIntervalMs }; } - _resolvePassword(options) { - const optionsCandidate = options; - const serverCandidate = optionsCandidate.server; - const server = isRecord(serverCandidate) - ? serverCandidate - : null; - const password = server && typeof server.password === 'string' ? server.password : null; + static _resolvePassword(options) { + const password = options.server?.password; if (!password) { throw new Error('TrackCacheManager requires options.server.password'); } return password; } - _deriveFastKey(password) { - return crypto - .createHash('sha256') - .update(`${TRACK_CACHE_SALT}:${password}`) - .digest(); - } - _getLegacyKey() { - if (!this.legacyKey) { - this.legacyKey = crypto.scryptSync(this.password, TRACK_CACHE_SALT, 32); - } - return this.legacyKey; - } - _purgeExpired() { - const now = Date.now(); - let expiredCount = 0; - for (const [key, entry] of this.cache.entries()) { - if (entry.expiresAt && now > entry.expiresAt) { - this.cache.delete(key); - expiredCount++; - } - } - return expiredCount; - } - _enforceMaxEntries() { - if (this.cache.size <= this.maxEntries) - return 0; - let removed = 0; - while (this.cache.size > this.maxEntries) { - const oldestKey = this.cache.keys().next().value; - if (!oldestKey) - break; - this.cache.delete(oldestKey); - removed++; - } - return removed; - } - _decodeStore(data, key) { - const iv = data.subarray(0, 16); - const tag = data.subarray(16, 32); - const encrypted = data.subarray(32); - const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv); - decipher.setAuthTag(tag); - const decrypted = Buffer.concat([ - decipher.update(encrypted), - decipher.final() - ]).toString('utf8'); - const parsed = JSON.parse(decrypted); - return this._normalizeStore(parsed); - } - _normalizeStore(raw) { - if (!isRecord(raw)) - return {}; - const store = {}; - for (const [key, value] of Object.entries(raw)) { - store[key] = this._normalizeEntry(value); - } - return store; - } - _normalizeEntry(rawValue) { - if (isRecord(rawValue)) { - const entryCandidate = rawValue; - const value = Object.hasOwn(entryCandidate, 'value') - ? entryCandidate.value - : rawValue; - const expiresAt = typeof entryCandidate.expiresAt === 'number' - ? entryCandidate.expiresAt - : null; - return { - value, - expiresAt - }; - } - return { - value: rawValue, - expiresAt: null - }; - } } diff --git a/dist/src/managers/workerManager.js b/dist/src/managers/workerManager.js index bfbf9cbc..6afba18f 100644 --- a/dist/src/managers/workerManager.js +++ b/dist/src/managers/workerManager.js @@ -6,7 +6,7 @@ import os from 'node:os'; import path from 'node:path'; import { fileURLToPath } from 'node:url'; import v8 from 'node:v8'; -import { logger } from "../utils.js"; +import { logger } from '../utils.js'; const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename); const getGlobalNodelink = () => globalThis.nodelink; @@ -124,12 +124,9 @@ export default class WorkerManager { this.nextStatelessWorkerIndex = 0; this.pendingRequests = new Map(); this.streamRequests = new Map(); - const availableParallelism = typeof os.availableParallelism === 'function' - ? os.availableParallelism() - : os.cpus().length; this.maxWorkers = config.cluster.workers === 0 - ? availableParallelism + ? os.cpus().length : Math.max(1, config.cluster.workers || 0); this.minWorkers = Math.max(1, config.cluster?.minWorkers || 1); this.workerLoad = new Map(); @@ -167,7 +164,7 @@ export default class WorkerManager { this.commandSocketPath = createSocketPath('commands'); this.commandServer = null; this.commandSockets = new Map(); - this.eventSockets = new Set(); + this.eventSockets = new Map(); this.socketRotateInProgress = false; this.lastSocketRotateAt = 0; logger('info', 'Cluster', `Primary PID ${process.pid} - WorkerManager initialized. Min: ${this.minWorkers}, Max: ${this.maxWorkers} workers`); @@ -339,22 +336,12 @@ export default class WorkerManager { let cost = playingCount * playingWeight + pausedCount * pausedWeight; if (stats.isHibernating) return cost; - const cpuLoad = stats.cpu?.nodelinkLoad ?? 0; - const lagP95 = stats.eventLoopLagP95 ?? stats.eventLoopLag ?? 0; - const frameDeficit = stats.frameStats?.deficit ?? 0; - const stuckRecoveries = stats.stuckRecoveries ?? 0; - if (cpuLoad > this.scalingConfig.cpuPenaltyLimit) { + if ((stats.cpu?.nodelinkLoad ?? 0) > this.scalingConfig.cpuPenaltyLimit) { cost += this.scalingConfig.maxPlayersPerWorker + 5; } - if (lagP95 > this.scalingConfig.lagPenaltyLimit) { + if ((stats.eventLoopLag ?? 0) > this.scalingConfig.lagPenaltyLimit) { cost += this.scalingConfig.maxPlayersPerWorker / 2; } - if (frameDeficit > playingCount * 10) { - cost += this.scalingConfig.maxPlayersPerWorker / 4; - } - if (stuckRecoveries > playingCount * 0.1 && playingCount > 0) { - cost += this.scalingConfig.maxPlayersPerWorker / 3; - } return cost; } _updateWorkerFailureHistory(workerId, code, signal) { @@ -375,16 +362,38 @@ export default class WorkerManager { } logger('debug', 'Cluster', `Worker ${workerId} failure history updated: ${JSON.stringify(history)}`); } + _registerEventSocket(pid, eventSocket) { + const worker = this.workers.find((w) => w.process.pid === pid); + if (!worker) + return; + const existing = this.eventSockets.get(worker.id); + if (existing && existing !== eventSocket) { + try { + existing.destroy(); + } + catch { } + } + eventSocket._workerId = worker.id; + this.eventSockets.set(worker.id, eventSocket); + } + _removeEventSocket(eventSocket) { + const workerId = eventSocket?._workerId; + if (!workerId) + return; + if (this.eventSockets.get(workerId) === eventSocket) { + this.eventSockets.delete(workerId); + } + } _startSocketServer() { this._safeUnlinkSocketPath(this.socketPath); this.server = net.createServer((socket) => { - this.eventSockets.add(socket); + const eventSocket = socket; const frameChunks = []; let frameBytes = 0; socket.on('error', () => { // Ignore per-connection transport errors (EPIPE/ECONNRESET). }); - socket.on('close', () => this.eventSockets.delete(socket)); + socket.on('close', () => this._removeEventSocket(eventSocket)); const peekBytes = (count) => { const first = frameChunks[0]; if (first && first.length >= count) @@ -459,7 +468,12 @@ export default class WorkerManager { } try { const data = v8.deserialize(payload); - if (type === 3) { + if (type === 0) { + // Event socket hello - register socket to worker by PID + if (isPidPacket(data)) + this._registerEventSocket(data.pid, eventSocket); + } + else if (type === 3) { // playerEvent const nodelink = getGlobalNodelink(); if (nodelink) @@ -469,10 +483,11 @@ export default class WorkerManager { }); } else if (type === 4) { - // workerStats + // workerStats - prefer socket-mapped worker ID over payload workerId if (isWorkerStatsPacket(data)) { - const { workerId, ...stats } = data; - this.statsUpdateBatch.set(workerId, stats); + const { workerId: payloadWorkerId, ...stats } = data; + const resolvedWorkerId = eventSocket._workerId ?? payloadWorkerId; + this.statsUpdateBatch.set(resolvedWorkerId, stats); if (!this.statsUpdateTimer) { this.statsUpdateTimer = setTimeout(() => this._flushStatsUpdates(), 100); } @@ -620,7 +635,7 @@ export default class WorkerManager { const oldEventPath = this.socketPath; const oldCommandPath = this.commandSocketPath; logger('warn', 'Cluster', `Rotating internal sockets after ${reason} (worker ${sourceWorkerId})`); - for (const socket of this.eventSockets) { + for (const socket of this.eventSockets.values()) { try { socket.destroy(); } @@ -865,6 +880,7 @@ export default class WorkerManager { WORKER_TYPE: 'playback' }); worker.workerType = 'playback'; + worker.send({ type: 'clusterId', clusterId: worker.id }); worker.ready = false; this.workers.push(worker); this.workersById.set(worker.id, worker); @@ -1053,28 +1069,6 @@ export default class WorkerManager { } } } - if (bestWorker) { - const ws = this.workerStats.get(bestWorker.id); - const localLoad = this.workerToGuilds.get(bestWorker.id)?.size ?? 0; - const lagP99 = ws?.eventLoopLagP99 ?? ws?.eventLoopLag ?? 0; - const cpuLoad = ws?.cpu?.nodelinkLoad ?? 0; - const stuckRecoveries = ws?.stuckRecoveries ?? 0; - const playingCount = localLoad; - const admissionDenied = lagP99 > this.scalingConfig.lagPenaltyLimit * 3 || - cpuLoad > 0.95 || - (stuckRecoveries > playingCount * 0.5 && playingCount > 5); - if (admissionDenied && this.workers.length < this.maxWorkers) { - logger('warn', 'Cluster', `Worker #${bestWorker.id} admission denied (lagP99=${lagP99.toFixed(1)}ms, cpu=${cpuLoad.toFixed(2)}, stuckRecoveries=${stuckRecoveries}). Forking new worker.`); - const newWorker = this.forkWorker(); - if (newWorker) { - this.assignGuildToWorker(playerKey, newWorker); - return newWorker; - } - } - else if (admissionDenied) { - logger('warn', 'Cluster', `Worker #${bestWorker.id} admission denied but at max workers. Assigning anyway.`); - } - } const threshold = this.scalingConfig.maxPlayersPerWorker; const hasConnectedWorker = !!bestWorker; if (hasConnectedWorker && @@ -1251,7 +1245,7 @@ export default class WorkerManager { catch { } } this.commandSockets.clear(); - for (const socket of this.eventSockets) { + for (const socket of this.eventSockets.values()) { try { socket.destroy(); } diff --git a/dist/src/meanings/letrasmus.js b/dist/src/meanings/letrasmus.js index 52aaadd9..c4ce7663 100644 --- a/dist/src/meanings/letrasmus.js +++ b/dist/src/meanings/letrasmus.js @@ -1,5 +1,5 @@ -import { translateMany, translateText } from "../modules/googleTranslate.js"; -import { getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { translateMany, translateText } from '../modules/googleTranslate.js'; +import { getBestMatch, http1makeRequest, logger } from '../utils.js'; /** * Letras suggest endpoint used to discover candidate tracks. * @internal diff --git a/dist/src/meanings/wikipedia.js b/dist/src/meanings/wikipedia.js index 6e6c767e..93563b1e 100644 --- a/dist/src/meanings/wikipedia.js +++ b/dist/src/meanings/wikipedia.js @@ -1,4 +1,4 @@ -import { logger, makeRequest } from "../utils.js"; +import { logger, makeRequest } from '../utils.js'; /** * Meaning provider backed by Wikipedia. * diff --git a/dist/src/modules/config/configMigration.js b/dist/src/modules/config/configMigration.js new file mode 100644 index 00000000..f27ca563 --- /dev/null +++ b/dist/src/modules/config/configMigration.js @@ -0,0 +1,185 @@ +import fs from 'node:fs/promises'; +import path from 'node:path'; +/** + * Migrates old flat configuration structures to the new hierarchical NodeLink schema. + */ +export function migrateConfig(oldConfig) { + const newConfig = JSON.parse(JSON.stringify(oldConfig)); + const migrationMap = { + host: 'server.host', + port: 'server.port', + password: 'server.password', + useBunServer: 'server.useBunServer', + trustProxy: 'trustProxy', + connection: 'connection', + proxy: 'network.proxy', + routePlanner: 'network.routePlanner', + maxSearchResults: 'search.maxResults', + defaultSearchSource: 'search.defaultSource', + unifiedSearchSources: 'search.unifiedSources', + resolveExternalLinks: 'search.resolveExternalLinks', + fetchChannelInfo: 'search.fetchChannelInfo', + maxAlbumPlaylistLength: 'playback.maxPlaylistLength', + playerUpdateInterval: 'playback.playerUpdateInterval', + statsUpdateInterval: 'playback.statsUpdateInterval', + trackStuckThresholdMs: 'playback.trackStuckThresholdMs', + eventTimeoutMs: 'playback.eventTimeoutMs', + zombieThresholdMs: 'playback.zombieThresholdMs', + sponsorblock: 'playback.sponsorblock', + filters: 'playback.filters', + audio: 'playback.audio', + voiceReceive: 'playback.voiceReceive', + mix: 'playback.mix', + enableTrackStreamEndpoint: 'api.enableTrackStreamEndpoint', + enableLoadStreamEndpoint: 'api.enableLoadStreamEndpoint', + dosProtection: 'dosProtection', + rateLimit: 'rateLimit', + metrics: 'metrics', + enableHoloTracks: 'experimental.enableHoloTracks', + commandTimeout: 'cluster.timeouts.heavyMs', + fastCommandTimeout: 'cluster.timeouts.fastMs' + }; + for (const [oldKey, newPath] of Object.entries(migrationMap)) { + if (Object.hasOwn(oldConfig, oldKey)) { + const value = oldConfig[oldKey]; + if (value === undefined) + continue; + // Do not overwrite already-migrated or explicit hierarchical values. + if (getDeepValue(newConfig, newPath) !== undefined) { + continue; + } + setDeepValue(newConfig, newPath, value); + } + } + const cluster = newConfig.cluster; + const network = newConfig.network; + const clusterTimeouts = cluster?.timeouts; + const connection = getDeepValue(newConfig, 'connection'); + if (connection) { + setDeepValue(newConfig, 'network.connection', connection); + } + const metrics = getDeepValue(newConfig, 'metrics'); + if (metrics) { + setDeepValue(newConfig, 'api.metrics', metrics); + } + if (typeof cluster?.commandTimeout === 'number' && + typeof clusterTimeouts?.heavyMs !== 'number') { + setDeepValue(newConfig, 'cluster.timeouts.heavyMs', cluster.commandTimeout); + } + if (typeof cluster?.fastCommandTimeout === 'number' && + typeof clusterTimeouts?.fastMs !== 'number') { + setDeepValue(newConfig, 'cluster.timeouts.fastMs', cluster.fastCommandTimeout); + } + if (!network?.proxy || typeof network.proxy !== 'object') { + setDeepValue(newConfig, 'network.proxy', { + enabled: false, + strategy: 'RoundRobin', + retries: 3, + timeout: 10000, + shuffleOnStart: true, + list: [] + }); + } + return newConfig; +} +function setDeepValue(obj, path, value) { + const parts = path.split('.'); + if (parts.length === 0) + return; + let current = obj; + for (let i = 0; i < parts.length - 1; i++) { + const part = parts[i]; + if (!part) + continue; + if (!current[part] || typeof current[part] !== 'object') { + current[part] = {}; + } + current = current[part]; + } + const leaf = parts[parts.length - 1]; + if (!leaf) + return; + current[leaf] = value; +} +function getDeepValue(obj, path) { + const parts = path.split('.'); + let current = obj; + for (const part of parts) { + if (!current || + typeof current !== 'object' || + Array.isArray(current) || + !(part in current)) { + return undefined; + } + const next = current[part]; + if (next === undefined) + return undefined; + current = next; + } + return current; +} +/** + * Converts a JavaScript object to a TypeScript literal string. + * Uses single quotes and avoids quoting keys when possible. + * + * @param obj - The object to convert. + * @param indent - Current indentation level. + * @returns A formatted string representation of the object. + * @internal + */ +export function toTsLiteral(obj, indent = 0) { + const spaces = ' '.repeat(indent); + const nextSpaces = ' '.repeat(indent + 2); + if (obj === null) + return 'null'; + if (typeof obj === 'string') + return `'${obj.replace(/'/g, "\\'")}'`; + if (typeof obj !== 'object') + return String(obj); + if (Array.isArray(obj)) { + if (obj.length === 0) + return '[]'; + const items = obj + .map((v) => toTsLiteral(v, indent + 2)) + .join(`,\n${nextSpaces}`); + return `[\n${nextSpaces}${items}\n${spaces}]`; + } + const keys = Object.keys(obj); + if (keys.length === 0) + return '{}'; + const props = keys + .map((key) => { + const val = obj[key]; + if (val === undefined) + return null; + const value = toTsLiteral(val, indent + 2); + const validKey = /^[a-z_$][a-z0-9_$]*$/i.test(key) ? key : `'${key}'`; + return `${validKey}: ${value}`; + }) + .filter((v) => v !== null) + .join(`,\n${nextSpaces}`); + return `{\n${nextSpaces}${props}\n${spaces}}`; +} +/** + * Persists a configuration object to config.ts if it was loaded from a legacy + * source or the default template. + * + * @param config - The migrated configuration object. + * @param fileName - The name of the source file. + */ +export async function persistConfig(config, fileName) { + const isLegacy = fileName.endsWith('.js'); + const isDefault = fileName.startsWith('config.default'); + if (!isLegacy && !isDefault) + return; + try { + const configTsPath = path.resolve(process.cwd(), 'config.ts'); + const literal = toTsLiteral(config); + const content = `import type { NodelinkConfig } from './src/typings/config/config.types.ts'\n\nexport const config: NodelinkConfig = ${literal}\n\nexport default config\n`; + await fs.writeFile(configTsPath, content, 'utf-8'); + console.log(`[INFO] Config: Automatically updated local config.ts from ${fileName}`); + } + catch (err) { + console.warn(`[WARN] Config: Failed to persist updated configuration: ${err instanceof Error ? err.message : String(err)}`); + } +} diff --git a/dist/src/modules/config/configMigration.test.js b/dist/src/modules/config/configMigration.test.js new file mode 100644 index 00000000..539752fa --- /dev/null +++ b/dist/src/modules/config/configMigration.test.js @@ -0,0 +1,154 @@ +import assert from 'node:assert/strict'; +import test from 'node:test'; +import defaultConfig from '../../../config.default.js'; +import { migrateConfig, toTsLiteral } from './configMigration.js'; +test('migrateConfig maps legacy flat config to hierarchical structure', () => { + const legacy = { + server: { + host: '0.0.0.0', + port: 3000, + password: 'legacy-pass', + useBunServer: false + }, + connection: { + interval: 12345, + timeout: 6789, + thresholds: { bad: 1, average: 5 }, + logAllChecks: true + }, + routePlanner: { + strategy: 'RotateOnBan', + bannedIpCooldown: 1000, + ipBlocks: ['1.1.1.0/24'] + }, + maxSearchResults: 25, + defaultSearchSource: ['youtube'], + unifiedSearchSources: ['youtube', 'soundcloud'], + resolveExternalLinks: true, + fetchChannelInfo: true, + maxAlbumPlaylistLength: 777, + playerUpdateInterval: 3000, + statsUpdateInterval: 15000, + trackStuckThresholdMs: 45000, + eventTimeoutMs: 3333, + zombieThresholdMs: 99999, + sponsorblock: { + enabled: true, + api: 'x', + categories: [], + actionTypes: ['skip'], + skipMarginMs: 1 + }, + filters: { enabled: { tremolo: true } }, + audio: { quality: 'high' }, + voiceReceive: { enabled: true, format: 'opus' }, + mix: { + enabled: true, + defaultVolume: 0.8, + maxLayersMix: 5, + autoCleanup: true + }, + enableTrackStreamEndpoint: true, + enableLoadStreamEndpoint: true, + dosProtection: { enabled: true }, + rateLimit: { enabled: true }, + metrics: { enabled: true }, + enableHoloTracks: true, + cluster: { + commandTimeout: 6000, + fastCommandTimeout: 4000 + } + }; + const migrated = migrateConfig(legacy); + assert.equal(migrated.search.maxResults, 25); + assert.deepEqual(migrated.search.defaultSource, ['youtube']); + assert.deepEqual(migrated.search.unifiedSources, ['youtube', 'soundcloud']); + assert.equal(migrated.search.resolveExternalLinks, true); + assert.equal(migrated.search.fetchChannelInfo, true); + assert.equal(migrated.playback.maxPlaylistLength, 777); + assert.equal(migrated.playback.playerUpdateInterval, 3000); + assert.equal(migrated.playback.statsUpdateInterval, 15000); + assert.equal(migrated.playback.trackStuckThresholdMs, 45000); + assert.equal(migrated.playback.eventTimeoutMs, 3333); + assert.equal(migrated.playback.zombieThresholdMs, 99999); + assert.equal(migrated.playback.voiceReceive.enabled, true); + assert.equal(migrated.api.enableTrackStreamEndpoint, true); + assert.equal(migrated.api.enableLoadStreamEndpoint, true); + assert.equal(migrated.experimental.enableHoloTracks, true); + assert.deepEqual(migrated.network.connection.interval, 12345); + assert.deepEqual(migrated.network.routePlanner.ipBlocks, ['1.1.1.0/24']); + assert.equal(migrated.cluster.timeouts?.heavyMs, 6000); + assert.equal(migrated.cluster.timeouts?.fastMs, 4000); + assert.equal(migrated.server.password, 'legacy-pass'); +}); +test('migrateConfig preserves explicit hierarchical values over legacy duplicates', () => { + const hybrid = { + server: { password: 'server-password' }, + trustProxy: true, + maxSearchResults: 10, + search: { maxResults: 50 }, + cluster: { + commandTimeout: 6000, + fastCommandTimeout: 4000, + timeouts: { heavyMs: 9000, fastMs: 7000 } + }, + network: { + proxy: { + enabled: true, + strategy: 'RoundRobin', + retries: 1, + timeout: 1, + shuffleOnStart: false, + list: [] + } + } + }; + const migrated = migrateConfig(hybrid); + assert.equal(migrated.server.password, 'server-password'); + assert.equal(migrated.search.maxResults, 50); + assert.equal(migrated.cluster.timeouts?.heavyMs, 9000); + assert.equal(migrated.cluster.timeouts?.fastMs, 7000); + assert.equal(migrated.network.proxy.enabled, true); +}); +test('migrateConfig fills required compatibility defaults', () => { + const minimalLegacy = { + server: { password: 'abc' }, + cluster: { commandTimeout: 1000, fastCommandTimeout: 2000 } + }; + const migrated = migrateConfig(minimalLegacy); + assert.equal(migrated.server.password, 'abc'); + assert.equal(migrated.cluster.timeouts?.heavyMs, 1000); + assert.equal(migrated.cluster.timeouts?.fastMs, 2000); + assert.equal(migrated.network.proxy.enabled, false); + assert.deepEqual(migrated.network.proxy.list, []); +}); +test('migrateConfig keeps vanilla default config valid', () => { + const migrated = migrateConfig(defaultConfig); + assert.equal(migrated.server.host, defaultConfig.server.host); + assert.equal(migrated.search.maxResults, defaultConfig.search.maxResults); + assert.equal(migrated.playback.playerUpdateInterval, defaultConfig.playback.playerUpdateInterval); + assert.equal(migrated.api.enableTrackStreamEndpoint, defaultConfig.api.enableTrackStreamEndpoint); + assert.equal(migrated.server.password, defaultConfig.server.password); +}); +test('toTsLiteral generates idiomatic TypeScript formatting', () => { + const input = { + a: 1, + 'b-c': 'val', + d: [1, { e: true }], + f: null, + g: "'quotes'" + }; + const expected = `{ + a: 1, + 'b-c': 'val', + d: [ + 1, + { + e: true + } + ], + f: null, + g: '\\'quotes\\'' +}`; + assert.equal(toTsLiteral(input), expected); +}); diff --git a/dist/src/modules/googleTranslate.js b/dist/src/modules/googleTranslate.js index e3067c05..9e24ef5c 100644 --- a/dist/src/modules/googleTranslate.js +++ b/dist/src/modules/googleTranslate.js @@ -1,4 +1,4 @@ -import { http1makeRequest } from "../utils.js"; +import { http1makeRequest } from '../utils.js'; /** * Fallback key used when no custom Google Translate key is configured. * @internal diff --git a/dist/src/modules/spotifyAuth.js b/dist/src/modules/spotifyAuth.js index bbe9fd20..a8242e8c 100644 --- a/dist/src/modules/spotifyAuth.js +++ b/dist/src/modules/spotifyAuth.js @@ -1,5 +1,5 @@ import crypto from 'node:crypto'; -import { http1makeRequest, logger } from "../utils.js"; +import { http1makeRequest, logger } from '../utils.js'; /** * Built-in encoded TOTP secrets used as primary/fallback bootstrap. * @internal @@ -119,7 +119,9 @@ async function getServerTime(spDc) { const data = typeof res.body === 'string' ? JSON.parse(res.body) : res.body; - return typeof data.serverTime === 'number' ? data.serverTime : Date.now(); + return typeof data.serverTime === 'number' + ? data.serverTime * 1000 + : Date.now(); } catch { return Date.now(); @@ -159,9 +161,8 @@ function generateTOTP(secretHex, timestampMs, step = 30) { */ async function performTokenRequest(secret, version, spDc, productType) { const isWebPlayer = productType === 'web-player'; - const serverTimeMs = isWebPlayer ? Date.now() : await getServerTime(spDc); - const localTimeMs = Date.now(); - const totpLocal = generateTOTP(secret, localTimeMs, 30); + const serverTimeMs = await getServerTime(spDc); + const totpLocal = generateTOTP(secret, serverTimeMs, 30); const totpServer = generateTOTP(secret, serverTimeMs, 900); const url = new URL('https://open.spotify.com/api/token'); url.searchParams.append('reason', 'init'); diff --git a/dist/src/playback/dash/DASHHandler.js b/dist/src/playback/dash/DASHHandler.js index 8d85fc71..aa22ce5e 100644 --- a/dist/src/playback/dash/DASHHandler.js +++ b/dist/src/playback/dash/DASHHandler.js @@ -1,5 +1,5 @@ import { Transform } from 'node:stream'; -import { logger, makeRequest } from "../../utils.js"; +import { logger, makeRequest } from '../../utils.js'; const PREFETCH_COUNT = 4; const MAX_BUFFERED = 16 * 1024; /** @@ -13,6 +13,7 @@ export class DASHHandler extends Transform { options; stopped = false; abortController = null; + readWaiters = []; constructor(mpdUrl, options = {}) { super(); this.mpdUrl = mpdUrl; @@ -21,6 +22,19 @@ export class DASHHandler extends Transform { _transform(_chunk, _encoding, callback) { callback(); } + _read(size) { + super._read(size); + this._resolveReadWaiters(); + } + _destroy(err, callback) { + this.stop(); + callback(err); + } + _resolveReadWaiters() { + const waiters = this.readWaiters.splice(0); + for (const resolve of waiters) + resolve(); + } /** * Fetch the MPD, parse representations, select AACLC, and stream segments. * Uses a bounded prefetch queue with backpressure to keep memory minimal. @@ -66,9 +80,7 @@ export class DASHHandler extends Transform { this.destroy(err); return; } - if (!this.push(initRes.body)) { - await this._waitForDrain(); - } + await this._pushChunk(initRes.body); const totalSegments = this._countSegments(selected); const segmentUrlGen = this._generateSegmentUrls(selected); const segmentDuration = this._calcSegmentDuration(selected); @@ -89,7 +101,8 @@ export class DASHHandler extends Transform { const fetchSegment = async (url) => { try { const res = await fetch(url, { - headers: this.options.headers + headers: this.options.headers, + signal }); if (!res.ok || !res.body) { logger('error', 'DASHHandler', `Segment fetch failed: HTTP ${res.status}`); @@ -125,7 +138,7 @@ export class DASHHandler extends Transform { break; const data = await pending; if (data && !this.stopped && !signal.aborted) { - this.push(data); + await this._pushChunk(data); } if (fetchIndex < totalSegments) { const url = segmentUrlGen.next().value; @@ -153,6 +166,7 @@ export class DASHHandler extends Transform { stop() { this.stopped = true; this.abortController?.abort(); + this._resolveReadWaiters(); } _sleepOrStop(ms) { return new Promise((resolve) => { @@ -171,17 +185,26 @@ export class DASHHandler extends Transform { } async _waitForBuffer() { while (this.readableLength > MAX_BUFFERED && !this.stopped) { - await this._waitForDrain(); + await this._waitForRead(); } } - _waitForDrain() { + _pushChunk(chunk) { + if (this.stopped || this.destroyed) + return Promise.resolve(); + if (this.push(chunk)) + return Promise.resolve(); + return this._waitForRead(); + } + _waitForRead() { return new Promise((resolve) => { if (this.readableLength <= MAX_BUFFERED) { resolve(); return; } const cleanup = () => { - this.off('data', onData); + const index = this.readWaiters.indexOf(onRead); + if (index !== -1) + this.readWaiters.splice(index, 1); this.off('end', onEnd); this.off('close', onEnd); }; @@ -189,13 +212,13 @@ export class DASHHandler extends Transform { cleanup(); resolve(); }; - const onData = () => { + const onRead = () => { if (this.readableLength <= MAX_BUFFERED) { cleanup(); resolve(); } }; - this.on('data', onData); + this.readWaiters.push(onRead); this.once('end', onEnd); this.once('close', onEnd); }); diff --git a/dist/src/playback/demuxers/Flv.js b/dist/src/playback/demuxers/Flv.js index c81c7394..8e81a600 100644 --- a/dist/src/playback/demuxers/Flv.js +++ b/dist/src/playback/demuxers/Flv.js @@ -1,7 +1,7 @@ import { Transform } from 'node:stream'; -import { logger } from "../../utils.js"; -import { bufferPool } from "../structs/BufferPool.js"; -import { RingBuffer } from "../structs/RingBuffer.js"; +import { logger } from '../../utils.js'; +import { bufferPool } from '../structs/BufferPool.js'; +import { RingBuffer } from '../structs/RingBuffer.js'; const STATE_HEADER = 0; const STATE_TAG_HEADER = 1; const STATE_TAG_BODY = 2; diff --git a/dist/src/playback/demuxers/WebmOpus.js b/dist/src/playback/demuxers/WebmOpus.js index 92be8484..4eefb832 100644 --- a/dist/src/playback/demuxers/WebmOpus.js +++ b/dist/src/playback/demuxers/WebmOpus.js @@ -1,6 +1,6 @@ import { Transform } from 'node:stream'; -import { logger } from "../../utils.js"; -import { RingBuffer } from "../structs/RingBuffer.js"; +import { logger } from '../../utils.js'; +import { RingBuffer } from '../structs/RingBuffer.js'; const TOO_SHORT = Symbol('TOO_SHORT'); const INVALID_VINT = Symbol('INVALID_VINT'); const parsePositiveIntEnv = (key, fallback) => { @@ -10,7 +10,7 @@ const parsePositiveIntEnv = (key, fallback) => { const parsed = Number.parseInt(raw, 10); return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; }; -const BUFFER_SIZE = parsePositiveIntEnv('NODELINK_WEBM_DEMUX_RING_BYTES', 2 * 1024 * 1024); +const BUFFER_SIZE = parsePositiveIntEnv('NODELINK_WEBM_DEMUX_RING_BYTES', 512 * 1024); const TAGS = Object.freeze({ '1a45dfa3': true, 18538067: true, diff --git a/dist/src/playback/filters/AnimatableFilter.js b/dist/src/playback/filters/AnimatableFilter.js index 45736b8a..58b7e5c6 100644 --- a/dist/src/playback/filters/AnimatableFilter.js +++ b/dist/src/playback/filters/AnimatableFilter.js @@ -1,4 +1,4 @@ -import { BaseFilter } from "./BaseFilter.js"; +import { BaseFilter } from './BaseFilter.js'; const SUPPORTED_CURVES = new Set([ 'linear', 'exponential', diff --git a/dist/src/playback/filters/channelMix.js b/dist/src/playback/filters/channelMix.js index 36a6a6aa..464d9f49 100644 --- a/dist/src/playback/filters/channelMix.js +++ b/dist/src/playback/filters/channelMix.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; /** * Mixes audio channels based on configurable weights. diff --git a/dist/src/playback/filters/chorus.js b/dist/src/playback/filters/chorus.js index 029e43f0..57b74d88 100644 --- a/dist/src/playback/filters/chorus.js +++ b/dist/src/playback/filters/chorus.js @@ -1,8 +1,8 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import DelayLine from "./dsp/delay.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import DelayLine from './dsp/delay.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; const MAX_DELAY_MS = 50; const bufferSize = Math.ceil((SAMPLE_RATE * MAX_DELAY_MS) / 1000); @@ -156,4 +156,9 @@ export default class Chorus extends AnimatableFilter { lfos[3].phase = (3 * Math.PI) / 2; return Buffer.alloc(0); } + destroy() { + for (const delay of this.delays) { + delay.destroy(); + } + } } diff --git a/dist/src/playback/filters/compressor.js b/dist/src/playback/filters/compressor.js index 9bdc3082..361673a2 100644 --- a/dist/src/playback/filters/compressor.js +++ b/dist/src/playback/filters/compressor.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; // biome-ignore lint/style/useExponentiationOperator: const dbToGain = (db) => Math.pow(10, db / 20); diff --git a/dist/src/playback/filters/distortion.js b/dist/src/playback/filters/distortion.js index bd52bf92..332a2b77 100644 --- a/dist/src/playback/filters/distortion.js +++ b/dist/src/playback/filters/distortion.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; /** * Applies various distortion effects (sin, cos, tan, etc.). diff --git a/dist/src/playback/filters/dsp/delay.js b/dist/src/playback/filters/dsp/delay.js index 535e628a..c30b94d0 100644 --- a/dist/src/playback/filters/dsp/delay.js +++ b/dist/src/playback/filters/dsp/delay.js @@ -20,7 +20,7 @@ export default class DelayLine { * @param sample - The PCM sample to write. */ write(sample) { - this.buffer.writeInt16LE(sample, this.writeIndex * 2); + this.buffer?.writeInt16LE(sample, this.writeIndex * 2); this.writeIndex = (this.writeIndex + 1) % this.size; } /** @@ -31,12 +31,15 @@ export default class DelayLine { read(delayInSamples) { const safeDelay = Math.max(0, Math.min(Math.floor(delayInSamples), this.size - 1)); const readIndex = (this.writeIndex - safeDelay + this.size) % this.size; - return this.buffer.readInt16LE(readIndex * 2); + return this.buffer?.readInt16LE(readIndex * 2) ?? 0; } /** * Clears the delay line buffer. */ clear() { - this.buffer.fill(0); + this.buffer?.fill(0); + } + destroy() { + this.buffer = null; } } diff --git a/dist/src/playback/filters/dsp/float64Delay.js b/dist/src/playback/filters/dsp/float64Delay.js index f509456d..757564c2 100644 --- a/dist/src/playback/filters/dsp/float64Delay.js +++ b/dist/src/playback/filters/dsp/float64Delay.js @@ -27,7 +27,10 @@ export class Float64DelayLine { * no clamping or truncation. */ write(sample) { - this.buffer[this.writeIndex] = sample; + const buf = this.buffer; + if (!buf) + return; + buf[this.writeIndex] = sample; this.writeIndex = (this.writeIndex + 1) % this.size; } /** @@ -43,15 +46,15 @@ export class Float64DelayLine { if (delayInSamples <= 0) { // Reading current write position (most recent sample) const idx = (this.writeIndex - 1 + this.size) % this.size; - return this.buffer[idx] ?? 0; + return this.buffer?.[idx] ?? 0; } const clamped = Math.min(delayInSamples, this.size - 1); const intDelay = Math.floor(clamped); const frac = clamped - intDelay; const idx0 = (this.writeIndex - intDelay - 1 + this.size * 2) % this.size; const idx1 = (idx0 - 1 + this.size) % this.size; - const s0 = this.buffer[idx0] ?? 0; - const s1 = this.buffer[idx1] ?? 0; + const s0 = this.buffer?.[idx0] ?? 0; + const s1 = this.buffer?.[idx1] ?? 0; // Linear interpolation: (1-frac)×s0 + frac×s1 return s0 + frac * (s1 - s0); } @@ -59,6 +62,9 @@ export class Float64DelayLine { * Clears the delay line (zero-fill). */ clear() { - this.buffer.fill(0); + this.buffer?.fill(0); + } + destroy() { + this.buffer = null; } } diff --git a/dist/src/playback/filters/dsp/lfo.js b/dist/src/playback/filters/dsp/lfo.js index 72772db4..f8b03a07 100644 --- a/dist/src/playback/filters/dsp/lfo.js +++ b/dist/src/playback/filters/dsp/lfo.js @@ -1,6 +1,6 @@ /** biome-ignore-all lint/complexity/useLiteralKeys: */ -import { SAMPLE_RATE } from "../../../constants.js"; -import { Waveforms } from "./waves.js"; +import { SAMPLE_RATE } from '../../../constants.js'; +import { Waveforms } from './waves.js'; /** * Low Frequency Oscillator for modulating audio parameters. * @public diff --git a/dist/src/playback/filters/echo.js b/dist/src/playback/filters/echo.js index f3544be2..7e952386 100644 --- a/dist/src/playback/filters/echo.js +++ b/dist/src/playback/filters/echo.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { Float64DelayLine } from "./dsp/float64Delay.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { Float64DelayLine } from './dsp/float64Delay.js'; const CHANNELS = 2; const MAX_DELAY_MS = 2000; const bufferSize = Math.ceil((SAMPLE_RATE * MAX_DELAY_MS) / 1000); @@ -117,4 +117,8 @@ export default class Echo extends AnimatableFilter { this.delayLineR.clear(); return Buffer.alloc(0); } + destroy() { + this.delayLineL.destroy(); + this.delayLineR.destroy(); + } } diff --git a/dist/src/playback/filters/equalizer.js b/dist/src/playback/filters/equalizer.js index e07e47fe..a76c8141 100644 --- a/dist/src/playback/filters/equalizer.js +++ b/dist/src/playback/filters/equalizer.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; const BANDS = [ 25, 40, 63, 100, 160, 250, 400, 630, 1000, 1600, 2500, 4000, 6300, 10000, diff --git a/dist/src/playback/filters/flanger.js b/dist/src/playback/filters/flanger.js index 68dab947..9d0310a6 100644 --- a/dist/src/playback/filters/flanger.js +++ b/dist/src/playback/filters/flanger.js @@ -1,8 +1,8 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import DelayLine from "./dsp/delay.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import DelayLine from './dsp/delay.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; const MAX_DELAY_MS = 10; const bufferSize = Math.ceil((SAMPLE_RATE * MAX_DELAY_MS) / 1000); @@ -85,4 +85,7 @@ export default class Flanger extends AnimatableFilter { this.lfo.phase = 0; return Buffer.alloc(0); } + destroy() { + this.delayLine.destroy(); + } } diff --git a/dist/src/playback/filters/highpass.js b/dist/src/playback/filters/highpass.js index 2a8027ae..93f4913b 100644 --- a/dist/src/playback/filters/highpass.js +++ b/dist/src/playback/filters/highpass.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; const BUTTERWORTH_Q = Math.SQRT1_2; const SUB_BLOCK_FRAMES = 64; diff --git a/dist/src/playback/filters/karaoke.js b/dist/src/playback/filters/karaoke.js index 07bd6ff2..c746a8d7 100644 --- a/dist/src/playback/filters/karaoke.js +++ b/dist/src/playback/filters/karaoke.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const MAX_OUTPUT_GAIN = 0.98; const SCALE_16 = 32768; const INV_16 = 1 / SCALE_16; @@ -295,4 +295,8 @@ export default class Karaoke extends AnimatableFilter { this._prevGain = MAX_OUTPUT_GAIN; return Buffer.alloc(0); } + destroy() { + this._bufL = null; + this._bufR = null; + } } diff --git a/dist/src/playback/filters/lowpass.js b/dist/src/playback/filters/lowpass.js index 6a4e08cf..3429a258 100644 --- a/dist/src/playback/filters/lowpass.js +++ b/dist/src/playback/filters/lowpass.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; const BUTTERWORTH_Q = Math.SQRT1_2; const SUB_BLOCK_FRAMES = 64; diff --git a/dist/src/playback/filters/phaser.js b/dist/src/playback/filters/phaser.js index 25512b99..0462763f 100644 --- a/dist/src/playback/filters/phaser.js +++ b/dist/src/playback/filters/phaser.js @@ -1,8 +1,8 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import Allpass from "./dsp/allpass.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import Allpass from './dsp/allpass.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; const MAX_STAGES = 12; /** diff --git a/dist/src/playback/filters/phonograph.js b/dist/src/playback/filters/phonograph.js index 818acd4a..70c95200 100644 --- a/dist/src/playback/filters/phonograph.js +++ b/dist/src/playback/filters/phonograph.js @@ -1,7 +1,7 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import LFO from './dsp/lfo.js'; const MAX_DELAY_MS = 60; const MAX_DELAY_SAMPLES = Math.ceil((SAMPLE_RATE * MAX_DELAY_MS) / 1000); class XorShift32 { @@ -34,15 +34,24 @@ class InterpDelayLine { this.buf = new Float32Array(size); } clear() { - this.buf.fill(0); + this.buf?.fill(0); this.w = 0; } + destroy() { + this.buf = null; + } write(x) { - this.buf[this.w] = x; - this.w = (this.w + 1) % this.buf.length; + const buf = this.buf; + if (!buf) + return; + buf[this.w] = x; + this.w = (this.w + 1) % buf.length; } read(delaySamples) { - const n = this.buf.length; + const buf = this.buf; + if (!buf) + return 0; + const n = buf.length; let r = this.w - delaySamples; while (r < 0) r += n; @@ -51,7 +60,7 @@ class InterpDelayLine { const i0 = r | 0; const i1 = (i0 + 1) % n; const frac = r - i0; - return (this.buf[i0] ?? 0) * (1 - frac) + (this.buf[i1] ?? 0) * frac; + return (buf[i0] ?? 0) * (1 - frac) + (buf[i1] ?? 0) * frac; } } class Biquad { @@ -337,4 +346,10 @@ export default class Phonograph extends AnimatableFilter { this.agcGain = 1; return Buffer.alloc(0); } + destroy() { + this.delay.destroy(); + this.r1.destroy(); + this.r2.destroy(); + this.r3.destroy(); + } } diff --git a/dist/src/playback/filters/reverb.js b/dist/src/playback/filters/reverb.js index 685bdcd7..9124f03d 100644 --- a/dist/src/playback/filters/reverb.js +++ b/dist/src/playback/filters/reverb.js @@ -1,6 +1,6 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; const CHANNELS = 2; const COMB_DELAYS = [1116, 1188, 1277, 1356, 1422, 1491, 1557, 1617]; const ALLPASS_DELAYS = [556, 441, 341, 225]; @@ -40,17 +40,24 @@ class CombFilter { * No clamping inside the loop — full Float64 precision. */ process(input) { - const output = this.buffer[this.writeIndex] ?? 0; + const buf = this.buffer; + if (!buf) + return 0; + const output = buf[this.writeIndex] ?? 0; this.filterStore = output * this.damp2 + this.filterStore * this.damp1; - this.buffer[this.writeIndex] = input + this.filterStore * this.feedback; + buf[this.writeIndex] = input + this.filterStore * this.feedback; this.writeIndex = (this.writeIndex + 1) % this.size; return output; } clear() { - this.buffer.fill(0); + this.buffer?.fill(0); this.filterStore = 0; this.writeIndex = 0; } + destroy() { + this.buffer = null; + this.filterStore = 0; + } } /** * Applies a Freeverb/Schroeder-based reverb effect. @@ -265,4 +272,20 @@ export default class Reverb extends AnimatableFilter { this.wetHPAccR = 0; return Buffer.alloc(0); } + destroy() { + for (const comb of [ + ...this.combFiltersL, + ...this.combFiltersR, + ...this.customCombsL, + ...this.customCombsR + ]) { + comb.destroy(); + } + this.combFiltersL = []; + this.combFiltersR = []; + this.customCombsL = []; + this.customCombsR = []; + this.allpassBuffersL = []; + this.allpassBuffersR = []; + } } diff --git a/dist/src/playback/filters/rotation.js b/dist/src/playback/filters/rotation.js index de975e2b..5a130e15 100644 --- a/dist/src/playback/filters/rotation.js +++ b/dist/src/playback/filters/rotation.js @@ -1,7 +1,7 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; /** * Rotates audio between left and right channels at a specific frequency. diff --git a/dist/src/playback/filters/spatial.js b/dist/src/playback/filters/spatial.js index 9f69ef60..04a0a64f 100644 --- a/dist/src/playback/filters/spatial.js +++ b/dist/src/playback/filters/spatial.js @@ -1,8 +1,8 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import DelayLine from "./dsp/delay.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import DelayLine from './dsp/delay.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; const MAX_DELAY_MS = 30; const bufferSize = Math.ceil((SAMPLE_RATE * MAX_DELAY_MS) / 1000); @@ -91,4 +91,8 @@ export default class Spatial extends AnimatableFilter { this.rightDelay.clear(); return Buffer.alloc(0); } + destroy() { + this.leftDelay.destroy(); + this.rightDelay.destroy(); + } } diff --git a/dist/src/playback/filters/tesseract.js b/dist/src/playback/filters/tesseract.js new file mode 100644 index 00000000..0f4d013e --- /dev/null +++ b/dist/src/playback/filters/tesseract.js @@ -0,0 +1,85 @@ +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import LFO from './dsp/lfo.js'; +const CHANNELS = 2; +export default class Tesseract extends AnimatableFilter { + priority = 11; + lfoTheta; + lfoPhi; + lfoGamma; + rotationHz = 0; + alpha = 0; + delaySamples = Math.floor(SAMPLE_RATE * 0.015); + delayBufferL = new Int16Array(this.delaySamples); + delayBufferR = new Int16Array(this.delaySamples); + delayIndex = 0; + constructor() { + super(); + this.lfoTheta = new LFO('SINE'); + this.lfoPhi = new LFO('SINE'); + this.lfoGamma = new LFO('SINE'); + } + update(settings) { + const r = settings?.tesseract || {}; + const isDisabled = r._disabled === true; + this.rotationHz = r.rotationHz ?? 0; + if (this.rotationHz > 0.001) { + this.lfoTheta.update(this.rotationHz, 1); + this.lfoPhi.update(this.rotationHz * 1.33, 1); + this.lfoGamma.update(this.rotationHz * 0.77, 1); + } + const targetAlpha = isDisabled ? 0.0 : this.rotationHz > 0.001 ? 1.0 : 0.0; + super.applyAnimatedUpdate({ tesseract: { alpha: targetAlpha } }, 'tesseract', { alpha: 0.0 }); + } + onConfigChanged(config) { + this.alpha = config.alpha ?? 0; + } + isConfigActive(config) { + const a = config ? config.alpha : this.alpha; + return (a ?? 0) > 0.001; + } + process(chunk) { + super.processAnimation(SAMPLE_RATE, chunk.length, CHANNELS); + if (this.alpha <= 0.001) { + return chunk; + } + const alpha = this.alpha; + for (let i = 0; i < chunk.length; i += 4) { + const thetaVal = this.lfoTheta.getValue() * Math.PI; + const phiVal = this.lfoPhi.getValue() * Math.PI; + const gammaVal = this.lfoGamma.getValue() * Math.PI; + const sinTheta = Math.sin(thetaVal); + const cosTheta = Math.cos(thetaVal); + const sinPhi = Math.sin(phiVal); + const cosPhi = Math.cos(phiVal); + const sinGamma = Math.sin(gammaVal); + const cosGamma = Math.cos(gammaVal); + const L = chunk.readInt16LE(i); + const R = chunk.readInt16LE(i + 2); + const Y = this.delayBufferL[this.delayIndex] ?? 0; + const Z = this.delayBufferR[this.delayIndex] ?? 0; + this.delayBufferL[this.delayIndex] = L; + this.delayBufferR[this.delayIndex] = R; + this.delayIndex = (this.delayIndex + 1) % this.delaySamples; + const L_rot = L * cosTheta - Y * sinTheta; + const R_rot = R * cosPhi - Z * sinPhi; + const newLeft = L_rot * cosGamma - R_rot * sinGamma; + const newRight = L_rot * sinGamma + R_rot * cosGamma; + const finalLeft = L * (1 - alpha) + newLeft * alpha; + const finalRight = R * (1 - alpha) + newRight * alpha; + chunk.writeInt16LE(clamp16Bit(finalLeft), i); + chunk.writeInt16LE(clamp16Bit(finalRight), i + 2); + } + return chunk; + } + flush() { + this.lfoTheta.phase = 0; + this.lfoPhi.phase = 0; + this.lfoGamma.phase = 0; + this.delayBufferL.fill(0); + this.delayBufferR.fill(0); + this.delayIndex = 0; + return Buffer.alloc(0); + } +} diff --git a/dist/src/playback/filters/timescale.js b/dist/src/playback/filters/timescale.js index 091bffe8..42f5f6b1 100644 --- a/dist/src/playback/filters/timescale.js +++ b/dist/src/playback/filters/timescale.js @@ -1,8 +1,8 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import { resample } from "./timescale/resampler.js"; -import TimeStretch from "./timescale/timeStretch.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import { resample } from './timescale/resampler.js'; +import TimeStretch from './timescale/timeStretch.js'; const CHANNELS = 2; const BYTES_PER_SAMPLE = 2; const FRAME_SIZE = CHANNELS * BYTES_PER_SAMPLE; @@ -217,4 +217,7 @@ export default class Timescale extends AnimatableFilter { this._reset(); return floatToInt16Buffer(combined); } + destroy() { + this._timeStretch.destroy(); + } } diff --git a/dist/src/playback/filters/timescale/floatFifoBuffer.js b/dist/src/playback/filters/timescale/floatFifoBuffer.js index a96a0c2c..adc0a42a 100644 --- a/dist/src/playback/filters/timescale/floatFifoBuffer.js +++ b/dist/src/playback/filters/timescale/floatFifoBuffer.js @@ -49,6 +49,12 @@ export default class FloatFifoBuffer { this._startFrame = 0; this._frames = 0; } + destroy() { + // biome-ignore lint/suspicious/noExplicitAny: intentional null to release buffer + ; + this._buffer = null; + this._frames = 0; + } /** * Calculates the starting sample index. */ diff --git a/dist/src/playback/filters/timescale/timeStretch.js b/dist/src/playback/filters/timescale/timeStretch.js index f5b9fa87..492965b7 100644 --- a/dist/src/playback/filters/timescale/timeStretch.js +++ b/dist/src/playback/filters/timescale/timeStretch.js @@ -1,4 +1,4 @@ -import FloatFifoBuffer from "./floatFifoBuffer.js"; +import FloatFifoBuffer from './floatFifoBuffer.js'; const DEFAULT_FRAME_SIZE = 1024; const DEFAULT_OVERLAP = 256; const DEFAULT_SEARCH = 128; @@ -66,6 +66,10 @@ export default class TimeStretch { this._inputPos = 0; this._prevOverlap = null; } + destroy() { + this._buffer.destroy(); + this._prevOverlap = null; + } /** * Processes new audio samples. * @param samples - The input Float32Array of samples. diff --git a/dist/src/playback/filters/tremolo.js b/dist/src/playback/filters/tremolo.js index 19485a6a..7faf0cab 100644 --- a/dist/src/playback/filters/tremolo.js +++ b/dist/src/playback/filters/tremolo.js @@ -1,7 +1,7 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; /** * Applies a tremolo effect (amplitude modulation) using an LFO. diff --git a/dist/src/playback/filters/vibrato.js b/dist/src/playback/filters/vibrato.js index 1a7c0712..4fab01a5 100644 --- a/dist/src/playback/filters/vibrato.js +++ b/dist/src/playback/filters/vibrato.js @@ -1,8 +1,8 @@ -import { SAMPLE_RATE } from "../../constants.js"; -import { AnimatableFilter } from "./AnimatableFilter.js"; -import { clamp16Bit } from "./dsp/clamp16Bit.js"; -import DelayLine from "./dsp/delay.js"; -import LFO from "./dsp/lfo.js"; +import { SAMPLE_RATE } from '../../constants.js'; +import { AnimatableFilter } from './AnimatableFilter.js'; +import { clamp16Bit } from './dsp/clamp16Bit.js'; +import DelayLine from './dsp/delay.js'; +import LFO from './dsp/lfo.js'; const CHANNELS = 2; const MAX_DELAY_MS = 20; const bufferSize = Math.ceil((SAMPLE_RATE * MAX_DELAY_MS) / 1000); @@ -93,4 +93,8 @@ export default class Vibrato extends AnimatableFilter { this.lfo.phase = 0; return Buffer.alloc(0); } + destroy() { + this.leftDelay.destroy(); + this.rightDelay.destroy(); + } } diff --git a/dist/src/playback/hls/AESDecryptor.js b/dist/src/playback/hls/AESDecryptor.js index 34dccbe3..c5876789 100644 --- a/dist/src/playback/hls/AESDecryptor.js +++ b/dist/src/playback/hls/AESDecryptor.js @@ -1,5 +1,5 @@ import crypto from 'node:crypto'; -import { logger } from "../../utils.js"; +import { logger } from '../../utils.js'; /** * Decrypts AES-encrypted HLS segment data. * Supports AES-128-CBC and AES-256-CBC. diff --git a/dist/src/playback/hls/HLSHandler.js b/dist/src/playback/hls/HLSHandler.js index a2ffbab9..eb51441b 100644 --- a/dist/src/playback/hls/HLSHandler.js +++ b/dist/src/playback/hls/HLSHandler.js @@ -1,7 +1,7 @@ import { PassThrough } from 'node:stream'; -import { http1makeRequest, logger } from "../../utils.js"; -import { parse as parsePlaylist } from "./PlaylistParser.js"; -import SegmentFetcher from "./SegmentFetcher.js"; +import { http1makeRequest, logger } from '../../utils.js'; +import { parse as parsePlaylist } from './PlaylistParser.js'; +import SegmentFetcher from './SegmentFetcher.js'; const MAX_HISTORY = 200; const MAX_GAP = 30; const MASTER_REFRESH_INTERVAL = 3; @@ -51,7 +51,7 @@ export default class HLSHandler extends PassThrough { this.currentUrl = url; this.headers = options.headers ?? {}; this.localAddress = options.localAddress ?? null; - this.proxy = options.proxy ?? null; + this.proxy = options.network?.proxy ?? options.proxy ?? null; this.onResolveUrl = options.onResolveUrl ?? null; this.strategy = options.strategy ?? diff --git a/dist/src/playback/hls/PlaylistParser.js b/dist/src/playback/hls/PlaylistParser.js index 9eb610c4..f67fbcf4 100644 --- a/dist/src/playback/hls/PlaylistParser.js +++ b/dist/src/playback/hls/PlaylistParser.js @@ -56,7 +56,13 @@ export function parse(content, baseUrl) { currentKey = parseAttributes(line, baseUrl); } else if (line.startsWith('#EXT-X-MAP:')) { - currentMap = parseAttributes(line, baseUrl); + const attrs = parseAttributes(line, baseUrl); + currentMap = { + uri: typeof attrs.uri === 'string' ? attrs.uri : undefined, + byteRange: typeof attrs.byterange === 'string' + ? parseByteRange(attrs.byterange, null) + : null + }; } else if (line.startsWith('#EXTINF:')) { const parts = line.split(':'); diff --git a/dist/src/playback/hls/SegmentFetcher.js b/dist/src/playback/hls/SegmentFetcher.js index eb20de65..0689d842 100644 --- a/dist/src/playback/hls/SegmentFetcher.js +++ b/dist/src/playback/hls/SegmentFetcher.js @@ -1,6 +1,6 @@ import crypto from 'node:crypto'; import { Transform } from 'node:stream'; -import { http1makeRequest, logger } from "../../utils.js"; +import { http1makeRequest, logger } from '../../utils.js'; /** * A Transform stream that decrypts HLS segments on the fly. * @@ -53,7 +53,7 @@ export default class SegmentFetcher { constructor(options = {}) { this.headers = options.headers || {}; this.localAddress = options.localAddress || null; - this.proxy = options.proxy || null; + this.proxy = options.network?.proxy || options.proxy || null; this.onResolveUrl = options.onResolveUrl || null; this.keyMap = new Map(); } @@ -104,13 +104,20 @@ export default class SegmentFetcher { async fetchMap(mapInfo, keyInfo = null) { if (!mapInfo?.uri) return null; + const headers = { + ...this.headers + }; + if (mapInfo.byteRange) { + const end = mapInfo.byteRange.offset + mapInfo.byteRange.length - 1; + headers.Range = `bytes=${mapInfo.byteRange.offset}-${end}`; + } const { body, error, statusCode } = await http1makeRequest(mapInfo.uri, { - headers: this.headers, + headers, responseType: 'buffer', localAddress: this.localAddress ?? undefined, proxy: this.proxy ?? undefined }); - if (error || statusCode !== 200) { + if (error || (statusCode !== 200 && statusCode !== 206)) { throw new Error(`Map fetch failed: ${statusCode}`); } const buffer = body; diff --git a/dist/src/playback/opus/Opus.js b/dist/src/playback/opus/Opus.js index 5969403c..08cd1168 100644 --- a/dist/src/playback/opus/Opus.js +++ b/dist/src/playback/opus/Opus.js @@ -1,21 +1,18 @@ +import { Buffer } from 'node:buffer'; import { createRequire } from 'node:module'; import { Transform } from 'node:stream'; -import { bufferPool } from "../structs/BufferPool.js"; +import { bufferPool } from '../structs/BufferPool.js'; const require = createRequire(import.meta.url); +const OPUS_MAX_PACKET_SIZE = 4000; +const OPUS_MAX_PACKET_DURATION_MS = 120; +const PCM_SAMPLE_BYTES = 2; +// ^^ @toddynnn/voice-opus related, the encodeInto() functions does not check for MAX_PACKET_SIZE, unlike the encode(). const OPUS_CTL = { BITRATE: 4002, FEC: 4012, PLP: 4014, DTX: 4016 }; -const parsePositiveIntEnv = (key, fallback) => { - const raw = process.env[key]; - if (!raw) - return fallback; - const parsed = Number.parseInt(raw, 10); - return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; -}; -const RING_SIZE = parsePositiveIntEnv('NODELINK_OPUS_ENCODER_RING_BYTES', 512 * 1024); let ACTIVE_LIB = null; const _getLib = () => { if (ACTIVE_LIB) @@ -76,86 +73,91 @@ export class Encoder extends Transform { lib; frameSize; frameBytes; - ring; - swap; - writePos; - readPos; + leftover; + leftoverStorage; + encodedScratch; constructor({ rate = 48000, channels = 2, frameSize = 960, application = 'audio' } = {}) { super({ readableObjectMode: true }); const { instance, lib } = _createInstance(rate, channels, application); this.enc = instance; this.lib = lib; this.frameSize = frameSize; - this.frameBytes = frameSize * channels * 2; - this.ring = bufferPool.acquire(RING_SIZE); - this.swap = bufferPool.acquire(this.frameBytes); - this.writePos = 0; - this.readPos = 0; + this.frameBytes = frameSize * channels * PCM_SAMPLE_BYTES; + this.leftover = null; + this.leftoverStorage = null; + this.encodedScratch = Buffer.allocUnsafe(OPUS_MAX_PACKET_SIZE); } _transform(chunk, _encoding, cb) { if (!chunk?.length) { cb(); return; } - if (!this.ring || !this.swap) { + if (!this.enc) { cb(new Error('Encoder destroyed.')); return; } - let wp = this.writePos; - let rp = this.readPos; - const total = chunk.length; - let remaining = total; - while (remaining > 0) { - const space = RING_SIZE - wp; - const canWrite = remaining < space ? remaining : space; - chunk.copy(this.ring, wp, total - remaining, total - remaining + canWrite); - remaining -= canWrite; - wp += canWrite; - if (wp === RING_SIZE) - wp = 0; + let buf; + let pooledBuf = null; + if (this.leftover?.length) { + const totalLen = this.leftover.length + chunk.length; + pooledBuf = bufferPool.acquire(totalLen); + this.leftover.copy(pooledBuf, 0); + chunk.copy(pooledBuf, this.leftover.length); + if (this.leftoverStorage) + bufferPool.release(this.leftoverStorage); + this.leftover = null; + this.leftoverStorage = null; + buf = pooledBuf.subarray(0, totalLen); } - while (true) { - const available = wp >= rp ? wp - rp : RING_SIZE - rp + wp; - if (available < this.frameBytes) - break; - let frame; - const end = rp + this.frameBytes; - if (end <= RING_SIZE) { - frame = this.ring.subarray(rp, end); - } - else { - const first = RING_SIZE - rp; - this.ring.copy(this.swap, 0, rp, RING_SIZE); - this.ring.copy(this.swap, first, 0, this.frameBytes - first); - frame = this.swap.subarray(0, this.frameBytes); - } + else { + buf = chunk; + } + const frames = Math.floor(buf.length / this.frameBytes); + const consumed = frames * this.frameBytes; + for (let i = 0; i < frames; i++) { + const off = i * this.frameBytes; + const frame = buf.subarray(off, off + this.frameBytes); try { - if (!this.enc) - throw new Error('Encoder not ready.'); - if (this.lib.name === 'opusscript') { - this.push(this.enc.encode(frame, this.frameSize)); + let encoded; + if (this.enc.encodeInto && this.encodedScratch) { + const written = this.enc.encodeInto(frame, this.encodedScratch); + encoded = Buffer.from(this.encodedScratch.subarray(0, written)); } else { - this.push(this.enc.encode(frame)); + encoded = + this.lib.name === 'opusscript' + ? this.enc.encode(frame, this.frameSize) + : this.enc.encode(frame); } + this.push(encoded); } catch (e) { - this.writePos = wp; - this.readPos = rp; + this.leftover = null; + this.leftoverStorage = null; + if (pooledBuf) + bufferPool.release(pooledBuf); cb(e instanceof Error ? e : new Error(String(e))); return; } - rp += this.frameBytes; - if (rp >= RING_SIZE) - rp -= RING_SIZE; } - this.writePos = wp; - this.readPos = rp; + if (consumed < buf.length) { + const remaining = buf.subarray(consumed); + this.leftoverStorage = bufferPool.acquire(remaining.length); + remaining.copy(this.leftoverStorage, 0, 0, remaining.length); + this.leftover = this.leftoverStorage.subarray(0, remaining.length); + } + // Release the temporary concatenation buffer back to the pool + if (pooledBuf) + bufferPool.release(pooledBuf); cb(); } _flush(cb) { - this.writePos = 0; - this.readPos = 0; + if (this.leftover) { + if (this.leftoverStorage) + bufferPool.release(this.leftoverStorage); + this.leftover = null; + this.leftoverStorage = null; + } cb(); } _destroy(err, cb) { @@ -163,13 +165,12 @@ export class Encoder extends Transform { this.enc.delete(); } this.enc = null; - if (this.ring) { - bufferPool.release(this.ring); - this.ring = null; - } - if (this.swap) { - bufferPool.release(this.swap); - this.swap = null; + this.encodedScratch = null; + if (this.leftover) { + if (this.leftoverStorage) + bufferPool.release(this.leftoverStorage); + this.leftover = null; + this.leftoverStorage = null; } cb(err); } @@ -196,17 +197,30 @@ export class Encoder extends Transform { export class Decoder extends Transform { dec; lib; + pcmScratch; constructor({ rate = 48000, channels = 2 } = {}) { super({ readableObjectMode: false }); const { instance, lib } = _createInstance(rate, channels, 'voip'); this.dec = instance; this.lib = lib; + const maxSamplesPerChannel = Math.ceil((rate * OPUS_MAX_PACKET_DURATION_MS) / 1000); + this.pcmScratch = Buffer.allocUnsafe(maxSamplesPerChannel * channels * PCM_SAMPLE_BYTES); } _transform(chunk, _encoding, cb) { try { if (!this.dec) throw new Error('Decoder not ready.'); - this.push(this.dec.decode(chunk)); + if (this.dec.decodeInto && this.pcmScratch) { + const written = this.dec.decodeInto(chunk, this.pcmScratch); + // Copy because stream consumers may retain the chunk after this call. + // pushing it to scratch would result: + // the scratch subarray would allow the next frame to overwrite queued audio, causing corruption. + // and its also required by ownership boundary btw. + this.push(Buffer.from(this.pcmScratch.subarray(0, written))); + } + else { + this.push(this.dec.decode(chunk)); + } cb(); } catch (e) { @@ -218,6 +232,7 @@ export class Decoder extends Transform { this.dec.delete(); } this.dec = null; + this.pcmScratch = null; cb(err); } } diff --git a/dist/src/playback/player.js b/dist/src/playback/player.js index 813c3860..df97e227 100644 --- a/dist/src/playback/player.js +++ b/dist/src/playback/player.js @@ -1,17 +1,17 @@ import { PassThrough } from 'node:stream'; +import { setTimeout as sleep } from 'node:timers/promises'; import { SeekError } from '@ecliptia/seekable-stream'; import discordVoice from '@performanc/voice'; -import { EndReasons, GatewayEvents } from "../constants.js"; -import { logger } from "../utils.js"; +import { EndReasons, GatewayEvents } from '../constants.js'; +import { logger } from '../utils.js'; +import { DuckingController } from './processing/DuckingController.js'; let createAudioResource = null; let createSeekeableAudioResource = null; -const env = process.env; -const trackFinishMemoryTraceEnabled = env.NODELINK_TRACK_FINISH_MEMORY_TRACE?.toLowerCase() === 'true'; -const trackFinishForceGcEnabled = env.NODELINK_TRACK_FINISH_FORCE_GC?.toLowerCase() === 'true'; +const trackFinishMemoryTraceEnabled = process.env.NODELINK_TRACK_FINISH_MEMORY_TRACE?.toLowerCase() === 'true'; async function getStreamProcessor() { if (createAudioResource && createSeekeableAudioResource) return; - const processor = await import("./processing/streamProcessor.js"); + const processor = await import('./processing/streamProcessor.js'); createAudioResource = processor.createAudioResource; createSeekeableAudioResource = processor.createSeekeableAudioResource; @@ -38,6 +38,7 @@ export class Player { holoTrack = null; nextTrack = null; nextResource = null; + _currentResource = null; nextStreamInfo = null; isPaused = false; volumePercent; @@ -62,6 +63,7 @@ export class Player { audioMixer = null; fading; loudnessNormalizer; + duckingController = null; _fadeTimers = { trackEnd: null, pause: null, stop: null }; _isResuming = false; _pendingTrackStartFade = false; @@ -87,7 +89,13 @@ export class Player { _isStopping = false; _pausedAtPosition = undefined; stuckRecoveryCount = 0; + _positionAtRecoveryStart = 0; static MAX_STUCK_RECOVERY_ATTEMPTS = 3; + _connStateHandler = () => { }; + _connPlayHandler = () => { }; + _connErrorHandler = () => { }; + _connStuckHandler = () => { }; + _connSpeakStartHandler = () => { }; constructor(options) { if (!options.nodelink || !options.session?.socket || @@ -99,12 +107,17 @@ export class Player { this.session = options.session; this.guildId = options.guildId; this.volumePercent = this.nodelink.options?.defaultVolume ?? 100; - this.fading = this.nodelink.options?.audio?.fading; + this.fading = this.nodelink.options?.playback.audio?.fading; this.loudnessNormalizer = - this.nodelink.options?.audio?.loudnessNormalizer ?? false; + this.nodelink.options?.playback.audio?.loudnessNormalizer ?? false; + // Initialize ducking controller from config + const duckingCfg = this._resolveDuckingConfig(); + if (duckingCfg.enabled) { + this.duckingController = new DuckingController(this.guildId, duckingCfg); + } this.sponsorBlock = { - enabled: this.nodelink.options.sponsorblock?.enabled ?? false, - categories: this.nodelink.options.sponsorblock?.categories ?? [ + enabled: this.nodelink.options.playback.sponsorblock?.enabled ?? false, + categories: this.nodelink.options.playback.sponsorblock?.categories ?? [ 'sponsor', 'selfpromo', 'interaction', @@ -114,10 +127,12 @@ export class Player { 'music_offtopic', 'filler' ], - actionTypes: this.nodelink.options.sponsorblock?.actionTypes ?? ['skip'], + actionTypes: this.nodelink.options.playback.sponsorblock?.actionTypes ?? [ + 'skip' + ], segments: [], lastSkippedUuid: null, - skipMarginMs: this.nodelink.options.sponsorblock?.skipMarginMs ?? 150 + skipMarginMs: this.nodelink.options.playback.sponsorblock?.skipMarginMs ?? 150 }; logger('debug', 'Player', `New player created for guild ${this.guildId} in session ${this.session.id}`); this.emitEvent = (type, payload = {}) => { @@ -142,24 +157,32 @@ export class Player { guildId: this.guildId, player: this.toJSON() }); - this.waitEvent = (event, filter, timeout = this.nodelink.options.eventTimeoutMs ?? 15000) => new Promise((resolve, reject) => { + this.waitEvent = (event, filter, timeout = this.nodelink.options.playback.eventTimeoutMs ?? 15000) => new Promise((resolve, reject) => { + logger('debug', 'Player', `waitEvent: Started waiting for '${event}' on guild ${this.guildId} (timeout: ${timeout}ms)`); + const conn = this.connection; + if (!conn) { + logger('warn', 'Player', `waitEvent: Aborted waiting for '${event}' on guild ${this.guildId} (no connection)`); + return reject(new Error('No connection available for waitEvent')); + } const handler = (_, payload) => { const typedPayload = payload; if (!filter || filter(typedPayload)) { clearTimeout(timeoutId); - this.connection?.off(event, handler); + conn.off(event, handler); + logger('debug', 'Player', `waitEvent: Resolved '${event}' for guild ${this.guildId}`); resolve(typedPayload); } }; const timeoutId = setTimeout(() => { - this.connection?.off(event, handler); + conn.off(event, handler); + logger('warn', 'Player', `waitEvent: Timeout waiting for '${event}' on guild ${this.guildId}`); reject(new Error(`Event ${event} timed out after ${timeout}ms for guild ${this.guildId}`)); }, timeout); - this.connection?.on(event, handler); + conn.on(event, handler); }); } _getAudioOptions() { - return this.nodelink.options.audio; + return this.nodelink.options.playback.audio; } _getFilterTransitions() { return this._getAudioOptions()?.filterTransitions; @@ -173,8 +196,8 @@ export class Player { async _initAudioMixer() { if (this.audioMixer) return; - const { AudioMixer: Mixer } = await import("./processing/AudioMixer.js"); - this.audioMixer = new Mixer(this.nodelink.options?.mix ?? { + const { AudioMixer: Mixer } = await import('./processing/AudioMixer.js'); + this.audioMixer = new Mixer(this.nodelink.options?.playback.mix ?? { enabled: true, defaultVolume: 0.8, maxLayersMix: 5, @@ -216,45 +239,72 @@ export class Player { } await this._audioMixerInitPromise; } + _destroyAudioMixer() { + if (this.audioMixer) { + this.audioMixer.destroy(); + this.audioMixer = null; + } + this._audioMixerInitPromise = null; + } /** * Establishes the voice connection and attaches event listeners. */ _initConnection() { if (this.connection || this.destroying) return; + logger('debug', 'Player', `[Connection] Initializing voice connection for guild ${this.guildId} (Session: ${this.session.id})`); this.connection = discordVoice.joinVoiceChannel({ guildId: this.guildId, userId: this.session.userId, channelId: this.voice.channelId || this.guildId, - encryption: this.nodelink.options?.audio?.encryption ?? null + encryption: this.nodelink.options?.playback.audio?.encryption ?? null }); - this.connection.on('stateChange', (_, s) => { + this.connection.stuckTimeout = + Math.max(this.nodelink.options.playback.trackStuckThresholdMs ?? 10000, 30000) + 5000; + this._connStateHandler = (_, s) => { logger('debug', 'Player', `Voice connection state change for guild ${this.guildId} in session ${this.session.id}: ${s.status}`); this._onConn(s); - }); - this.connection.on('playerStateChange', (_, s) => this._onPlay(s)); - this.connection.on('error', (err) => { + }; + this.connection.on('stateChange', this._connStateHandler); + this._connPlayHandler = (_, s) => this._onPlay(s); + this.connection.on('playerStateChange', this._connPlayHandler); + this._connErrorHandler = (err) => { logger('error', 'Player', `Voice connection error for guild ${this.guildId} in session ${this.session.id}:`, err); - this._onError(err); - }); - this.connection.on('audioStream', (audioStream) => { - const dataHandler = () => { - this._lastStreamDataTime = Date.now(); - if (this.isLyricsSubscribed && !this.isPaused && this.track) { - this._syncLyrics(); + process.nextTick(() => { + if (this.destroying) + return; + const playerReason = this.connection?.playerState?.reason; + if (playerReason === 'reconnecting') { + logger('warn', 'Player', `Voice connection error for guild ${this.guildId} is a recoverable reconnection (playerState.reason=${playerReason}). Deferring to library.`); + return; } - }; - audioStream.on('data', dataHandler); - audioStream.once('close', () => { - audioStream.off('data', dataHandler); - }); - audioStream.once('end', () => { - audioStream.off('data', dataHandler); + this._onError(err); }); - }); + }; + this.connection.on('error', this._connErrorHandler); + this._connStuckHandler = () => { + if (this.destroying) + return; + logger('warn', 'Player', `Voice library detected stuck stream for guild ${this.guildId}`); + }; + this.connection.on('stuck', this._connStuckHandler); + // Automatically drain incoming voice streams to prevent memory leaks + this._connSpeakStartHandler = (_userId, ssrc) => { + if (this.destroying || !this.connection) + return; + const stream = this.connection.getSpeakStream?.(ssrc); + if (stream && !stream.destroyed) { + stream.resume(); + } + }; + this.connection.on('speakStart', this._connSpeakStartHandler); if (this.nodelink.voiceRelay?.attach) { this.nodelink.voiceRelay.attach(this.connection, this.guildId); } + // Attach ducking controller to the voice connection + if (this.duckingController && this.connection) { + this.duckingController.attach(this.connection); + } } /** * Handles connection state transitions. @@ -262,12 +312,13 @@ export class Player { _onConn(state) { if (this.destroying) return; + const previousStatus = this.connStatus; this.connStatus = state.status; if (state.status === 'connected') { logger('info', 'Player', `Voice connection established for guild ${this.guildId} in session ${this.session.id}`); this.emitEvent(GatewayEvents.PLAYER_CONNECTED, { guildId: this.guildId, - voice: { ...this.voice } + voice: structuredClone(this.voice) }); if (this.track && this.isPaused && this.connection?.audioStream) { this.isPaused = false; @@ -275,17 +326,31 @@ export class Player { logger('debug', 'Player', `Unpaused track on reconnection for guild ${this.guildId}`); } } - else if (state.status === 'reconnecting') { - logger('info', 'Player', `Voice connection is reconnecting for guild ${this.guildId}`); - this.emitEvent(GatewayEvents.PLAYER_RECONNECTING, { - guildId: this.guildId, - voice: { ...this.voice } - }); + else if (state.status === 'connecting') { + if (previousStatus !== 'disconnected' || this.connection?.audioStream) { + logger('info', 'Player', `Voice connection is reconnecting for guild ${this.guildId}`); + this.emitEvent(GatewayEvents.PLAYER_RECONNECTING, { + guildId: this.guildId, + voice: structuredClone(this.voice) + }); + } } else if (state.status === 'disconnected') { + const reason = state.reason; + if (reason === 'reconnect_circuit_breaker') { + logger('error', 'Player', `Voice connection circuit breaker triggered for guild ${this.guildId}. Too many reconnection attempts.`); + this.emitEvent(GatewayEvents.TRACK_EXCEPTION, { + track: this.track, + exception: { + message: 'Voice reconnection circuit breaker triggered', + severity: 'fault', + cause: 'RECONNECT_CIRCUIT_BREAKER' + } + }); + } this.emitEvent(GatewayEvents.WEBSOCKET_CLOSED, { code: state.code, - reason: state.closeReason, + reason: state.closeReason ?? state.reason, byRemote: true }); } @@ -316,7 +381,8 @@ export class Player { } if (state.status === 'idle' && state.reason === 'stuck') { logger('warn', 'Player', `Track became stuck for guild ${this.guildId}. Triggering immediate recovery.`); - this._stuckTime = this.nodelink.options.trackStuckThresholdMs + 1; + this._stuckTime = + (this.nodelink.options.playback.trackStuckThresholdMs ?? 0) + 1; this._sendUpdate(); return; } @@ -349,7 +415,22 @@ export class Player { this._lyricsBasePosition = 0; this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0; - this.connection?.play(resource); + const oldStream = this.connection?.play(resource); + if (oldStream) + oldStream.destroy(); + if (this._currentResource && this._currentResource !== resource) { + try { + this._currentResource.destroy(); + } + catch { } + } + this._currentResource = resource; + if (this.duckingController && this.connection && resource.fadeTo) { + this.duckingController.attach(this.connection); + this.duckingController.setStreamControl({ + fadeTo: (volume, durationMs, curve) => resource.fadeTo?.(volume, durationMs, curve) + }); + } return; } if ((this.isUpdatingTrack || this._isSeeking) && @@ -363,17 +444,17 @@ export class Player { this._emitTrackEnd(endReason); this._resetTrack(); this._traceTrackFinishMemory('after-reset'); - this._scheduleTrackFinishGcProbe(); } else if (state.status === 'playing' && this.track && !this._isSeeking && - (['requested', 'reconnected', 'seamless_bridge'].includes(state.reason ?? '') || + (['requested', 'reconnected', 'unpaused'].includes(state.reason ?? '') || this._pendingTrackStartFade)) { const wasResuming = this._isResuming; this._isResuming = false; this.isPaused = false; - if (wasResuming && state.reason !== 'seamless_bridge') { + this._lastStreamDataTime = Date.now(); + if (wasResuming) { this._fading('trackEndSchedule', { startPosition: this._pausedAtPosition ?? this._realPosition() }); @@ -386,9 +467,17 @@ export class Player { this._emitTrackStart().catch((err) => this._onError(err)); } } - else if (state.status === 'paused') { + else if (state.status === 'idle' && + (state.reason === 'paused' || state.reason === 'requested')) { this.isPaused = true; } + else if (state.status === 'idle' && state.reason === 'reconnecting') { + logger('info', 'Player', `Voice library reports reconnecting for guild ${this.guildId}`); + this.emitEvent(GatewayEvents.PLAYER_RECONNECTING, { + guildId: this.guildId, + voice: structuredClone(this.voice) + }); + } } /** * Handles playback errors and emits exception events. @@ -468,9 +557,12 @@ export class Player { this.position = 0; this._pausedAtPosition = undefined; this._lastStreamDataTime = 0; + this.streamInfo = null; + this.sponsorBlock.segments = []; this.currentLyrics = null; this.lyricsLineIndex = -1; this._fading('reset'); + this._destroyAudioMixer(); this._lyricsBasePosition = 0; this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0; if (this._lyricsMarkerTimer) { @@ -492,43 +584,66 @@ export class Player { * Destroys and dereferences current audio stream to avoid lingering references. */ _cleanupCurrentAudioStream(context) { + logger('debug', 'Player', `[Cleanup] Triggering stream cleanup for guild ${this.guildId}. Context: ${context}`); const conn = this.connection; + const mls = this.connection?.mlsSession; + if (mls?._pendingKeyPackage) + mls._pendingKeyPackage = null; const audioStream = conn?.audioStream; - if (!audioStream) + if (this.duckingController) { + this.duckingController.setStreamControl(null); + this.duckingController.detach(); + } + if (this._currentResource) { + try { + this._currentResource.destroy(); + } + catch (err) { + logger('debug', 'Player', `Resource destroy failed during ${context} for guild ${this.guildId}: ${err?.message ?? String(err)}`); + } + this._currentResource = null; + } + if (!audioStream) { return; + } try { audioStream._cleanupListeners?.(); } catch { // Ignore cleanup errors } + if (audioStream.destroyed) { + if (conn) + conn.audioStream = null; + return; + } try { audioStream.destroy?.(); + if (Array.isArray(audioStream.pipes)) { + for (const pipe of audioStream.pipes) { + pipe.destroy?.(); + } + } + conn?.udp?.flush?.(); } catch (err) { logger('debug', 'Player', `Failed to destroy audio stream during ${context} for guild ${this.guildId}: ${err?.message ?? String(err)}`); } - if (conn) - conn.audioStream = null; + finally { + if (conn) + conn.audioStream = null; + } } - /** - * Optionally runs forced GC after finish for leak diagnostics. - */ - _scheduleTrackFinishGcProbe() { - if (!trackFinishForceGcEnabled) + _cleanupSSRCStreams(conn) { + if (!conn?.ssrcs) return; - const gcFn = global.gc; - if (typeof gcFn !== 'function') - return; - const timer = setTimeout(() => { - try { - gcFn(); - gcFn(); + for (const entry of conn.ssrcs.values()) { + const s = entry?.stream; + if (s && !s.destroyed) { + s.resume(); + s.destroy?.(); } - catch { } - this._traceTrackFinishMemory('after-gc'); - }, 0); - timer.unref?.(); + } } /** * Emits TRACK_START and related events after resolving Holo tracks. @@ -592,7 +707,7 @@ export class Player { async _resolveTrackForEvent(track) { if (!track) return null; - if (!this.nodelink.options.enableHoloTracks) { + if (!this.nodelink.options.experimental.enableHoloTracks) { return track; } try { @@ -600,8 +715,8 @@ export class Player { const resolveHoloTrack = source?.resolveHoloTrack; if (typeof resolveHoloTrack === 'function') { const holoTrack = await resolveHoloTrack.call(source, track, { - fetchChannelInfo: this.nodelink.options.fetchChannelInfo, - resolveExternalLinks: this.nodelink.options.resolveExternalLinks + fetchChannelInfo: this.nodelink.options.search.fetchChannelInfo, + resolveExternalLinks: this.nodelink.options.search.resolveExternalLinks }); return holoTrack || track; } @@ -649,7 +764,7 @@ export class Player { * Fetches an audio resource for playback. */ async _fetchResource(info, urlData, startTime) { - if (this.nodelink.options?.mix?.enabled !== false) { + if (this.nodelink.options?.playback.mix?.enabled !== false) { await this._ensureAudioMixer(); } await getStreamProcessor(); @@ -658,28 +773,36 @@ export class Player { return { exception: { message: 'Stream processor not initialized' } }; } const additionalData = { - ...urlData.additionalData + ...urlData.additionalData, + ...(startTime !== undefined ? { startTime, position: startTime } : {}), + guildId: this.guildId, + positionCallback: (positionMs) => { + if (!Number.isFinite(positionMs) || positionMs < 0) + return; + this.position = positionMs; + }, + // specific to sabr protocol for now + playbackPaused: () => this.isPaused }; - if (startTime !== undefined) { - additionalData.startTime = startTime; - // Keep both keys for source compatibility while seek handling is unified. - additionalData.position = startTime; - } - additionalData.guildId = this.guildId; - additionalData.positionCallback = (positionMs) => { - if (!Number.isFinite(positionMs) || positionMs < 0) - return; - this.position = positionMs; + const resolvedUrlData = { + ...urlData, + additionalData }; - urlData.additionalData = additionalData; - const track = urlData?.newTrack - ? urlData?.newTrack?.info + const track = resolvedUrlData?.newTrack + ? resolvedUrlData?.newTrack?.info : info; - const fetched = await this.nodelink.sources.getTrackStream(track, urlData.url, urlData.protocol, additionalData); - if (fetched.exception) + logger('debug', 'Player', `Fetching stream resource from source for guild ${this.guildId}`, { + source: track.sourceName, + url: resolvedUrlData.url + }); + const fetched = await this.nodelink.sources.getTrackStream(track, resolvedUrlData.url, resolvedUrlData.protocol, additionalData); + if (fetched.exception) { + logger('error', 'Player', `Stream resource fetch failed for guild ${this.guildId}`, fetched.exception); return fetched; + } + logger('debug', 'Player', `Successfully fetched stream resource for guild ${this.guildId}`); const fetchedStream = fetched.stream; - const totalBytesRaw = urlData.additionalData?.contentLength ?? null; + const totalBytesRaw = resolvedUrlData.additionalData?.contentLength ?? null; const totalBytesNum = Number(totalBytesRaw); this.profilerStreamStats = { downloadedBytes: 0, @@ -704,6 +827,17 @@ export class Player { streamForResource = fetchedStream.pipe(profilerTap); profilerTap._sourceStream = fetchedStream; + const seekControl = fetchedStream; + const beginSeekHandoff = seekControl.beginSeekHandoff; + if (beginSeekHandoff) { + ; + profilerTap.beginSeekHandoff = () => beginSeekHandoff(); + } + const cancelSeekHandoff = seekControl.cancelSeekHandoff; + if (cancelSeekHandoff) { + ; + profilerTap.cancelSeekHandoff = () => cancelSeekHandoff(); + } const eternalboxHandler = (data) => { this.emitEvent(GatewayEvents.ETERNALBOX_JUMP, { track: this.holoTrack || this.track, @@ -718,17 +852,39 @@ export class Player { }; eventStream.on?.('eternalboxJump', eternalboxHandler); eventStream.on?.('icyMetadata', icyHandler); + let listenersCleaned = false; const cleanupListeners = () => { + if (listenersCleaned) + return; + listenersCleaned = true; eventStream.off?.('eternalboxJump', eternalboxHandler); eventStream.off?.('icyMetadata', icyHandler); profilerTap.off('data', profilerHandler); - profilerTap.destroy(); + streamForResource.off('close', cleanupListeners); + streamForResource.off('error', cleanupListeners); + streamForResource.off('end', cleanupListeners); + const src = profilerTap + ._sourceStream; + if (src && !src.destroyed) { + try { + src.destroy(); + } + catch { } + } + delete profilerTap._sourceStream; + if (!profilerTap.destroyed) { + try { + profilerTap.destroy(); + } + catch { } + } }; streamForResource.on('close', cleanupListeners); streamForResource.on('error', cleanupListeners); + streamForResource.on('end', cleanupListeners); streamForResource._cleanupListeners = cleanupListeners; } - const resource = audioResourceFactory(this.guildId, streamForResource, fetched.type || urlData.format, this.nodelink, this.filters, this.volumePercent / 100, this.audioMixer, false, this.loudnessNormalizer); + const resource = audioResourceFactory(this.guildId, streamForResource, fetched.type || resolvedUrlData.format, this.nodelink, this.filters, this.volumePercent / 100, this.audioMixer, false, this.loudnessNormalizer); return { stream: resource }; } /** @@ -743,11 +899,12 @@ export class Player { const position = this._realPosition(); if (this.sponsorBlock.enabled && this.track) { // Periodic log to verify position and sb state - if (Math.abs(position - this._lastPosition) > 1000 || this._lastPosition === 0) { + if (Math.abs(position - this._lastPosition) > 1000 || + this._lastPosition === 0) { logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Current position: ${Math.round(position)}ms, Segments: ${this.sponsorBlock.segments.length}, LastSkipped: ${this.sponsorBlock.lastSkippedUuid}`); } } - const threshold = this.nodelink.options.trackStuckThresholdMs; + const threshold = this.nodelink.options.playback.trackStuckThresholdMs ?? 0; if (threshold > 0 && !this.isUpdatingTrack && !this._isStopping && @@ -755,12 +912,19 @@ export class Player { !this._isResuming && !this.isPaused) { if (this._lastPosition === position) { - this._stuckTime += this.nodelink.options.playerUpdateInterval; + this._stuckTime += + this.nodelink.options.playback.playerUpdateInterval ?? 0; if (this._stuckTime >= threshold && !this._isRecovering && this.connStatus === 'connected') { const stuckTime = this._stuckTime; this._stuckTime = 0; + const pipelineStream = this._getAudioStream(); + if (pipelineStream?.isPipelineFinished?.()) { + logger('debug', 'Player', `Player for guild ${this.guildId} is starving but the network stream has finished. Treating as natural trackEnd.`); + this.connection.stop(EndReasons.FINISHED); + return false; + } if (this.streamInfo?.format === 'mp4') { logger('error', 'Player', `Player for guild ${this.guildId} is stuck on an MP4 track. Emitting TRACK_STUCK without recovery.`); this.emitEvent(GatewayEvents.TRACK_STUCK, { @@ -799,12 +963,10 @@ export class Player { const endThreshold = playbackSpeed < 1.0 ? 5000 : 2000; if (trackLength > 0 && position >= trackLength - endThreshold) { logger('debug', 'Player', `Player for guild ${this.guildId} is near track end (${position}/${trackLength}ms). Treating as natural finish instead of stuck.`); - this._emitTrackEnd(EndReasons.FINISHED); - this._resetTrack(); + this.connection.stop(EndReasons.FINISHED); return false; } - if (this.stuckRecoveryCount >= - Player.MAX_STUCK_RECOVERY_ATTEMPTS) { + if (this.stuckRecoveryCount >= Player.MAX_STUCK_RECOVERY_ATTEMPTS) { logger('error', 'Player', `Player for guild ${this.guildId} exceeded max recovery attempts (${Player.MAX_STUCK_RECOVERY_ATTEMPTS}). Stopping track.`); this.emitEvent(GatewayEvents.TRACK_STUCK, { guildId: this.guildId, @@ -828,7 +990,13 @@ export class Player { }); this._isRecovering = true; this.stuckRecoveryCount++; - this.seek(this._lastPosition, this.track.endTime, true) + this._positionAtRecoveryStart = position; + if (this.track.info.identifier && this.track.info.sourceName) { + this.nodelink.trackCacheManager?.delete(this.track.info.sourceName, this.track.info.identifier); + } + const isStream = this.track.info.isStream; + const recoveryPosition = isStream ? 0 : this._lastPosition; + this.seek(recoveryPosition, this.track.endTime, true) .then((success) => { if (success) { logger('info', 'Player', `Player for guild ${this.guildId} recovered successfully.`); @@ -865,8 +1033,12 @@ export class Player { } if (position !== this._lastPosition) { this._lastStreamDataTime = Date.now(); - if (this.stuckRecoveryCount > 0) - this.stuckRecoveryCount = 0; + if (this.stuckRecoveryCount > 0) { + const meaningfulAdvance = 2000; + if (position - this._positionAtRecoveryStart >= meaningfulAdvance) { + this.stuckRecoveryCount = 0; + } + } } this._lastPosition = position; this._syncLyrics(); @@ -890,16 +1062,19 @@ export class Player { if (success) { logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Successfully jumped to ${segment.end}ms`); this.emitEvent(GatewayEvents.SPONSORBLOCK_SEGMENT_SKIPPED, { - segment, - skippedMs + track: this.track, + segment }); } else { logger('warn', 'Player', `[SponsorBlock][${this.guildId}] Failed to jump to ${segment.end}ms for segment ${segment.uuid}`); + // fallback: temporarily mute or un-stick if it fails + this.sponsorBlock.lastSkippedUuid = null; } }) .catch((err) => { logger('error', 'Player', `[SponsorBlock][${this.guildId}] Error while seeking to segment end:`, err); + this.sponsorBlock.lastSkippedUuid = null; }); return true; } @@ -913,7 +1088,9 @@ export class Player { time: Date.now(), position, connected: this.connStatus === 'connected', - ping: this.connection.ping ?? 0 + ping: this.connection && this.connection.ping >= 0 + ? this.connection.ping + : 0 } })); return true; @@ -921,75 +1098,93 @@ export class Player { /** * Starts playback for the current track. */ - async _startPlayback(startTime = 0) { + async _connectAndPlayStream(urlData, position, cleanupReason, fadingAction, playLogMessage) { if (!this.track) return false; - const trackInfo = { - ...this.track.info, - audioTrackId: this.track.audioTrackId - }; - const urlData = await this.nodelink.sources.getTrackUrl(trackInfo, undefined, this._isRecovering); - const urlDataWithFormats = urlData; - if (!this.track) - return false; - this.streamInfo = { ...urlData, trackInfo: this.track.info }; - logger('debug', 'Player', `Got track URL for guild ${this.guildId}`, { - urlData: { - ...urlData, - formats: urlDataWithFormats.formats - ? `[${urlDataWithFormats.formats.length} format(s) omitted]` - : undefined - } - }); - if (urlData.exception) { - const err = new Error(urlData.exception.message); - this._onError(err); - return false; - } if (!this.connection) { this._initConnection(); } if (!this.connection?.udpInfo?.secretKey) { logger('debug', 'Player', `Waiting for voice connection to be ready for guild ${this.guildId}`); - await this.waitEvent('stateChange', (s) => s.status === 'connected' && !!this.connection?.udpInfo?.secretKey); + try { + await this.waitEvent('stateChange', (s) => s.status === 'connected' && !!this.connection?.udpInfo?.secretKey); + } + catch (err) { + logger('warn', 'Player', `Timeout or error while waiting for voice connection on guild ${this.guildId}:`, err); + } } if (!this.connection?.udpInfo?.secretKey) { - logger('error', 'Player', `Voice connection for guild ${this.guildId} is not ready, cannot start playback.`); - this._onError(new Error('Voice connection is not ready.')); + const errorMessage = `Voice connection for guild ${this.guildId} is not ready (missing UDP info). Aborting playback.`; + logger('error', 'Player', errorMessage); + this._onError(new Error(errorMessage)); return false; } - const fetched = await this._fetchResource(this.track.info, urlData, startTime); + const fetched = await this._fetchResource(this.track.info, urlData, position); if ('exception' in fetched) { const err = new Error(fetched.exception.message); this._onError(err); return false; } - this._cleanupCurrentAudioStream('start-playback'); + this._cleanupCurrentAudioStream(cleanupReason); const resource = fetched.stream; if (this.volumePercent !== 100) { resource.setVolume(this.volumePercent / 100); } - this._fading('trackStartArm', { resource }); - this._fading('trackEndSchedule', { startPosition: startTime || 0 }); + this._fading(fadingAction, { resource }); this.setFilters(this.filters); - logger('debug', 'Player', `Playing resource for guild ${this.guildId}`); - this._stuckTime = 0; + logger('debug', 'Player', playLogMessage); + this._currentResource = resource; this.connection.play(resource); + // Connect ducking controller to the new audio stream + if (this.duckingController && resource.fadeTo) { + this.duckingController.attach(this.connection); + this.duckingController.setStreamControl({ + fadeTo: (volume, durationMs, curve) => resource.fadeTo?.(volume, durationMs, curve) + }); + } await this.waitEvent('playerStateChange', (s) => s.status === 'playing'); - this._lyricsBasePosition = startTime || 0; + this._lyricsBasePosition = position; this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0; + return true; + } + async _startPlayback(startTime = 0) { + if (!this.track) + return false; + const trackInfo = { + ...this.track.info, + audioTrackId: this.track.audioTrackId + }; + const urlData = await this.nodelink.sources.getTrackUrl(trackInfo, undefined, this._isRecovering); + if (!this.track) + return false; + this.streamInfo = { ...urlData, trackInfo: this.track.info }; + logger('debug', 'Player', `Got track URL for guild ${this.guildId}`, { + urlData + }); + if (urlData.exception) { + const err = new Error(urlData.exception.message); + this._onError(err); + return false; + } + const result = await this._connectAndPlayStream(urlData, startTime, 'start-playback', 'trackStartArm', `Playing resource for guild ${this.guildId}`); + if (!result) + return false; + this._fading('trackEndSchedule', { startPosition: startTime || 0 }); + this._stuckTime = 0; if (this.track.info.sourceName === 'youtube' || this.track.info.sourceName === 'ytmusic') { this.sponsorBlock.segments = []; this.sponsorBlock.lastSkippedUuid = null; const videoId = this.track.info.identifier; - const sbConfig = this.nodelink.options.sponsorblock; + const sbConfig = this.nodelink.options.playback.sponsorblock; if (this.sponsorBlock.enabled) { logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Initiating segment fetch for video ${videoId}`); - const { fetchSponsorBlockSegments } = await import("../utils.js"); + const { fetchSponsorBlockSegments } = await import('../utils.js'); fetchSponsorBlockSegments(videoId, this.sponsorBlock.categories, this.sponsorBlock.actionTypes, sbConfig?.api) .then((segments) => { - if (this.destroying || !this.track || this.track.info.identifier !== videoId) { + if (this.destroying || + !this.track || + this.track.info.identifier !== videoId) { logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Ignoring fetched segments for ${videoId} (track changed or player destroyed)`); return; } @@ -1023,6 +1218,7 @@ export class Player { * @returns True when the request is accepted (actual start is async). */ async play({ encoded, info, userData, audioTrackId, noReplace = false, startTime, endTime = 0 }) { + logger('debug', 'Player', `[Action: play] Method invoked for guild ${this.guildId} with track ${info.identifier}`); return new Promise((resolve) => { this.isUpdatingTrack = true; try { @@ -1087,10 +1283,20 @@ export class Player { * @returns True when the seek succeeds; false otherwise. */ async seek(position, endTime, forceLegacy = false) { - if (this.destroying || !this.track) + logger('debug', 'Player', `[Action: seek] Method invoked for guild ${this.guildId} with target position: ${position}ms`); + if (this.destroying || !this.track) { + logger('debug', 'Player', `[Action: seek] Aborted for guild ${this.guildId}: destroying=${this.destroying}, hasTrack=${!!this.track}`); return false; + } if (!this.track.info.isSeekable && !this.track.info.isStream) return false; + const streamFormat = typeof this.streamInfo?.format === 'string' + ? this.streamInfo.format.toLowerCase() + : ''; + if (streamFormat.includes('flac')) { + logger('warn', 'Player', `Seeking not supported for FLAC stream on guild ${this.guildId}`); + return false; + } const seekPosition = position ?? this._realPosition(); if (seekPosition === 0 && !this._isRecovering && @@ -1110,7 +1316,6 @@ export class Player { let seekPromise; if (!this.streamInfo?.url) { logger('debug', 'Player', 'No stream info URL available for seek. awaiting getTrackUrl.'); - const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); await sleep(1600); if (!this.streamInfo?.url) { logger('debug', 'Player', 'Still no stream info URL available for seek.'); @@ -1130,7 +1335,7 @@ export class Player { logger('debug', 'Player', 'Stream info URL became available during wait.'); } } - const source = this.nodelink.sources.getSource(sourceName); + const source = this.nodelink.sources.getSource(resolvedSourceName); const hasSourceLoader = source && typeof source.loadStream === 'function'; const canNativeSeek = !!hasSourceLoader && (this.streamInfo?.protocol === 'sabr' || @@ -1168,6 +1373,11 @@ export class Player { } return result; } + catch (e) { + logger('error', 'Player', `Seek failed for guild ${this.guildId}`, e); + this._onError(e); + return false; + } finally { this._isSeeking = false; } @@ -1181,26 +1391,27 @@ export class Player { logger('debug', 'Player', `Seeking using source (native) to ${position}ms for guild ${this.guildId}`); this.position = position; this.track.endTime = endTime; - let previousSession = null; let reuseUrlData = null; + let seekHandoff = null; if (this.streamInfo?.protocol === 'sabr' && this.connection?.audioStream) { - const inputStream = this.connection.audioStream - ?.pipes?.[0]; - if (inputStream && typeof inputStream.getSessionState === 'function') { - previousSession = inputStream.getSessionState(); - if (previousSession) { - logger('debug', 'Player', `Extracted SABR session state: rn=${previousSession.requestNumber}, hasCookie=${!!previousSession.nextRequestPolicy?.playbackCookie}`); - reuseUrlData = { - protocol: this.streamInfo.protocol, - url: this.streamInfo.url, - additionalData: { - ...this.streamInfo.additionalData, - previousSession, - startTime: position - } - }; - logger('debug', 'Player', `Reusing existing SABR streaming URL for seek to maintain session`); - } + const inputStream = this.connection.audioStream?.pipes?.[0]; + const previousSession = await inputStream?.beginSeekHandoff?.(); + if (previousSession) { + seekHandoff = inputStream?.cancelSeekHandoff + ? { cancelSeekHandoff: inputStream.cancelSeekHandoff } + : null; + logger('debug', 'Player', `Extracted SABR session state: rn=${previousSession.requestNumber}, hasCookie=${!!previousSession.nextRequestPolicy?.playbackCookie}`); + reuseUrlData = { + newTrack: this.streamInfo.newTrack, + protocol: this.streamInfo.protocol, + url: this.streamInfo.url, + additionalData: { + ...this.streamInfo.additionalData, + previousSession, + startTime: position + } + }; + logger('debug', 'Player', `Reusing existing SABR streaming URL for seek to maintain session`); } } const trackInfo = { @@ -1210,47 +1421,27 @@ export class Player { const urlData = reuseUrlData || (await this.nodelink.sources.getTrackUrl(trackInfo)); this.streamInfo = { ...urlData, trackInfo: this.track.info }; if (urlData.exception) { + seekHandoff?.cancelSeekHandoff(); const err = new Error(urlData.exception.message); this._onError(err); return false; } - if (!this.connection) { - this._initConnection(); - } - if (!this.connection?.udpInfo?.secretKey) { - await this.waitEvent('stateChange', (s) => s.status === 'connected' && !!this.connection?.udpInfo?.secretKey); - } - if (!this.connection?.udpInfo?.secretKey) { - const errorMessage = `Voice connection for guild ${this.guildId} is not ready (missing UDP info). Aborting playback.`; - logger('error', 'Player', errorMessage); - this._onError(new Error(errorMessage)); - return false; - } - const fetched = await this._fetchResource(this.track.info, urlData, position); - if ('exception' in fetched) { - const err = new Error(fetched.exception.message); - this._onError(err); - return false; + try { + const result = await this._connectAndPlayStream(urlData, position, 'source-seek', 'seekPrepare', `Playing resource for guild ${this.guildId} after source seek`); + if (!result) + seekHandoff?.cancelSeekHandoff(); + return result; } - this._cleanupCurrentAudioStream('source-seek'); - const resource = fetched.stream; - if (this.volumePercent !== 100) { - resource.setVolume(this.volumePercent / 100); + catch (error) { + seekHandoff?.cancelSeekHandoff(); + throw error; } - this._fading('seekPrepare', { resource }); - this.setFilters(this.filters); - logger('debug', 'Player', `Playing resource for guild ${this.guildId} after source seek`); - this.connection.play(resource); - await this.waitEvent('playerStateChange', (s) => s.status === 'playing'); - this._lyricsBasePosition = position; - this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0; - return true; } /** * Seeks using seekable-stream helper for compatible sources. */ async _seekeableSeek(position, endTime) { - if (this.nodelink.options?.mix?.enabled !== false) { + if (this.nodelink.options?.playback.mix?.enabled !== false) { await this._ensureAudioMixer(); } await getStreamProcessor(); @@ -1286,6 +1477,13 @@ export class Player { if (oldStream) { oldStream.destroy(); } + if (this._currentResource && this._currentResource !== resource) { + try { + this._currentResource.destroy(); + } + catch { } + } + this._currentResource = resource; this._lyricsBasePosition = position; this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0; @@ -1358,7 +1556,15 @@ export class Player { this._fading('seekPrepare', { resource }); this.setFilters(this.filters); logger('debug', 'Player', `Playing resource for guild ${this.guildId} after legacy seek`); + this._currentResource = resource; this.connection.play(resource); + // Connect ducking controller to the new audio stream + if (this.duckingController && resource.fadeTo) { + this.duckingController.attach(this.connection); + this.duckingController.setStreamControl({ + fadeTo: (volume, durationMs, curve) => resource.fadeTo?.(volume, durationMs, curve) + }); + } await this.waitEvent('playerStateChange', (s) => s.status === 'playing'); this._lyricsBasePosition = position; this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0; @@ -1370,10 +1576,13 @@ export class Player { * @returns True when stop was executed; false when no active track. */ stop() { + logger('debug', 'Player', `[Action: stop] Executing stop for guild ${this.guildId}`); this.isUpdatingTrack = true; try { - if (this.destroying || !this.track) + if (this.destroying || !this.track) { + logger('debug', 'Player', `[Action: stop] Aborted for guild ${this.guildId}: destroying=${this.destroying}, hasTrack=${!!this.track}`); return false; + } if (this.nextResource) { this.nextResource.destroy(); this.nextResource = null; @@ -1410,8 +1619,11 @@ export class Player { * @returns True when preload succeeded. */ async preload(payload) { - if (this.destroying) + logger('debug', 'Player', `[Action: preload] Method invoked for guild ${this.guildId} with track ${payload.info.identifier}`); + if (this.destroying) { + logger('debug', 'Player', `[Action: preload] Aborted for guild ${this.guildId}: player is destroying`); return false; + } const sameEncoded = !!payload.encoded && !!this.nextTrack?.encoded && this.nextTrack.encoded === payload.encoded; @@ -1465,6 +1677,7 @@ export class Player { * @returns True when state was cleared. */ clearNextTrack() { + logger('debug', 'Player', `[Action: clearNextTrack] Method invoked for guild ${this.guildId}`); if (this.destroying) return false; if (this.nextResource) { @@ -1482,8 +1695,11 @@ export class Player { * @returns True when state changed; false otherwise. */ pause(shouldPause) { - if (this.destroying || this.isPaused === shouldPause) + logger('debug', 'Player', `[Action: pause] Method invoked for guild ${this.guildId} with target: ${shouldPause}`); + if (this.destroying || this.isPaused === shouldPause) { + logger('debug', 'Player', `[Action: pause] Aborted for guild ${this.guildId}: destroying=${this.destroying}, alreadyPaused=${this.isPaused === shouldPause}`); return false; + } logger('debug', 'Player', `Setting pause to ${shouldPause} for guild ${this.guildId}`); if (shouldPause) { this._pausedAtPosition = this._realPosition(); @@ -1515,8 +1731,11 @@ export class Player { * @returns True when volume was updated. */ volume(level) { - if (this.destroying) + logger('debug', 'Player', `[Action: volume] Method invoked for guild ${this.guildId} with target: ${level}`); + if (this.destroying) { + logger('debug', 'Player', `[Action: volume] Aborted for guild ${this.guildId}: player is destroying`); return false; + } logger('debug', 'Player', `Setting volume to ${level} for guild ${this.guildId}`); this.volumePercent = Math.max(0, Math.min(1000, level)); this.connection?.audioStream?.setVolume(this.volumePercent / 100); @@ -1531,6 +1750,7 @@ export class Player { * @returns Always true. */ setFading(config) { + logger('debug', 'Player', `[Action: setFading] Method invoked for guild ${this.guildId}`); this.fading = config; return true; } @@ -1541,12 +1761,67 @@ export class Player { * @returns True when updated. */ setLoudnessNormalizer(enabled) { + logger('debug', 'Player', `[Action: setLoudnessNormalizer] Method invoked for guild ${this.guildId} to ${enabled}`); this.loudnessNormalizer = !!enabled; if (this.connection?.audioStream) { this.connection.audioStream.setLoudnessNormalizer?.(this.loudnessNormalizer); } return true; } + /** + * Resolves the ducking configuration from the fading config or global config. + * + * @returns Resolved ducking configuration. + */ + _resolveDuckingConfig() { + const fadingDucking = this.fading?.ducking; + const configDucking = this.nodelink.options?.playback?.audio?.fading?.ducking; + const source = fadingDucking ?? configDucking; + return { + enabled: source?.enabled ?? false, + duration: source?.duration ?? 500, + targetVolume: source?.targetVolume ?? 0.15, + curve: source?.curve ?? 'linear' + }; + } + /** + * Toggles auto-ducking (lowers music volume when users speak). + * + * @param enabled - Whether to enable auto-ducking. + * @returns True when updated. + */ + setDucking(enabled) { + logger('debug', 'Player', `[Action: setDucking] Method invoked for guild ${this.guildId} to ${enabled}`); + if (enabled) { + const duckingCfg = this._resolveDuckingConfig(); + duckingCfg.enabled = true; + if (!this.duckingController) { + this.duckingController = new DuckingController(this.guildId, duckingCfg); + } + else { + this.duckingController.updateConfig(duckingCfg); + } + // Attach to current connection if available + if (this.connection) { + this.duckingController.attach(this.connection); + } + // Connect to current audio stream if available + if (this.connection?.audioStream?.fadeTo) { + const stream = this.connection.audioStream; + this.duckingController.setStreamControl({ + fadeTo: (volume, durationMs, curve) => stream.fadeTo?.(volume, durationMs, curve) + }); + } + } + else { + if (this.duckingController) { + this.duckingController.detach(); + this.duckingController.destroy(); + this.duckingController = null; + } + } + return true; + } /** * Applies audio filters to the active stream. * @@ -1554,8 +1829,11 @@ export class Player { * @returns True when filters applied; false if player inactive. */ setFilters(filters) { - if (this.destroying || !this.track) + logger('debug', 'Player', `[Action: setFilters] Method invoked for guild ${this.guildId}`); + if (this.destroying || !this.track) { + logger('debug', 'Player', `[Action: setFilters] Aborted for guild ${this.guildId}: destroying=${this.destroying}, hasTrack=${!!this.track}`); return false; + } logger('debug', 'Player', `Applying filters for guild ${this.guildId}:`, filters); const payload = filters.filters ?? filters; @@ -1688,6 +1966,7 @@ export class Player { * @param force - Forces reconnect even when unchanged. */ updateVoice(voicePayload = {}, force = false) { + logger('debug', 'Player', `[Action: updateVoice] Method invoked for guild ${this.guildId} with force=${force}`); if (this.destroying) return; const { sessionId, token, endpoint, channelId } = voicePayload; @@ -1716,13 +1995,17 @@ export class Player { logger('debug', 'Player', `Updating voice state for guild ${this.guildId}`); if (!this.connection) this._initConnection(); - if (this.voice.channelId && this.connection) { - this.connection.channelId = this.voice.channelId; + this.connection?.voiceStateUpdate({ + session_id: this.voice.sessionId, + channel_id: this.voice.channelId ?? undefined + }); + if (force && this.connection?.voiceServer) { + this.connection.voiceServer = null; } - this.connection?.voiceStateUpdate({ session_id: this.voice.sessionId }); this.connection?.voiceServerUpdate({ token: this.voice.token, - endpoint: this.voice.endpoint + endpoint: this.voice.endpoint, + channel_id: this.voice.channelId ?? undefined }); this.connection?.connect(async () => { if (this.destroying) @@ -1734,7 +2017,9 @@ export class Player { !this.connection?.audioStream && !this.isUpdatingTrack) { logger('debug', 'Player', `Voice state updated for guild ${this.guildId}, starting pending track.`); - await this._startPlayback(); + await this._startPlayback().catch((err) => { + logger('error', 'Player', `Failed to start pending track during voice update for guild ${this.guildId}:`, err); + }); } }); } @@ -1748,17 +2033,30 @@ export class Player { * @param emitClose - Whether to emit WEBSOCKET_CLOSED to the client. */ destroy(emitClose = true) { + logger('debug', 'Player', `[Action: destroy] Method invoked for guild ${this.guildId} with emitClose=${emitClose}`); if (this.destroying) return; this.destroying = true; - logger('debug', 'Player', `Destroying player for guild ${this.guildId}`); if (this.connection) { try { + this.connection.removeListener('stateChange', this._connStateHandler); + this.connection.removeListener('playerStateChange', this._connPlayHandler); + this.connection.removeListener('error', this._connErrorHandler); + this.connection.removeListener('stuck', this._connStuckHandler); + this.connection.removeListener('speakStart', this._connSpeakStartHandler); + if (this.nodelink.voiceRelay?.detach) { + this.nodelink.voiceRelay.detach(this.connection); + } if (this.connection.audioStream) { this.connection.stop(EndReasons.CLEANUP); this._cleanupCurrentAudioStream('destroy'); } + this._cleanupSSRCStreams(this.connection); this.connection.destroy(); + if (this.duckingController) { + this.duckingController.destroy(); + this.duckingController = null; + } this.connection = null; } catch (err) { @@ -1776,6 +2074,14 @@ export class Player { this.emitEvent(GatewayEvents.PLAYER_DESTROYED, { guildId: this.guildId }); + this._destroyAudioMixer(); + if (this._currentResource) { + try { + this._currentResource.destroy(); + } + catch { } + this._currentResource = null; + } this._resetTrack(); this.connStatus = 'destroyed'; this.volumePercent = this.nodelink.options?.defaultVolume ?? 100; @@ -1788,13 +2094,14 @@ export class Player { * @throws Error when no active main stream or mixer limits exceeded. */ async addMix(trackPayload, volume = null) { + logger('debug', 'Player', `[Action: addMix] Method invoked for guild ${this.guildId}`); if (!this.track || this.isPaused) { throw new Error('Cannot add mix without an active stream'); } await this._ensureAudioMixer(); if (!this.audioMixer) throw new Error('AudioMixer not initialized'); - const mixConfig = this.nodelink?.options?.mix ?? { + const mixConfig = this.nodelink?.options?.playback.mix ?? { enabled: true, defaultVolume: 0.8, maxLayersMix: 5 @@ -1803,7 +2110,7 @@ export class Player { throw new Error(`Maximum number of mix layers(${mixConfig.maxLayersMix}) reached`); } const mixVolume = volume ?? mixConfig.defaultVolume ?? 0.8; - const { createAudioResource: createResource } = await import("./processing/streamProcessor.js"); + const { createAudioResource: createResource } = await import('./processing/streamProcessor.js'); const urlData = await this.nodelink.sources.getTrackUrl(trackPayload.info); if (!urlData?.url) { throw new Error('Failed to get stream URL for mix track'); @@ -1827,6 +2134,7 @@ export class Player { * @returns True when removed. */ removeMix(mixId) { + logger('debug', 'Player', `[Action: removeMix] Method invoked for guild ${this.guildId} mixId=${mixId}`); if (!this.audioMixer) { return false; } @@ -1840,6 +2148,7 @@ export class Player { * @returns True when updated; false if layer missing. */ updateMix(mixId, volume) { + logger('debug', 'Player', `[Action: updateMix] Method invoked for guild ${this.guildId} mixId=${mixId} volume=${volume}`); if (!this.audioMixer) { return false; } @@ -1851,6 +2160,7 @@ export class Player { * @returns Current mix layers with track and volume. */ getMixes() { + logger('debug', 'Player', `[Action: getMixes] Method invoked for guild ${this.guildId}`); if (!this.audioMixer) { return []; } @@ -1862,6 +2172,7 @@ export class Player { * @param skipTrackSource - When true, skips track source provider before fetching lyrics. */ async subscribeLyrics(skipTrackSource) { + logger('debug', 'Player', `[Action: subscribeLyrics] Method invoked for guild ${this.guildId}`); return new Promise((resolve) => { if (this.isLyricsSubscribed) { return resolve(); @@ -1882,6 +2193,7 @@ export class Player { * Unsubscribes from lyrics events. */ unsubscribeLyrics() { + logger('debug', 'Player', `[Action: unsubscribeLyrics] Method invoked for guild ${this.guildId}`); return new Promise((resolve) => { this.isLyricsSubscribed = false; this.skipTrackSource = false; @@ -1900,6 +2212,7 @@ export class Player { * @returns Current segments and configuration. */ getSponsorBlock() { + logger('debug', 'Player', `[Action: getSponsorBlock] Method invoked for guild ${this.guildId}`); return this.sponsorBlock; } /** @@ -1908,6 +2221,7 @@ export class Player { * @param updates - Configuration updates. */ updateSponsorBlock(updates) { + logger('debug', 'Player', `[Action: updateSponsorBlock] Method invoked for guild ${this.guildId}`); if (updates.enabled !== undefined) this.sponsorBlock.enabled = updates.enabled; if (updates.categories !== undefined) @@ -1921,6 +2235,7 @@ export class Player { * @param segments - Array of segments to apply. */ setSponsorBlockSegments(segments) { + logger('debug', 'Player', `[Action: setSponsorBlockSegments] Method invoked for guild ${this.guildId}`); this.sponsorBlock.segments = segments; this.sponsorBlock.lastSkippedUuid = null; } @@ -1928,6 +2243,7 @@ export class Player { * Clears SponsorBlock state for the player. */ clearSponsorBlock() { + logger('debug', 'Player', `[Action: clearSponsorBlock] Method invoked for guild ${this.guildId}`); this.sponsorBlock.segments = []; this.sponsorBlock.lastSkippedUuid = null; } @@ -2080,6 +2396,7 @@ export class Player { * Serializes player state to JSON-safe object. */ toJSON() { + logger('debug', 'Player', `[Action: toJSON] Method invoked for guild ${this.guildId}`); return { guildId: this.guildId, track: this.track, @@ -2092,15 +2409,18 @@ export class Player { time: Date.now(), position: this._realPosition(), connected: this.connStatus === 'connected', - ping: this.connection?.ping ?? 0 + ping: this.connection && this.connection.ping >= 0 + ? this.connection.ping + : 0 }, - voice: { ...this.voice } + voice: structuredClone(this.voice) }; } /** * Handles fading, tape, and scratch actions for start/stop/seek/pause events. */ _fading(action, payload = {}) { + logger('debug', 'Player', `[Fading] Executing fading action '${action}' for guild ${this.guildId}`); const timers = this._fadeTimers; if (!timers) return false; @@ -2217,7 +2537,7 @@ export class Player { }, delay); return true; } - if (!this.fading || this.fading.enabled !== true) + if (this.fading?.enabled !== true) return false; let section = null; if (action === 'trackStart' || action === 'trackStartArm') @@ -2268,8 +2588,9 @@ export class Player { return false; this._pendingTrackStartFade = false; if (fadeType === 'volume' || fadeType === 'both') { + const targetVol = this.duckingController?.getTargetVolume(1) ?? 1; if (stream.fadeTo) - stream.fadeTo?.(1, section.duration, section.curve); + stream.fadeTo?.(targetVol, section.duration, section.curve); } if (fadeType === 'tape' || fadeType === 'both') { if (stream.tapeTo) @@ -2304,9 +2625,10 @@ export class Player { if (!stream) return false; if (fadeType === 'volume' || fadeType === 'both') { + const targetVol = this.duckingController?.getTargetVolume(1) ?? 1; if (stream.setFadeVolume) stream.setFadeVolume(0); - stream.fadeTo?.(1, section.duration, section.curve); + stream.fadeTo?.(targetVol, section.duration, section.curve); } if (fadeType === 'tape' || fadeType === 'both') { stream.tapeTo?.(section.duration, 'start', section.curve); diff --git a/dist/src/playback/processing/AudioMixer.js b/dist/src/playback/processing/AudioMixer.js index cfb6f22b..67be018d 100644 --- a/dist/src/playback/processing/AudioMixer.js +++ b/dist/src/playback/processing/AudioMixer.js @@ -1,6 +1,6 @@ import { randomBytes } from 'node:crypto'; import { Readable } from 'node:stream'; -import { RingBuffer } from "../structs/RingBuffer.js"; +import { RingBuffer } from '../structs/RingBuffer.js'; const LAYER_BUFFER_SIZE = 1024 * 1024; const EMPTY_BUFFER = Buffer.alloc(0); const FRAME_SIZE = 3840; @@ -15,6 +15,7 @@ export class AudioMixer extends Readable { defaultVolume; autoCleanup; enabled; + layerListeners; /** * Creates a new AudioMixer. * @param config - Mixer configuration. @@ -26,6 +27,7 @@ export class AudioMixer extends Readable { this.defaultVolume = config.defaultVolume || 0.8; this.autoCleanup = config.autoCleanup !== false; this.enabled = config.enabled !== false; + this.layerListeners = new Map(); } _read(_size) { const targetSize = FRAME_SIZE; @@ -118,7 +120,7 @@ export class AudioMixer extends Readable { paused: false }; this.mixLayers.set(id, layer); - stream.on('data', (chunk) => { + const onData = (chunk) => { if (!layer.active) return; if (layer.ringBuffer.length > LAYER_BUFFER_SIZE * 0.8) { @@ -142,17 +144,27 @@ export class AudioMixer extends Readable { layer.receivedBytes += data.length; layer.ringBuffer.write(data); } - }); - stream.once('end', () => { + }; + const onEnd = () => { layer.finishedFeeding = true; - }); - stream.once('close', () => { + }; + const onClose = () => { layer.finishedFeeding = true; - }); - stream.once('error', (error) => { + }; + const onError = (error) => { this.emit('mixError', { id, error }); this.removeLayer(id, 'ERROR'); + }; + this.layerListeners.set(id, { + data: onData, + end: onEnd, + close: onClose, + error: onError }); + stream.on('data', onData); + stream.once('end', onEnd); + stream.once('close', onClose); + stream.once('error', onError); this.emit('mixStarted', { id, track, volume: layer.volume }); return id; } @@ -204,8 +216,15 @@ export class AudioMixer extends Readable { if (!layer) return false; layer.active = false; + const listeners = this.layerListeners.get(id); + if (listeners) { + layer.stream.off('data', listeners.data); + layer.stream.off('end', listeners.end); + layer.stream.off('close', listeners.close); + layer.stream.off('error', listeners.error); + this.layerListeners.delete(id); + } if (layer.stream && !layer.stream.destroyed) { - layer.stream.removeAllListeners('data'); layer.stream.destroy(); } layer.ringBuffer.dispose(); @@ -267,4 +286,14 @@ export class AudioMixer extends Readable { this.removeLayer(id, reason); return ids.length; } + /** + * Destroys the mixer: clears all layers, removes all listeners, + * and ends the Readable stream. + */ + destroy() { + this.clearLayers('DESTROYED'); + this.removeAllListeners(); + super.destroy(); + return this; + } } diff --git a/dist/src/playback/processing/DuckingController.js b/dist/src/playback/processing/DuckingController.js new file mode 100644 index 00000000..75cfc012 --- /dev/null +++ b/dist/src/playback/processing/DuckingController.js @@ -0,0 +1,210 @@ +import { Decoder as OpusDecoder } from '../../playback/opus/Opus.js'; +import { logger } from '../../utils.js'; +/** + * Controls auto-ducking behavior: lowers music volume when users speak + * and restores it when they stop. + */ +export class DuckingController { + config; + streamControl = null; + activeSpeakers = new Map(); + isDucked = false; + destroyed = false; + hookedStreams = new Set(); + activeStreams = new Map(); + static HOLD_MS = 600; + static RMS_THRESHOLD = 3500; + _onSpeakStart = (_userId, ssrc) => { + if (this.destroyed || !this.config.enabled || !this.streamControl) + return; + if (this.hookedStreams.has(ssrc)) + return; + const stream = this.connection?.getSpeakStream?.(ssrc); + if (!stream) + return; + this.hookedStreams.add(ssrc); + let decoder = null; + try { + decoder = new OpusDecoder({ rate: 48000, channels: 2 }); + } + catch (err) { + logger('warn', 'Ducking', `Failed to create Opus decoder for RMS ducking: ${err.message}`); + const onData = (chunk) => { + if (this.destroyed || !this.config.enabled) + return; + if (chunk.length < 40) + return; + this._registerSpeech(ssrc); + }; + const onEnd = () => this._cleanupStream(ssrc); + this.activeStreams.set(ssrc, { + stream, + decoder: null, + onData, + onEnd + }); + stream.on('data', onData); + stream.once('end', onEnd); + stream.once('close', onEnd); + return; + } + let lastLogTime = 0; + const onData = (pcm) => { + if (this.destroyed || !this.config.enabled) + return; + let sumSquare = 0; + for (let i = 0; i < pcm.length; i += 2) { + const sample = pcm.readInt16LE(i); + sumSquare += sample * sample; + } + const rms = Math.sqrt(sumSquare / (pcm.length / 2)); + const now = Date.now(); + if (now - lastLogTime > 1000) { + logger('debug', 'Ducking', `[RMS Debug] SSRC ${ssrc} - Current RMS: ${Math.round(rms)} (Threshold: ${DuckingController.RMS_THRESHOLD})`); + lastLogTime = now; + } + if (rms >= DuckingController.RMS_THRESHOLD) { + this._registerSpeech(ssrc, rms); + } + }; + const onEnd = () => this._cleanupStream(ssrc); + this.activeStreams.set(ssrc, { stream, decoder, onData, onEnd }); + stream.pipe(decoder); + decoder.on('data', onData); + stream.once('end', onEnd); + stream.once('close', onEnd); + }; + connection = null; + guildId; + constructor(guildId, config) { + this.guildId = guildId; + this.config = { ...config }; + } + updateConfig(config) { + this.config = { ...config }; + if (!config.enabled && this.isDucked) + this._restore(0); + } + getTargetVolume(defaultVolume = 1.0) { + return this.isDucked ? this.currentTargetVolume : defaultVolume; + } + setStreamControl(control) { + this.streamControl = control; + if (!control) { + for (const ssrc of this.activeStreams.keys()) + this._cleanupStream(ssrc); + this._restore(0); + return; + } + if (this.isDucked && this.streamControl) { + try { + this.streamControl.fadeTo(this.config.targetVolume, this.config.duration, this.config.curve); + } + catch (err) { + logger('error', 'Ducking', `Failed to reapply ducked volume for guild ${this.guildId}: ${err.message}`); + } + } + } + attach(connection) { + if (this.connection) + return; + this.connection = connection; + this.connection.on('speakStart', this._onSpeakStart); + logger('debug', 'Ducking', `Attached ducking listeners for guild ${this.guildId}`); + } + detach() { + if (this.connection) { + this.connection.removeListener('speakStart', this._onSpeakStart); + this.connection = null; + logger('debug', 'Ducking', `Detached ducking listeners for guild ${this.guildId}`); + } + for (const ssrc of this.activeStreams.keys()) + this._cleanupStream(ssrc); + this.hookedStreams.clear(); + this._restore(0); + } + destroy() { + this.destroyed = true; + this.detach(); + this.activeSpeakers.forEach(clearTimeout); + this.activeSpeakers.clear(); + this.streamControl = null; + } + currentTargetVolume = 1.0; + lastFadeTime = 0; + _cleanupStream(ssrc) { + const entry = this.activeStreams.get(ssrc); + if (!entry) + return; + this.activeStreams.delete(ssrc); + this.hookedStreams.delete(ssrc); + entry.stream.off('end', entry.onEnd); + entry.stream.off('close', entry.onEnd); + if (entry.decoder) { + entry.decoder.off('data', entry.onData); + entry.stream.unpipe(entry.decoder); + entry.decoder.destroy(); + } + else { + entry.stream.off('data', entry.onData); + } + const existing = this.activeSpeakers.get(ssrc); + if (existing) { + clearTimeout(existing); + this.activeSpeakers.delete(ssrc); + if (this.activeSpeakers.size === 0) + this._restore(); + } + } + _registerSpeech(ssrc, rms = 0) { + const existing = this.activeSpeakers.get(ssrc); + if (existing) + clearTimeout(existing); + this.activeSpeakers.set(ssrc, setTimeout(() => { + this.activeSpeakers.delete(ssrc); + logger('debug', 'Ducking', `Speaker ${ssrc} timeout expired. Active speakers: ${this.activeSpeakers.size}`); + if (this.activeSpeakers.size === 0) + this._restore(); + }, DuckingController.HOLD_MS)); + const intensity = Math.min(1.0, Math.max(0, (rms - DuckingController.RMS_THRESHOLD) / + (15000 - DuckingController.RMS_THRESHOLD))); + const minVol = 0.03; + let dynamicVol = this.config.targetVolume - intensity * (this.config.targetVolume - minVol); + dynamicVol = Number(Math.max(minVol, dynamicVol).toFixed(2)); + const now = Date.now(); + const wasDucked = this.isDucked; + const isAttacking = dynamicVol < this.currentTargetVolume; + const threshold = isAttacking ? 0.02 : 0.06; + const isSignificantChange = Math.abs(this.currentTargetVolume - dynamicVol) >= threshold; + if (!wasDucked || (isSignificantChange && now - this.lastFadeTime > 100)) { + this.isDucked = true; + let fadeDur = 50; + if (!isAttacking && wasDucked) { + fadeDur = 400; + } + this.currentTargetVolume = dynamicVol; + this.lastFadeTime = now; + try { + this.streamControl?.fadeTo(dynamicVol, fadeDur, this.config.curve); + logger('debug', 'Ducking', `Proportional Ducking -> Vol: ${dynamicVol} | Dur: ${fadeDur}ms | RMS: ${Math.round(rms)} | Guild: ${this.guildId}`); + } + catch (err) { + logger('error', 'Ducking', `Failed to dynamically duck volume for guild ${this.guildId}: ${err.message}`); + } + } + } + _restore(overrideDuration) { + if (!this.isDucked) + return; + this.isDucked = false; + this.currentTargetVolume = 1.0; + const duration = overrideDuration ?? Math.max(this.config.duration, 600); + try { + this.streamControl?.fadeTo(1.0, duration, this.config.curve); + logger('debug', 'Ducking', `Volume restored to 1.0 over ${duration}ms for guild ${this.guildId}`); + } + catch (err) { + logger('error', 'Ducking', `Failed to restore volume for guild ${this.guildId}: ${err.message}`); + } + } +} diff --git a/dist/src/playback/processing/FlowController.js b/dist/src/playback/processing/FlowController.js index 9c2430fa..31c79bd0 100644 --- a/dist/src/playback/processing/FlowController.js +++ b/dist/src/playback/processing/FlowController.js @@ -100,6 +100,12 @@ export class FlowController extends Transform { checkScratchEffectCompleted() { return this.scratch.checkEffectCompleted(); } + setLoudnessNormalizer(enabled) { + if ('setAGCEnabled' in this.volume && + typeof this.volume.setAGCEnabled === 'function') { + this.volume.setAGCEnabled(enabled); + } + } /** * Updates filters in the pipeline via the FlowController. * Note: FlowController currently doesn't manage filters itself, @@ -110,6 +116,10 @@ export class FlowController extends Transform { // This exists to satisfy streamProcessor's type check and avoid 'as any' } _transform(chunk, _encoding, callback) { + if (!this.pendingBuffer) { + callback(); + return; + } let offset = 0; if (this.pendingLength > 0) { const needed = FRAME_SIZE - this.pendingLength; @@ -136,7 +146,7 @@ export class FlowController extends Transform { } _flush(callback) { let remaining = this.pendingLength > 0 - ? this.pendingBuffer.subarray(0, this.pendingLength) + ? (this.pendingBuffer?.subarray(0, this.pendingLength) ?? EMPTY_BUFFER) : EMPTY_BUFFER; this.pendingLength = 0; if (remaining.length > 0) { @@ -168,4 +178,8 @@ export class FlowController extends Transform { } callback(); } + _destroy(_err, cb) { + this.pendingBuffer = null; + cb(null); + } } diff --git a/dist/src/playback/processing/LoudnessNormalizer.js b/dist/src/playback/processing/LoudnessNormalizer.js index 7d3dd9a8..475d5b69 100644 --- a/dist/src/playback/processing/LoudnessNormalizer.js +++ b/dist/src/playback/processing/LoudnessNormalizer.js @@ -154,6 +154,8 @@ export class LoudnessNormalizer { process(inputView) { if (inputView.length === 0) return; + if (!this._channelBuffer) + return; const frameCount = inputView.length / this.channels; const channelBuffer = this._channelBuffer; let energyState = this._energyState; @@ -214,4 +216,8 @@ export class LoudnessNormalizer { this._releaseAlpha = fround(Math.exp(-1 / (releaseTime * sr))); this._energyAlpha = fround(Math.exp(-1 / (shortTermTime * sr))); } + destroy() { + this._channelBuffer = null; + this.filters = []; + } } diff --git a/dist/src/playback/processing/ScratchTransformer.js b/dist/src/playback/processing/ScratchTransformer.js index b2aa3af0..5f7b0435 100644 --- a/dist/src/playback/processing/ScratchTransformer.js +++ b/dist/src/playback/processing/ScratchTransformer.js @@ -19,7 +19,7 @@ export class ScratchTransformer extends Transform { * Internal circular buffer for storing PCM samples. * Storing as floats (0.0 to 1.0) simplifies resampling math. */ - inputBuffer; + inputBuffer = null; inputReadPos = 0; inputWritePos = 0; maxBufferSize; @@ -32,7 +32,6 @@ export class ScratchTransformer extends Transform { this.sampleRate = options.sampleRate ?? 48000; this.channels = options.channels ?? 2; this.maxBufferSize = this.sampleRate * this.channels * 5; - this.inputBuffer = new Float32Array(this.maxBufferSize); } /** * Triggers a scratch movement. @@ -42,6 +41,8 @@ export class ScratchTransformer extends Transform { scratchTo(durationMs, style) { const duration = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 500; this._lastEffectCompleted = false; + if (duration > 0) + this._ensureInputBuffer(); if (style === 'start' && this.inputWritePos > 0) { const latencySamples = 1024 * this.channels; this.inputReadPos = Math.max(this.channels, this.inputWritePos - latencySamples); @@ -83,6 +84,14 @@ export class ScratchTransformer extends Transform { getRate() { return this.currentRate; } + _ensureInputBuffer() { + if (!this.inputBuffer) { + this.inputBuffer = new Float32Array(this.maxBufferSize); + this.inputReadPos = 0; + this.inputWritePos = 0; + } + return this.inputBuffer; + } /** * Core math for rate modulation. Simulates the physics of a DJ's hand. * @param t - Progress of the effect (0.0 to 1.0). @@ -137,8 +146,14 @@ export class ScratchTransformer extends Transform { process(chunk) { if (chunk.length === 0) return chunk; + if (!this.state && + Math.abs(this.currentRate - 1.0) <= 0.001 && + this.inputWritePos <= this.inputReadPos + this.channels) { + return chunk; + } const incomingSamples = chunk.length / 2; const incomingFrames = incomingSamples / this.channels; + const inputBuffer = this._ensureInputBuffer(); if (this.inputWritePos + incomingSamples > this.maxBufferSize) { this._compact(); if (this.inputWritePos + incomingSamples > this.maxBufferSize) { @@ -148,7 +163,7 @@ export class ScratchTransformer extends Transform { } } for (let i = 0; i < incomingSamples; i++) { - this.inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767; + inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767; } const outI16 = new Int16Array(incomingSamples); const frameDurationMs = 1000 / this.sampleRate; @@ -174,10 +189,10 @@ export class ScratchTransformer extends Transform { const safeIPos = Math.max(this.channels, Math.min(this.inputWritePos - this.channels * 3, iPos)); const frac = (this.inputReadPos - iPos) / this.channels; for (let c = 0; c < this.channels; c++) { - const p0 = this.inputBuffer[safeIPos - this.channels + c] || 0; - const p1 = this.inputBuffer[safeIPos + c] || 0; - const p2 = this.inputBuffer[safeIPos + this.channels + c] || 0; - const p3 = this.inputBuffer[safeIPos + this.channels * 2 + c] || 0; + const p0 = inputBuffer[safeIPos - this.channels + c] || 0; + const p1 = inputBuffer[safeIPos + c] || 0; + const p2 = inputBuffer[safeIPos + this.channels + c] || 0; + const p3 = inputBuffer[safeIPos + this.channels * 2 + c] || 0; const val = 0.5 * (2 * p1 + (-p0 + p2) * frac + @@ -198,6 +213,8 @@ export class ScratchTransformer extends Transform { * This allows the "disk" to be pulled backwards immediately even at the start of a chunk. */ _compact() { + if (!this.inputBuffer) + return; const historyFrames = this.sampleRate * 1; const keepSamples = historyFrames * this.channels; const integralReadPos = Math.floor(this.inputReadPos / this.channels) * this.channels; @@ -209,4 +226,9 @@ export class ScratchTransformer extends Transform { this.inputReadPos -= copyStart; this.inputWritePos = remaining; } + _destroy(_err, cb) { + this.inputBuffer = null; + this.state = null; + cb(null); + } } diff --git a/dist/src/playback/processing/TapeTransformer.js b/dist/src/playback/processing/TapeTransformer.js index 03dde937..fd6f4f76 100644 --- a/dist/src/playback/processing/TapeTransformer.js +++ b/dist/src/playback/processing/TapeTransformer.js @@ -16,7 +16,7 @@ export class TapeTransformer extends Transform { currentRate = 1.0; tape = null; _lastRampCompleted = false; - inputBuffer; + inputBuffer = null; inputReadPos = 0; inputWritePos = 0; maxBufferSize; @@ -25,7 +25,6 @@ export class TapeTransformer extends Transform { this.sampleRate = options.sampleRate ?? 48000; this.channels = options.channels ?? 2; this.maxBufferSize = this.sampleRate * this.channels * 10; - this.inputBuffer = new Float32Array(this.maxBufferSize); } setRate(rate) { this.currentRate = Math.max(0.01, Math.min(2.0, rate)); @@ -35,6 +34,8 @@ export class TapeTransformer extends Transform { tapeTo(durationMs, type, curve = DEFAULT_CURVE) { const duration = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0; this._lastRampCompleted = false; + if (duration > 0) + this._ensureInputBuffer(); if (type === 'start' && this.inputWritePos > 0) { const latencySamples = 1024 * this.channels; this.inputReadPos = Math.max(0, this.inputWritePos - latencySamples); @@ -69,6 +70,14 @@ export class TapeTransformer extends Transform { getRate() { return this.currentRate; } + _ensureInputBuffer() { + if (!this.inputBuffer) { + this.inputBuffer = new Float32Array(this.maxBufferSize); + this.inputReadPos = 0; + this.inputWritePos = 0; + } + return this.inputBuffer; + } _getCurveValue(t, curve) { switch (curve) { case 'linear': @@ -93,8 +102,14 @@ export class TapeTransformer extends Transform { process(chunk) { if (chunk.length === 0) return chunk; + if (!this.tape && + Math.abs(this.currentRate - 1.0) <= 0.001 && + this.inputWritePos <= this.inputReadPos + this.channels) { + return chunk; + } const incomingSamples = chunk.length / 2; const incomingFrames = incomingSamples / this.channels; + const inputBuffer = this._ensureInputBuffer(); if (this.inputWritePos + incomingSamples > this.maxBufferSize) { this._compact(); if (this.inputWritePos + incomingSamples > this.maxBufferSize) { @@ -104,7 +119,7 @@ export class TapeTransformer extends Transform { } } for (let i = 0; i < incomingSamples; i++) { - this.inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767; + inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767; } const outI16 = new Int16Array(incomingSamples); const sampleDurationMs = 1000 / this.sampleRate; @@ -127,12 +142,10 @@ export class TapeTransformer extends Transform { break; const frac = (this.inputReadPos - iPos) / this.channels; for (let c = 0; c < this.channels; c++) { - const p0 = this.inputBuffer[iPos - this.channels + c] ?? - this.inputBuffer[iPos + c] ?? - 0; - const p1 = this.inputBuffer[iPos + c] ?? 0; - const p2 = this.inputBuffer[iPos + this.channels + c] ?? 0; - const p3 = this.inputBuffer[iPos + this.channels * 2 + c] ?? 0; + const p0 = inputBuffer[iPos - this.channels + c] ?? inputBuffer[iPos + c] ?? 0; + const p1 = inputBuffer[iPos + c] ?? 0; + const p2 = inputBuffer[iPos + this.channels + c] ?? 0; + const p3 = inputBuffer[iPos + this.channels * 2 + c] ?? 0; const val = 0.5 * (2 * p1 + (-p0 + p2) * frac + @@ -147,7 +160,14 @@ export class TapeTransformer extends Transform { } return Buffer.from(outI16.buffer, outI16.byteOffset, outI16.byteLength); } + _destroy(_err, cb) { + this.inputBuffer = null; + this.tape = null; + cb(null); + } _compact() { + if (!this.inputBuffer) + return; const integralReadPos = Math.floor(this.inputReadPos / this.channels) * this.channels; const fractionalReadPos = this.inputReadPos - integralReadPos; if (integralReadPos <= 0) diff --git a/dist/src/playback/processing/VolumeTransformer.js b/dist/src/playback/processing/VolumeTransformer.js index 422e321f..90591c58 100644 --- a/dist/src/playback/processing/VolumeTransformer.js +++ b/dist/src/playback/processing/VolumeTransformer.js @@ -1,6 +1,6 @@ import { Buffer } from 'node:buffer'; import { Transform } from 'node:stream'; -import { LoudnessNormalizer } from "./LoudnessNormalizer.js"; +import { LoudnessNormalizer } from './LoudnessNormalizer.js'; const INT16_MAX = 32767; const INT16_MIN = -32768; const DEFAULT_CURVE = 'sinusoidal'; @@ -82,6 +82,18 @@ export class VolumeTransformer extends Transform { }) : null; } + setAGCEnabled(enabled) { + if (enabled && !this.agc) { + this.agc = new LoudnessNormalizer({ + sampleRate: this.sampleRate, + channels: this.channels, + targetLoudness: -14 + }); + } + else if (!enabled && this.agc) { + this.agc = null; + } + } _getFadeCurveValue(progress) { const clamped = Math.min(1, Math.max(0, progress)); switch (this.fadeCurve) { @@ -185,7 +197,7 @@ export class VolumeTransformer extends Transform { const { gainStart, gainEnd } = this._computeFadeGains(usableSamples); const gainStep = usableSamples > 1 ? (gainEnd - gainStart) / (usableSamples - 1) : 0; let gain = gainStart; - if (this.lookaheadSamples > 0) { + if (this.lookaheadSamples > 0 && this.lookaheadBuffer) { const outputBuffer = alignedBufferIfRequired(chunk.length); const outputView = new Int16Array(outputBuffer.buffer, outputBuffer.byteOffset, usableSamples); if (useBufferOps) { @@ -255,4 +267,12 @@ export class VolumeTransformer extends Transform { callback(error); } } + _destroy(_err, cb) { + this.lookaheadBuffer = null; + if (this.agc && typeof this.agc.destroy === 'function') { + this.agc.destroy(); + } + this.agc = null; + cb(null); + } } diff --git a/dist/src/playback/processing/filtersManager.js b/dist/src/playback/processing/filtersManager.js index 64c54913..fc53efd9 100644 --- a/dist/src/playback/processing/filtersManager.js +++ b/dist/src/playback/processing/filtersManager.js @@ -1,22 +1,23 @@ import { Transform } from 'node:stream'; -import ChannelMix from "../filters/channelMix.js"; -import Chorus from "../filters/chorus.js"; -import Compressor from "../filters/compressor.js"; -import Distortion from "../filters/distortion.js"; -import Echo from "../filters/echo.js"; -import Equalizer from "../filters/equalizer.js"; -import Flanger from "../filters/flanger.js"; -import Highpass from "../filters/highpass.js"; -import Karaoke from "../filters/karaoke.js"; -import Lowpass from "../filters/lowpass.js"; -import Phaser from "../filters/phaser.js"; -import Phonograph from "../filters/phonograph.js"; -import Reverb from "../filters/reverb.js"; -import Rotation from "../filters/rotation.js"; -import Spatial from "../filters/spatial.js"; -import Timescale from "../filters/timescale.js"; -import Tremolo from "../filters/tremolo.js"; -import Vibrato from "../filters/vibrato.js"; +import ChannelMix from '../filters/channelMix.js'; +import Chorus from '../filters/chorus.js'; +import Compressor from '../filters/compressor.js'; +import Distortion from '../filters/distortion.js'; +import Echo from '../filters/echo.js'; +import Equalizer from '../filters/equalizer.js'; +import Flanger from '../filters/flanger.js'; +import Highpass from '../filters/highpass.js'; +import Karaoke from '../filters/karaoke.js'; +import Lowpass from '../filters/lowpass.js'; +import Phaser from '../filters/phaser.js'; +import Phonograph from '../filters/phonograph.js'; +import Reverb from '../filters/reverb.js'; +import Rotation from '../filters/rotation.js'; +import Spatial from '../filters/spatial.js'; +import Timescale from '../filters/timescale.js'; +import Tremolo from '../filters/tremolo.js'; +import Vibrato from '../filters/vibrato.js'; +import Tesseract from '../filters/tesseract.js'; const FILTER_CLASSES = { tremolo: Tremolo, vibrato: Vibrato, @@ -35,7 +36,8 @@ const FILTER_CLASSES = { spatial: Spatial, reverb: Reverb, flanger: Flanger, - phonograph: Phonograph + phonograph: Phonograph, + tesseract: Tesseract }; const CANONICAL_KEY_MAP = {}; for (const key in FILTER_CLASSES) { @@ -234,11 +236,24 @@ export class FiltersManager extends Transform { * @param filters - Filter payload in any supported shape. */ _normalizeFilters(filters) { - if (!filters || typeof filters !== 'object') - return {}; - if ('filters' in filters) { - return filters.filters ?? {}; + let normalized = {}; + if (filters && typeof filters === 'object') { + if ('filters' in filters) { + normalized = filters.filters ?? {}; + } + else { + normalized = filters; + } } - return filters; + return normalized; + } + _destroy(_err, cb) { + for (const name in this.filterInstances) { + const instance = this.filterInstances[name]; + instance?.destroy?.(); + delete this.filterInstances[name]; + } + this.activeFilters = []; + cb(null); } } diff --git a/dist/src/playback/processing/streamProcessor.js b/dist/src/playback/processing/streamProcessor.js index 7cb0d37c..fe64ca47 100644 --- a/dist/src/playback/processing/streamProcessor.js +++ b/dist/src/playback/processing/streamProcessor.js @@ -3,19 +3,19 @@ import { PassThrough, Readable, Transform, pipeline } from 'node:stream'; import FAAD2NodeDecoder from '@ecliptia/faad2-wasm/faad2_node_decoder.js'; import { SeekError, seekableStream } from '@ecliptia/seekable-stream'; import { SymphoniaDecoder } from '@toddynnn/symphonia-decoder'; -import { normalizeFormat, SupportedFormats } from "../../constants.js"; -import { http1makeRequest, logger } from "../../utils.js"; -import FlvDemuxer from "../demuxers/Flv.js"; -import WebmOpusDemuxer from "../demuxers/WebmOpus.js"; -import { Decoder as OpusDecoder, Encoder as OpusEncoder } from "../opus/Opus.js"; -import { RingBuffer } from "../structs/RingBuffer.js"; -import { FadeTransformer } from "./FadeTransformer.js"; -import { TapeTransformer } from "./TapeTransformer.js"; -import { ScratchTransformer } from "./ScratchTransformer.js"; -import { FlowController } from "./FlowController.js"; -import { FiltersManager } from "./filtersManager.js"; -import { VolumeTransformer } from "./VolumeTransformer.js"; -import { SilenceDetector } from "./SilenceDetector.js"; +import { normalizeFormat, SupportedFormats } from '../../constants.js'; +import { http1makeRequest, logger } from '../../utils.js'; +import FlvDemuxer from '../demuxers/Flv.js'; +import WebmOpusDemuxer from '../demuxers/WebmOpus.js'; +import { Decoder as OpusDecoder, Encoder as OpusEncoder } from '../opus/Opus.js'; +import { RingBuffer } from '../structs/RingBuffer.js'; +import { FadeTransformer } from './FadeTransformer.js'; +import { TapeTransformer } from './TapeTransformer.js'; +import { ScratchTransformer } from './ScratchTransformer.js'; +import { FlowController } from './FlowController.js'; +import { FiltersManager } from './filtersManager.js'; +import { VolumeTransformer } from './VolumeTransformer.js'; +import { SilenceDetector } from './SilenceDetector.js'; let libSampleRatePromise = null; let mp4BoxPromise = null; const getMP4Box = async () => { @@ -26,7 +26,7 @@ const getMP4Box = async () => { }; const getLibSampleRate = async () => { if (!libSampleRatePromise) { - libSampleRatePromise = import('@alexanderolsen/libsamplerate-js').then((module) => module); + libSampleRatePromise = import('@alexanderolsen/libsamplerate-js').then((module) => (module.default || module)); } return libSampleRatePromise; }; @@ -47,7 +47,7 @@ const parsePositiveIntEnv = (key, fallback) => { const parsed = Number.parseInt(raw, 10); return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback; }; -const AAC_BUFFER_SIZE = parsePositiveIntEnv('NODELINK_AAC_RING_BYTES', 2 * 1024 * 1024); +const AAC_BUFFER_SIZE = parsePositiveIntEnv('NODELINK_AAC_RING_BYTES', 512 * 1024); const AUDIO_CONSTANTS = Object.freeze({ pcmFloatFactor: 32767, maxDecodesPerTick: 5, @@ -69,6 +69,37 @@ const SAMPLE_RATES = Object.freeze([ 96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350 ]); +const _parseAacSampleRate = (data) => { + let bitOffset = 0; + const readBits = (count) => { + if (bitOffset + count > data.byteLength * 8) + return null; + let value = 0; + for (let i = 0; i < count; i++) { + const byte = data[bitOffset >> 3]; + if (byte === undefined) + return null; + value = (value << 1) | ((byte >> (7 - (bitOffset & 7))) & 1); + bitOffset++; + } + return value; + }; + const objectType = readBits(5); + if (objectType === null) + return null; + if (objectType === 31 && readBits(6) === null) + return null; + const samplingIndex = readBits(4); + if (samplingIndex === null) + return null; + if (samplingIndex === 15) { + const explicitSampleRate = readBits(24); + return explicitSampleRate && explicitSampleRate > 0 + ? explicitSampleRate + : null; + } + return SAMPLE_RATES[samplingIndex] ?? null; +}; const EMPTY_BUFFER = Buffer.alloc(0); const _getResamplerConverterType = (quality, libSampleRate) => { const types = libSampleRate.ConverterType; @@ -160,6 +191,22 @@ const _isMp4Format = (type) => type.indexOf('mp4') !== -1 || type.indexOf('quicktime') !== -1; const _isWebmFormat = (type) => type.includes('webm') || type.includes('weba'); const _isFlvFormat = (type) => type.indexOf('flv') !== -1; +const _getSymphoniaCodecHint = (type) => { + const lowerType = type.toLowerCase(); + if (lowerType.includes('flac')) + return 'flac'; + if (lowerType.includes('mp3') || lowerType.includes('mpeg')) + return 'mp3'; + if (lowerType.includes('ogg') || lowerType.includes('vorbis')) + return 'ogg'; + if (lowerType.includes('wav') || lowerType.includes('wave')) + return 'wav'; + if (lowerType.includes('alac') || + lowerType.includes('mp4') || + lowerType.includes('m4a')) + return 'm4a'; + return null; +}; const _tightBuffer = (buf) => buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength ? buf : Buffer.from(buf); @@ -374,13 +421,18 @@ class PCMFrameCounter extends Transform { class BaseAudioResource { pipes; stream; + canStop; _destroyed; guildId; + _forwardFinishBuffering = null; + _finishBufferingEmitted; constructor(guildId) { this.guildId = guildId || 'api-stream'; this.pipes = []; this.stream = null; + this.canStop = false; this._destroyed = false; + this._finishBufferingEmitted = false; } _assignStream(stream) { const voiceStream = stream; @@ -392,6 +444,27 @@ class BaseAudioResource { voiceStream.getEffectiveRate = () => this.getEffectiveRate(); voiceStream.getRMS = () => this.getRMS(); voiceStream.isSilent = () => this.isSilent(); + voiceStream.setFadeVolume = (volume) => this.setFadeVolume(volume); + voiceStream.fadeTo = (volume, durationMs, curve) => this.fadeTo(volume, durationMs, curve); + voiceStream.tapeTo = (durationMs, type, curve) => this.tapeTo(durationMs, type, curve); + voiceStream.setLoudnessNormalizer = (enabled) => this.setLoudnessNormalizer(enabled); + voiceStream.isPipelineFinished = () => this.isPipelineFinished(); + /* + * This will prevent a race condition where fast CDN/network streams finish buffering and emit + * 'finishBuffering' before the voice connection finishes starting and subscribes to the event. + * Using 'newListener' event, if the voice player subscribes after the stream has + * already buffered, we will re-emit 'finishBuffering' immediately, allowing the track to be stoppable + * and transition to trackEnd naturally. + * + * ... i hate nodejs sometimes... + */ + voiceStream.on('newListener', (event) => { + if (event === 'finishBuffering' && this._finishBufferingEmitted) { + setImmediate(() => { + voiceStream.emit('finishBuffering'); + }); + } + }); this.stream = voiceStream; } _end() { @@ -399,23 +472,41 @@ class BaseAudioResource { return; this._destroyed = true; const firstPipe = this.pipes[0]; + if (typeof firstPipe?._cleanupListeners === 'function') { + try { + firstPipe._cleanupListeners(); + } + catch { } + } + if (this._forwardFinishBuffering && firstPipe?._sourceStream) { + try { + firstPipe._sourceStream.off?.('finishBuffering', this._forwardFinishBuffering); + } + catch { } + } if (firstPipe?.stopHls) { firstPipe.stopHls(); } if (firstPipe?.responseStream?.destroyed === false) { firstPipe.responseStream.destroy(); } - const src = firstPipe; - if (src._sourceStream && !src._sourceStream.destroyed) { - src._sourceStream.destroy(); + if (firstPipe?._sourceStream && !firstPipe._sourceStream.destroyed) { + try { + firstPipe._sourceStream.destroy(); + } + catch { } + try { + delete firstPipe._sourceStream; + } + catch { } } for (let i = this.pipes.length - 1; i >= 0; i--) { const pipe = this.pipes[i]; pipe.abort?.(); pipe.unpipe?.(); pipe.destroy?.(); - pipe.removeAllListeners?.(); } + this.pipes.length = 0; this.stream = null; this.pipes = null; } @@ -447,6 +538,19 @@ class BaseAudioResource { checkScratchEffectCompleted() { return false; } + tapeTo(_durationMs, _type, _curve) { } + setLoudnessNormalizer(_enabled) { } + isPipelineFinished() { + if (this._destroyed || !this.pipes) + return true; + for (const pipe of this.pipes) { + if (pipe.isFinished || + pipe.readableEnded) { + return true; + } + } + return false; + } setVolume(volume) { if (!this.pipes) return; @@ -534,34 +638,30 @@ class BaseAudioResource { } class SymphoniaDecoderStream extends Transform { decoder; - resumeInput; + codecRegistryHint; + flushCallback; + inputClosed; isFinished; _aborted; - _loopScheduled; _isDecoding; _timeoutId; _immediateId; - _onResume; constructor(options = {}) { + const { codecRegistryHint, ...streamOptions } = options; super({ - ...options, - highWaterMark: AUDIO_CONFIG.highWaterMark, + ...streamOptions, + highWaterMark: options.highWaterMark ?? AUDIO_CONFIG.highWaterMark, objectMode: false }); this.decoder = new SymphoniaDecoder(); - this.resumeInput = null; + this.codecRegistryHint = codecRegistryHint ?? null; + this.flushCallback = null; + this.inputClosed = false; this.isFinished = false; this._aborted = false; - this._loopScheduled = false; this._isDecoding = false; this._timeoutId = null; this._immediateId = null; - this._onResume = () => { - if (!this.isFinished && !this._aborted && this.decoder) { - this._scheduleDecode(); - } - }; - this.on('resume', this._onResume); } abort() { this._aborted = true; @@ -576,7 +676,6 @@ class SymphoniaDecoderStream extends Transform { clearImmediate(this._immediateId); this._immediateId = null; } - this._loopScheduled = false; } _isDecoderValid() { return this.decoder !== null && !this._aborted && !this.isFinished; @@ -586,117 +685,109 @@ class SymphoniaDecoderStream extends Transform { callback(); return; } - this.decoder.push(chunk); - this._scheduleDecode(); - const bufferedBytes = this.decoder?.bufferedBytes ?? 0; - if (bufferedBytes > BUFFER_THRESHOLDS.maxCompressed) { - this.resumeInput = callback; - } - else { + try { + this.decoder.push(chunk); + if (!this.decoder.isProbed) { + this.decoder.initialize(this.codecRegistryHint); + } + this._scheduleDecode(); callback(); } + catch (err) { + callback(err); + } + } + _read(_size) { + super._read(_size); + if (this._isDecoderValid()) { + this._scheduleDecode(); + } } - _scheduleDecode() { - if (this._loopScheduled || - this._isDecoding || - !this._isDecoderValid() || - this.readableFlowing === false) + _scheduleDecode(delayMs = 0) { + if (this._immediateId || this._timeoutId || !this._isDecoderValid()) return; - if (this.readableLength >= this.readableHighWaterMark) { - this._loopScheduled = true; + if (delayMs > 0) { this._timeoutId = setTimeout(() => { this._timeoutId = null; - this._loopScheduled = false; - if (this._isDecoderValid()) - this._scheduleDecode(); - }, AUDIO_CONSTANTS.decodeIntervalMs); + this._decodeLoop(); + }, delayMs); return; } - this._loopScheduled = true; - this._timeoutId = setTimeout(() => { - this._timeoutId = null; - this._loopScheduled = false; - if (this._isDecoderValid()) - this._decodeLoop(); - }, AUDIO_CONSTANTS.decodeIntervalMs); + this._immediateId = setImmediate(() => { + this._immediateId = null; + this._decodeLoop(); + }); } - async _decodeLoop() { - if (!this._isDecoderValid() || this.readableFlowing === false) + _decodeLoop() { + if (this._isDecoding || !this._isDecoderValid()) + return; + if (!this.decoder?.isProbed) { + try { + if (!this.decoder?.initialize(this.codecRegistryHint)) { + if (this.inputClosed) + this._finishDecode(); + return; + } + } + catch (err) { + this._failDecode(err); + return; + } + } + if (this.readableLength >= this.readableHighWaterMark) { + this._scheduleDecode(AUDIO_CONSTANTS.decodeIntervalMs); return; + } this._isDecoding = true; try { - let hasMoreData = true; - while (hasMoreData && + let decodeCount = 0; + while (decodeCount < AUDIO_CONSTANTS.maxDecodesPerTick && this._isDecoderValid() && - this.readableFlowing !== false && this.readableLength < this.readableHighWaterMark) { - hasMoreData = this._processAudio(); - if (hasMoreData && this._isDecoderValid()) { - await new Promise((resolve) => { - this._immediateId = setImmediate(() => { - this._immediateId = null; - resolve(); - }); - }); + const result = this.decoder?.decode(); + if (!result) { + if (this.inputClosed) + this._finishDecode(); + return; + } + decodeCount++; + if (result.samples.length === 0) + continue; + if (!this.push(result.samples)) { + this._scheduleDecode(AUDIO_CONSTANTS.decodeIntervalMs); + return; } } + this._scheduleDecode(); } catch (err) { - if (!this._aborted) - this.emit('error', err); + this._failDecode(err); } finally { this._isDecoding = false; } - const bufferedBytes = this.decoder?.bufferedBytes ?? 0; - if (bufferedBytes > 0 && - this._isDecoderValid() && - this.readableFlowing !== false && - this.readableLength < this.readableHighWaterMark) { - this._scheduleDecode(); - } } - _processAudio() { - if (!this._isDecoderValid()) - return false; - if (this.readableLength >= this.readableHighWaterMark) - return true; - if (!this.decoder?.isProbed) { - try { - if (!this.decoder?.initialize()) - return false; - } - catch (err) { - throw new Error(`Symphonia init failed: ${err.message}`); - } + _finishDecode() { + const callback = this.flushCallback; + this.flushCallback = null; + this.isFinished = true; + this._cleanup(); + callback?.(); + } + _failDecode(err) { + const callback = this.flushCallback; + this.flushCallback = null; + this.isFinished = true; + this._cleanup(); + const error = err instanceof Error ? err : new Error(`Symphonia decode failed: ${err}`); + if (callback) { + callback(error); } - let decodeCount = 0; - let hasOutput = false; - while (decodeCount < AUDIO_CONSTANTS.maxDecodesPerTick && - this._isDecoderValid() && - this.readableLength < this.readableHighWaterMark) { - const result = this.decoder?.decode(); - if (!result) - break; - const canPush = this.push(result.samples); - hasOutput = true; - decodeCount++; - if (this.resumeInput) { - const afterBytes = this.decoder?.bufferedBytes ?? 0; - if (afterBytes < BUFFER_THRESHOLDS.minCompressed) { - const cb = this.resumeInput; - this.resumeInput = null; - cb(); - } - } - if (!canPush) - break; + else { + this.emit('error', error); } - const remainingBytes = this.decoder?.bufferedBytes ?? 0; - return hasOutput || remainingBytes > 0; } _flush(callback) { - this.isFinished = true; this._cancelTimers(); if (this._aborted || !this.decoder) { this._cleanup(); @@ -705,47 +796,39 @@ class SymphoniaDecoderStream extends Transform { } try { this.decoder.closeInput(); - let count = 0; - while (count < 1000) { - const result = this.decoder?.decode(); - if (!result) - break; - this.push(result.samples); - count++; + this.inputClosed = true; + this.flushCallback = callback; + if (!this.decoder.initialize(this.codecRegistryHint)) { + if ((this.decoder.bufferedBytes ?? 0) === 0) { + this._cleanup(); + callback(); + return; + } + throw new Error('Symphonia init failed: not enough input data'); } + this._decodeLoop(); + } + catch (err) { + this.flushCallback = null; + this._cleanup(); + callback(err); } - catch { } - this._cleanup(); - callback(); } _destroy(err, callback) { this._aborted = true; this.isFinished = true; this._cancelTimers(); - if (this.resumeInput) { - const cb = this.resumeInput; - this.resumeInput = null; - cb(); + if (this.flushCallback) { + const cb = this.flushCallback; + this.flushCallback = null; + cb(err); } this._cleanup(); super._destroy(err, callback); } _cleanup() { this._cancelTimers(); - this.removeListener('resume', this._onResume); - if (this.resumeInput) { - const cb = this.resumeInput; - this.resumeInput = null; - try { - cb(); - } - catch { } - } if (this.decoder) { - try { - this.decoder.flush(); - } - catch { } try { this.decoder.free(); } @@ -832,7 +915,7 @@ class MPEGTSDemuxer extends Transform { offset += (packet[offset] || 0) + 1; if (offset + 11 < MPEGTS_CONFIG.packetSize) { this.patPmtId = - ((packet[offset + 10] || 0 & 0x1f) << 8) | (packet[offset + 11] || 0); + (((packet[offset + 10] || 0) & 0x1f) << 8) | (packet[offset + 11] || 0); } } _processPMT(packet, offset) { @@ -912,11 +995,13 @@ class AACDecoderStream extends Transform { resamplingQuality; resamplerCreationPromise; static MAX_PENDING_CHUNKS = 200; + state; constructor(options) { super({ ...options, highWaterMark: AUDIO_CONFIG.highWaterMark }); + this.state = options.state ?? null; this.decoder = new FAAD2NodeDecoder(); this.resampler = null; this.isDecoderReady = false; @@ -937,8 +1022,10 @@ class AACDecoderStream extends Transform { this.pendingChunks.length = 0; if (this.decoder) this.decoder.free?.(); - if (this.resampler) + if (this.resampler) { this.resampler.destroy?.(); + this.resampler = null; + } super._destroy(err, cb); } _downmixToStereo(interleavedPCM, channels, samplesPerChannel) { @@ -1048,6 +1135,11 @@ class AACDecoderStream extends Transform { return null; } _transform(chunk, encoding, callback) { + if (this.state?.isAlac) { + this.push(chunk); + callback(); + return; + } if (!this.isDecoderReady || this.pendingChunks.length > 0) { if (this.pendingChunks.length >= AACDecoderStream.MAX_PENDING_CHUNKS) { this.pendingChunks.shift(); @@ -1094,9 +1186,7 @@ class AACDecoderStream extends Transform { if (!this.resamplerCreationPromise) { this.resamplerCreationPromise = getLibSampleRate() .then((libSampleRate) => libSampleRate.create(2, sampleRate, 48000, { - converterType: _getResamplerConverterType(this.resamplingQuality, libSampleRate - // biome-ignore lint/suspicious/noExplicitAny: library type mismatch - ) + converterType: _getResamplerConverterType(this.resamplingQuality, libSampleRate) })) .then((resampler) => { this.resampler = resampler; @@ -1133,6 +1223,10 @@ class AACDecoderStream extends Transform { } } _flush(callback) { + if (this.state?.isAlac) { + callback(); + return; + } if (this.ringBuffer.length > 0 && this.isConfigured) { try { const frameInfo = this._findADTSFrame(); @@ -1150,13 +1244,80 @@ class AACDecoderStream extends Transform { } catch (_err) { } } - if (this.resampler) + if (this.resampler) { this.resampler.destroy?.(); + this.resampler = null; + } if (this.decoder) this.decoder.destroy?.(); callback(); } } +function patchMoovOffsets(moovBuffer, shift) { + let idx = 0; + while (true) { + idx = moovBuffer.indexOf('stco', idx); + if (idx === -1) + break; + const boxStart = idx - 4; + if (boxStart >= 0) { + const boxSize = moovBuffer.readUInt32BE(boxStart); + const entryCount = moovBuffer.readUInt32BE(idx + 8); + if (boxSize === 16 + entryCount * 4) { + for (let i = 0; i < entryCount; i++) { + const offsetPos = idx + 12 + i * 4; + const originalOffset = moovBuffer.readUInt32BE(offsetPos); + moovBuffer.writeUInt32BE(originalOffset + shift, offsetPos); + } + } + } + idx += 4; + } + idx = 0; + while (true) { + idx = moovBuffer.indexOf('co64', idx); + if (idx === -1) + break; + const boxStart = idx - 4; + if (boxStart >= 0) { + const boxSize = moovBuffer.readUInt32BE(boxStart); + const entryCount = moovBuffer.readUInt32BE(idx + 8); + if (boxSize === 16 + entryCount * 8) { + for (let i = 0; i < entryCount; i++) { + const offsetPos = idx + 12 + i * 8; + const high = moovBuffer.readUInt32BE(offsetPos); + const low = moovBuffer.readUInt32BE(offsetPos + 4); + const originalOffset = high * 0x100000000 + low; + const newOffset = originalOffset + shift; + const newHigh = Math.floor(newOffset / 0x100000000); + const newLow = newOffset % 0x100000000; + moovBuffer.writeUInt32BE(newHigh, offsetPos); + moovBuffer.writeUInt32BE(newLow, offsetPos + 4); + } + } + } + idx += 4; + } +} +/* INFO: for context of why i did this: https://github.com/pdeljanov/Symphonia/issues/289, still seems to be broken. */ +function reorderMp4Boxes(originalBuffer) { + const topBoxes = _parseBoxes(originalBuffer); + const ftyp = topBoxes.find((b) => b.type === 'ftyp'); + const moov = topBoxes.find((b) => b.type === 'moov'); + const mdat = topBoxes.find((b) => b.type === 'mdat'); + if (!ftyp || !moov || !mdat) { + return originalBuffer; + } + if (moov.offset < mdat.offset) { + return originalBuffer; + } + const ftypBuffer = originalBuffer.subarray(ftyp.offset, ftyp.offset + ftyp.size); + const moovBuffer = Buffer.from(originalBuffer.subarray(moov.offset, moov.offset + moov.size)); + patchMoovOffsets(moovBuffer, moov.size); + const beforeMoov = originalBuffer.subarray(ftyp.offset + ftyp.size, moov.offset); + const afterMoov = originalBuffer.subarray(moov.offset + moov.size); + return Buffer.concat([ftypBuffer, moovBuffer, beforeMoov, afterMoov]); +} class MP4ToAACStream extends Transform { mp4boxFile; audioConfig; @@ -1165,6 +1326,9 @@ class MP4ToAACStream extends Transform { _prefetchDone; _opts; _initPromise; + state; + symphoniaDecoder; + headerChunks; constructor(options = {}) { super({ ...options, highWaterMark: AUDIO_CONFIG.highWaterMark }); this._opts = options; @@ -1174,6 +1338,9 @@ class MP4ToAACStream extends Transform { this._aborted = false; this._prefetchDone = false; this._initPromise = null; + this.state = options.state ?? null; + this.symphoniaDecoder = null; + this.headerChunks = []; } async _initMp4Box() { if (this.mp4boxFile) @@ -1184,7 +1351,7 @@ class MP4ToAACStream extends Transform { } this._initPromise = (async () => { const mp4Box = await getMP4Box(); - this.mp4boxFile = mp4Box.createFile(true); + this.mp4boxFile = mp4Box.createFile(false); this._setupMP4BoxHandlers(); })(); await this._initPromise; @@ -1192,12 +1359,16 @@ class MP4ToAACStream extends Transform { abort() { this._aborted = true; this._cleanupMp4Box(); + if (this.symphoniaDecoder) { + this.symphoniaDecoder.abort?.(); + } } _appendPrefetchIfNeeded() { if (this._prefetchDone || !this.mp4boxFile) return; this._prefetchDone = true; const prefetch = this._opts.prefetch ?? []; + this._opts.prefetch = undefined; for (const chunk of prefetch) { const ab = chunk.data; ab.fileStart = chunk.fileStart; @@ -1213,26 +1384,48 @@ class MP4ToAACStream extends Transform { this.mp4boxFile.onReady = (info) => { if (this._aborted || !this.mp4boxFile) return; - const audioTrack = info.tracks.find((t) => t.codec?.startsWith('mp4a')); - if (!audioTrack) - throw new Error('No AAC track found in MP4'); - this.audioConfig = this._getAudioConfig(audioTrack); - this.mp4boxFile.setExtractionOptions(audioTrack.id, null, { - nbSamples: 50 - }); - if (typeof this._opts.seekTimeSec === 'number') { - const mp4boxFile = this.mp4boxFile; - const seekRes = mp4boxFile.seek(this._opts.seekTimeSec, true); - const expectedOffset = _seekOffset(seekRes); - if (typeof this._opts.baseFileStart === 'number' && - this._opts.baseFileStart !== expectedOffset) { - logger('warn', 'MP4ToAACStream', `MP4 seek mismatch: stream starts at ${this._opts.baseFileStart} but MP4Box requested ${expectedOffset}`); - } - if (typeof this._opts.baseFileStart !== 'number') { - this.offset = expectedOffset; + const audioTrack = info.tracks.find((t) => t.codec?.startsWith('mp4a') || t.codec?.startsWith('alac')); + if (!audioTrack) { + throw new Error('No supported track found in MP4'); + } + if (audioTrack.codec?.startsWith('alac')) { + if (this.state) + this.state.isAlac = true; + this._cleanupMp4Box(); + this.symphoniaDecoder = new SymphoniaDecoderStream({ + codecRegistryHint: 'm4a' + }); + this.symphoniaDecoder.on('data', (pcm) => { + this.push(pcm); + }); + this.symphoniaDecoder.on('error', (err) => { + this.emit('error', err); + }); + const fullBuffer = Buffer.concat(this.headerChunks); + const reordered = reorderMp4Boxes(fullBuffer); + this.headerChunks = []; + this.symphoniaDecoder.write(reordered); + } + else { + this.audioConfig = this._getAudioConfig(audioTrack); + this.headerChunks = []; + this.mp4boxFile.setExtractionOptions(audioTrack.id, null, { + nbSamples: 50 + }); + if (typeof this._opts.seekTimeSec === 'number') { + const mp4boxFile = this.mp4boxFile; + const seekRes = mp4boxFile.seek(this._opts.seekTimeSec, true); + const expectedOffset = _seekOffset(seekRes); + if (typeof this._opts.baseFileStart === 'number' && + this._opts.baseFileStart !== expectedOffset) { + logger('warn', 'MP4ToAACStream', `MP4 seek mismatch: stream starts at ${this._opts.baseFileStart} but MP4Box requested ${expectedOffset}`); + } + if (typeof this._opts.baseFileStart !== 'number') { + this.offset = expectedOffset; + } } + this.mp4boxFile.start(); } - this.mp4boxFile.start(); }; this.mp4boxFile.onSamples = (id, _user, samples) => { if (this._aborted || !this.mp4boxFile) @@ -1258,16 +1451,21 @@ class MP4ToAACStream extends Transform { } _getAudioConfig(track) { let profile = 2; - let adtsSampleRate = track.audio.sample_rate; + const file = this.mp4boxFile; + const entry = file?.getTrackById?.(track.id)?.mdia?.minf?.stbl?.stsd + ?.entries?.[0]; + const decoderConfig = entry?.esds?.esd?.descs?.find((descriptor) => descriptor.tag === 4); + const decoderSpecificInfo = decoderConfig?.descs?.find((descriptor) => descriptor.tag === 5)?.data; + const adtsSampleRate = (decoderSpecificInfo && _parseAacSampleRate(decoderSpecificInfo)) || + track.audio.sample_rate; if (track.codec) { const codecParts = (String(track.codec) || '').split('.'); if (codecParts.length >= 3) { const objectType = Number.parseInt(codecParts[2] || '0', 10); if (objectType === 5 || objectType === 29) { - // HE-AAC/HE-AACv2 stores the output rate on the track, but ADTS must - // advertise the core AAC-LC rate (typically half of the output rate). + // ADTS carries the AAC-LC core profile. FAAD detects the SBR/PS + // extension from the payload and exposes the higher output rate. profile = 2; - adtsSampleRate = Math.max(SAMPLE_RATES[SAMPLE_RATES.length - 1] ?? 7350, Math.floor(track.audio.sample_rate / 2)); } else { profile = objectType; @@ -1290,6 +1488,13 @@ class MP4ToAACStream extends Transform { callback(); return; } + if (this.symphoniaDecoder) { + this.symphoniaDecoder.write(chunk); + callback(); + return; + } + if (!this.audioConfig) + this.headerChunks.push(chunk); try { await this._initMp4Box(); if (!this.mp4boxFile) { @@ -1311,24 +1516,42 @@ class MP4ToAACStream extends Transform { } } _flush(callback) { + const decoderInstance = this + .symphoniaDecoder; + if (decoderInstance) { + decoderInstance.end(callback); + return; + } if (!this._aborted && this.mp4boxFile) { try { this.mp4boxFile.flush(); } catch { } } + const decoderInstanceAfter = this + .symphoniaDecoder; + if (decoderInstanceAfter) { + decoderInstanceAfter.end(callback); + return; + } this._cleanupMp4Box(); callback(); } _destroy(err, callback) { this._aborted = true; this._cleanupMp4Box(); + this.headerChunks = []; + if (this.symphoniaDecoder) { + this.symphoniaDecoder.destroy(); + this.symphoniaDecoder = null; + } super._destroy(err, callback); } _cleanupMp4Box() { if (this.mp4boxFile) { try { this.mp4boxFile.stop(); + this.mp4boxFile.flush(); } catch { } this.mp4boxFile.onReady = null; @@ -1823,7 +2046,7 @@ class StreamAudioResource extends BaseAudioResource { super(guildId); this.nodelink = nodelink; this._validateInputStream(stream); - const resamplingQuality = nodelink.options.audio?.resamplingQuality || 'fastest'; + const resamplingQuality = nodelink.options.playback.audio?.resamplingQuality || 'fastest'; const normalizedType = normalizeFormat(type); this.pipes = [stream]; const pcmStream = this._createDecoderPipeline(stream, type, normalizedType, resamplingQuality); @@ -1852,7 +2075,8 @@ class StreamAudioResource extends BaseAudioResource { case SupportedFormats.FLAC: case SupportedFormats.OGG_VORBIS: case SupportedFormats.WAV: - return this._createSymphoniaPipeline(stream); + case SupportedFormats.ALAC: + return this._createSymphoniaPipeline(stream, type); case SupportedFormats.OPUS: return this._createOpusPipeline(stream, type); default: @@ -1876,6 +2100,7 @@ class StreamAudioResource extends BaseAudioResource { const lowerType = type.toLowerCase(); const _aacStream = stream; const streams = [stream]; + const state = { isAlac: false }; if (_isFmp4Format(lowerType)) { const bufferMode = lowerType.includes('fmp4-buffered'); const demuxer = new FMP4ToAACStream({ bufferMode }); @@ -1885,7 +2110,9 @@ class StreamAudioResource extends BaseAudioResource { const demuxer = new MPEGTSDemuxer(); streams.push(demuxer); if (lowerType.includes('mp3') || lowerType.includes('mpeg')) { - const decoder = new SymphoniaDecoderStream(); + const decoder = new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(lowerType) + }); streams.push(decoder); this.pipes?.push(...streams.slice(1)); pipeline(streams, (err) => { @@ -1902,13 +2129,15 @@ class StreamAudioResource extends BaseAudioResource { ? { prefetch: seekOpts.prefetch, baseFileStart: seekOpts.baseFileStart, - seekTimeSec: seekOpts.seekTimeSec + seekTimeSec: seekOpts.seekTimeSec, + state } - : {}); + : { state }); streams.push(demuxer); } const decoder = new AACDecoderStream({ - resamplingQuality: resamplingQuality + resamplingQuality: resamplingQuality, + state }); streams.push(decoder); this.pipes?.push(...streams.slice(1)); @@ -1919,8 +2148,10 @@ class StreamAudioResource extends BaseAudioResource { }); return decoder; } - _createSymphoniaPipeline(stream) { - const decoder = new SymphoniaDecoderStream(); + _createSymphoniaPipeline(stream, type) { + const decoder = new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(type) + }); this.pipes?.push(decoder); pipeline(stream, decoder, (err) => { if (err && !this._destroyed) { @@ -1957,8 +2188,8 @@ class StreamAudioResource extends BaseAudioResource { type: 's16le', volume, enableAGC, - lookaheadMs: nodelink.options.audio?.lookaheadMs, - gateThresholdLUFS: nodelink.options.audio?.gateThresholdLUFS + lookaheadMs: nodelink.options.playback.audio?.lookaheadMs, + gateThresholdLUFS: nodelink.options.playback.audio?.gateThresholdLUFS }); const fadeTransformer = new FadeTransformer({ type: 's16le', @@ -1977,7 +2208,7 @@ class StreamAudioResource extends BaseAudioResource { const silenceDetector = new SilenceDetector({ sampleRate: AUDIO_CONFIG.sampleRate, channels: AUDIO_CONFIG.channels, - thresholdDb: nodelink.options.audio?.automix?.silenceThresholdDb ?? -40 + thresholdDb: nodelink.options.playback.audio?.automix?.silenceThresholdDb ?? -40 }); const flowController = new FlowController(volumeTransformer, fadeTransformer, tapeTransformer, scratchTransformer, audioMixer); const opusEncoder = new OpusEncoder({ @@ -2055,6 +2286,19 @@ class StreamAudioResource extends BaseAudioResource { flowController.scratchTo(durationMs, style); } } + setLoudnessNormalizer(enabled) { + if (!this.pipes) + return; + const volumeTransformer = this.pipes.find((p) => p instanceof VolumeTransformer); + if (volumeTransformer) { + volumeTransformer.setAGCEnabled(enabled); + return; + } + const flowController = this.pipes.find((p) => p instanceof FlowController); + if (flowController) { + flowController.setLoudnessNormalizer(enabled); + } + } _createPCMOutputPipeline(pcmStream, volume, enableAGC = true) { if (volume !== 1.0 || enableAGC) { const volumeTransformer = new VolumeTransformer({ @@ -2078,9 +2322,11 @@ class StreamAudioResource extends BaseAudioResource { _setupEventHandlers(inputStream) { const forwardFinishBuffering = () => { if (!this._destroyed) { + this._finishBufferingEmitted = true; this.stream?.emit('finishBuffering'); } }; + this._forwardFinishBuffering = forwardFinishBuffering; inputStream.on('finishBuffering', forwardFinishBuffering); const wrappedSource = inputStream._sourceStream; wrappedSource?.on?.('finishBuffering', forwardFinishBuffering); @@ -2162,12 +2408,13 @@ export const createSeekeableAudioResource = async (guildId, url, seekTime, endTi } }; export const createPCMStream = (_guildId, stream, type, nodelink, volume = 1.0, filters = {}) => { - const resamplingQuality = nodelink.options.audio?.resamplingQuality || 'fastest'; + const resamplingQuality = nodelink.options.playback.audio?.resamplingQuality || 'fastest'; const normalizedType = normalizeFormat(type); const streams = [stream]; switch (normalizedType) { case SupportedFormats.AAC: { const lowerType = type.toLowerCase(); + const state = { isAlac: false }; if (_isFmp4Format(lowerType)) { const bufferMode = lowerType.includes('fmp4-buffered'); streams.push(new FMP4ToAACStream({ bufferMode })); @@ -2175,14 +2422,17 @@ export const createPCMStream = (_guildId, stream, type, nodelink, volume = 1.0, else if (_isMpegtsFormat(lowerType)) { streams.push(new MPEGTSDemuxer()); if (lowerType.includes('mp3') || lowerType.includes('mpeg')) { - streams.push(new SymphoniaDecoderStream()); + streams.push(new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(lowerType) + })); break; } } else if (_isMp4Format(lowerType)) - streams.push(new MP4ToAACStream()); + streams.push(new MP4ToAACStream({ state })); streams.push(new AACDecoderStream({ - resamplingQuality: resamplingQuality + resamplingQuality: resamplingQuality, + state })); break; } @@ -2196,8 +2446,11 @@ export const createPCMStream = (_guildId, stream, type, nodelink, volume = 1.0, case SupportedFormats.MPEG: case SupportedFormats.FLAC: case SupportedFormats.OGG_VORBIS: - case SupportedFormats.WAV: { - streams.push(new SymphoniaDecoderStream()); + case SupportedFormats.WAV: + case SupportedFormats.ALAC: { + streams.push(new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(type) + })); break; } case SupportedFormats.OPUS: { diff --git a/dist/src/playback/structs/BufferPool.js b/dist/src/playback/structs/BufferPool.js index 0256b65d..fa8450a2 100644 --- a/dist/src/playback/structs/BufferPool.js +++ b/dist/src/playback/structs/BufferPool.js @@ -1,4 +1,4 @@ -import { logger } from "../../utils.js"; +import { logger } from '../../utils.js'; const parsePositiveIntEnv = (key, fallback) => { const raw = process.env[key]; if (!raw) diff --git a/dist/src/playback/structs/RingBuffer.js b/dist/src/playback/structs/RingBuffer.js index 59a565f0..0d095a6d 100644 --- a/dist/src/playback/structs/RingBuffer.js +++ b/dist/src/playback/structs/RingBuffer.js @@ -1,4 +1,4 @@ -import { bufferPool } from "./BufferPool.js"; +import { bufferPool } from './BufferPool.js'; /** * A fast, fixed-size circular buffer for audio chunks. * Uses BufferPool for memory management to reduce GC pressure. diff --git a/dist/src/server/bunServer.js b/dist/src/server/bunServer.js new file mode 100644 index 00000000..52d00f38 --- /dev/null +++ b/dist/src/server/bunServer.js @@ -0,0 +1,549 @@ +import { EventEmitter } from 'node:events'; +import { logger, parseClient, verifyDiscordID } from '../utils.js'; +const VOICE_PATH_RE = /^\/v4\/websocket\/voice\/([A-Za-z0-9]+)\/?$/; +const LIVE_PATH_RE = /^\/v4\/websocket\/youtube\/live\/([^/]+)\/?$/; +/** + * Wrapper for Bun's ServerWebSocket that implements EventEmitter + * Provides compatibility with Node.js WebSocket implementations + */ +export class BunSocketWrapper extends EventEmitter { + ws; + remoteAddress; + /** + * Creates a new BunSocketWrapper + * @param ws - Bun ServerWebSocket instance + */ + constructor(ws) { + super(); + this.ws = ws; + this.remoteAddress = ws?.data?.remoteAddress || 'unknown'; + } + /** + * Sends data through the WebSocket connection + * @param data - Data to send + * @returns True if sent successfully + * @public + */ + send(data) { + try { + const r = this.ws.send(data); + return r !== 0; + } + catch { + return false; + } + } + /** + * Sends a WebSocket ping frame + * @param data - Optional ping data + * @returns True if sent successfully + * @public + */ + ping(data) { + try { + this.ws.ping?.(data); + return true; + } + catch { + return false; + } + } + /** + * Closes the connection. + * + * - `1000` means "normal closure" **(default)** + * - `1009` means a message was too big and was rejected + * - `1011` means the server encountered an error + * - `1012` means the server is restarting + * - `1013` means the server is too busy or the client is rate-limited + * - `4000` through `4999` are reserved for applications (you can use it!) + * + * To close the connection abruptly, use `terminate()`. + * + * @param code The close code to send + * @param reason The close reason to send + * @public + */ + close(code, reason) { + this.ws.close(code, reason); + } + /** + * Terminates the connection immediately + * @public + */ + terminate() { + this.ws.close(1000, 'Terminated'); + } + /** + * Internal handler for received messages + * @param message - Message data + * @internal + */ + _handleMessage(message) { + this.emit('message', message); + } + /** + * Internal handler for connection close events + * @param code - Close code + * @param reason - Close reason + * @internal + */ + _handleClose(code, reason) { + this.emit('close', code, reason); + } +} +/** + * Creates and configures Bun HTTP server with WebSocket support + * @param context - Server context (NodelinkServer subset) + * @param getRequestHandler - Lazy loader for the API request handler + * @returns The created Bun server instance + * @internal + */ +export function createBunServer(context, getRequestHandler) { + const port = context.options.server.port; + const host = context.options.server.host || '0.0.0.0'; + const password = context.options.server.password; + logger('warn', 'Server', 'Running with Bun.serve, remember this is experimental!'); + const server = Bun.serve({ + port, + hostname: host, + maxRequestBodySize: 1024 * 1024 * 50, + idleTimeout: 60, + error(error) { + logger('error', 'Server', `HTTP server error: ${error instanceof Error ? error.message : String(error)}`); + return new Response('Internal Server Error', { status: 500 }); + }, + async fetch(req, server) { + const url = new URL(req.url); + const pathname = url.pathname.endsWith('/') + ? url.pathname.slice(0, -1) + : url.pathname; + if (pathname === '/v4/profiler/socket') { + const remoteAddress = server.requestIP(req)?.address || 'unknown'; + const isInternal = /^(::1|localhost|127\.0\.0\.1)/.test(remoteAddress); + const endpoint = context.options.cluster?.endpoint || {}; + const patchEnabled = endpoint.patchEnabled === true; + const allowExternalPatch = endpoint.allowExternalPatch === true; + const expectedCode = typeof endpoint.code === 'string' && endpoint.code.length > 0 + ? endpoint.code + : 'CAPYBARA'; + const providedCode = url.searchParams.get('code') || + req.headers.get('x-nodelink-code') || + req.headers.get('x-worker-code'); + if (!patchEnabled) { + return new Response('Profiler socket endpoint is disabled.', { + status: 403, + statusText: 'Forbidden' + }); + } + if (!allowExternalPatch && !isInternal) { + return new Response('External profiler socket access is blocked.', { + status: 403, + statusText: 'Forbidden' + }); + } + if (!providedCode || providedCode !== expectedCode) { + return new Response('Invalid or missing profiler code.', { + status: 403, + statusText: 'Forbidden' + }); + } + const success = server.upgrade(req, { + data: { + clientInfo: { name: 'ProfilerUI', version: '1' }, + sessionId: null, + reqHeaders: Object.fromEntries(req.headers), + remoteAddress, + url: req.url, + pathname, + eventName: '/v4/profiler/socket', + routeId: null + } + }); + if (success) + return undefined; + return new Response('WebSocket upgrade failed', { status: 400 }); + } + const voiceMatch = pathname.match(VOICE_PATH_RE); + const liveMatch = pathname.match(LIVE_PATH_RE); + const isMainWs = pathname === '/v4/websocket'; + if (isMainWs || voiceMatch || liveMatch) { + const remoteAddress = server.requestIP(req)?.address || 'unknown'; + const clientAddress = `[External] (${remoteAddress})`; + const clientName = req.headers.get('client-name'); + const auth = req.headers.get('authorization'); + const userId = req.headers.get('user-id'); + let sessionId = req.headers.get('session-id'); + if (auth !== password) { + logger('warn', 'Server', `Unauthorized connection attempt from ${clientAddress} - Invalid password provided: ${auth || 'None'}`); + return new Response('Invalid password provided.', { + status: 401, + statusText: 'Unauthorized', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }); + } + if (!clientName) { + logger('warn', 'Server', `Missing client-name from ${clientAddress}`); + return new Response('Invalid or missing Client-Name header.', { + status: 400, + statusText: 'Bad Request', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }); + } + if (!userId || !verifyDiscordID(userId)) { + logger('warn', 'Server', `Invalid user ID from ${clientAddress}`); + return new Response('Invalid or missing User-Id header.', { + status: 400, + statusText: 'Bad Request', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }); + } + const clientInfo = parseClient(clientName); + if (!clientInfo) { + logger('warn', 'Server', `Invalid client-name from ${clientAddress}`); + return new Response('Invalid or missing Client-Name header.', { + status: 400, + statusText: 'Bad Request', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }); + } + let eventName = '/v4/websocket'; + let routeId = null; + if (voiceMatch) { + if (!context.options.playback.voiceReceive?.enabled) { + return new Response('Voice receive disabled.', { + status: 404, + statusText: 'Not Found', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }); + } + eventName = '/v4/websocket/voice'; + routeId = voiceMatch[1] ?? null; + } + else if (liveMatch) { + eventName = '/v4/websocket/youtube/live'; + routeId = liveMatch[1] ?? null; + } + if (sessionId && !context.sessions.resumableSessions.has(sessionId)) { + logger('warn', 'Server', `Session-ID provided by ${clientAddress} does not exist or is not resumable: ${sessionId}, creating a new session`); + sessionId = null; + } + const success = server.upgrade(req, { + data: { + clientInfo, + sessionId, + reqHeaders: Object.fromEntries(req.headers), + remoteAddress, + url: req.url, + pathname, + eventName, + routeId + } + }); + if (success) + return undefined; + return new Response('WebSocket upgrade failed', { + status: 400, + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }); + } + return new Promise((resolve) => { + const dataListeners = []; + const endListeners = []; + const errorListeners = []; + let bodyTriggered = false; + const triggerBodyRead = () => { + if (bodyTriggered) + return; + bodyTriggered = true; + const hasBody = req.headers.get('content-length') || + req.headers.get('transfer-encoding'); + if (!hasBody && (req.method === 'GET' || req.method === 'HEAD')) { + queueMicrotask(() => { + for (const cb of endListeners) { + try { + cb(); + } + catch (e) { + logger('debug', 'Server', `Bun reqShim end listener threw: ${e.message}`); + } + } + }); + return; + } + req + .arrayBuffer() + .then((buf) => { + const chunk = Buffer.from(buf); + if (chunk.length > 0) { + for (const cb of dataListeners) { + try { + cb(chunk); + } + catch (e) { + logger('debug', 'Server', `Bun reqShim data listener threw: ${e.message}`); + } + } + } + for (const cb of endListeners) { + try { + cb(); + } + catch (e) { + logger('debug', 'Server', `Bun reqShim end listener threw: ${e.message}`); + } + } + }) + .catch((err) => { + const error = err instanceof Error ? err : new Error(String(err)); + if (errorListeners.length > 0) { + for (const cb of errorListeners) { + try { + cb(error); + } + catch { } + } + } + else { + logger('debug', 'Server', `Bun request body read failed: ${error.message}`); + for (const cb of endListeners) { + try { + cb(); + } + catch { } + } + } + }); + }; + const reqShim = { + method: req.method, + url: url.pathname + url.search, + headers: Object.fromEntries(req.headers), + socket: { remoteAddress: server.requestIP(req)?.address }, + on: (event, cb) => { + if (event === 'data') { + dataListeners.push(cb); + triggerBodyRead(); + } + else if (event === 'end') { + endListeners.push(cb); + triggerBodyRead(); + } + else if (event === 'error') { + errorListeners.push(cb); + } + } + }; + const resShim = { + _status: 200, + _headers: {}, + _body: [], + writeHead(status, headers) { + this._status = status; + if (headers) + Object.assign(this._headers, headers); + }, + setHeader(name, value) { + this._headers[name] = value; + }, + getHeader(name) { + return this._headers[name]; + }, + end(data) { + if (data) + this._body.push(data); + let finalBody; + if (this._body.length === 0) { + finalBody = ''; + } + else if (this._body.length === 1 && + Buffer.isBuffer(this._body[0])) { + finalBody = this._body[0]; + } + else { + finalBody = Buffer.concat(this._body.map((chunk) => Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))); + } + const headers = new Headers(); + for (const [key, value] of Object.entries(this._headers)) { + if (Array.isArray(value)) { + for (const v of value) + headers.append(key, v); + } + else if (value !== undefined) { + headers.set(key, String(value)); + } + } + const response = new Response(finalBody, { + status: this._status, + headers + }); + resolve(response); + }, + write(data) { + if (data) + this._body.push(data); + } + }; + void getRequestHandler() + .then((handler) => handler(context, reqShim, resShim)) + .catch((error) => { + logger('error', 'Server', `Failed to handle Bun request: ${error.message}`); + if (!resShim._status || resShim._status < 400) { + resShim.writeHead(500, { 'Content-Type': 'text/plain' }); + } + resShim.end('Internal Server Error'); + }); + }); + }, + websocket: { + sendPings: true, + idleTimeout: 120, + maxPayloadLength: 1024 * 1024 * 16, + data: {}, + open(ws) { + if (!ws.data) { + try { + ws.close(1011, 'Missing socket data'); + } + catch { } + return; + } + const wrapper = new BunSocketWrapper(ws); + ws.data.wrapper = wrapper; + const { clientInfo, sessionId, reqHeaders, pathname, eventName, routeId } = ws.data; + const reqShim = { + headers: reqHeaders, + url: ws.data.url, + socket: { remoteAddress: ws.data.remoteAddress } + }; + if (pathname === '/v4/profiler/socket') { + logger('info', 'ProfilerSocket', `Profiler socket connected from [External] (${ws.data.remoteAddress})`); + context.socket?.emit('/v4/profiler/socket', wrapper, reqShim, null, null); + return; + } + logger('info', 'Server', `\x1b[36m${clientInfo.name}\x1b[0m${clientInfo.version ? `/\x1b[32mv${clientInfo.version}\x1b[0m` : ''} connected from [External] (${ws.data.remoteAddress}) | \x1b[33mURL:\x1b[0m ${ws.data.url}`); + if (context.socket) { + context.socket.emit(eventName ?? '/v4/websocket', wrapper, reqShim, clientInfo, sessionId, routeId ?? null); + } + }, + message(ws, message) { + const wrapper = ws.data?.wrapper; + if (!wrapper) { + logger('debug', 'WebSocket', `Bun message received without wrapper (remote: ${ws.data?.remoteAddress || 'unknown'})`); + return; + } + wrapper._handleMessage(message); + }, + close(ws, code, reason) { + const wrapper = ws.data?.wrapper; + if (!wrapper) { + logger('debug', 'WebSocket', `Bun close received without wrapper (code: ${code}, remote: ${ws.data?.remoteAddress || 'unknown'})`); + return; + } + wrapper._handleClose(code, reason); + }, + // `error` is documented in Bun.serve docs but missing from + // bun-types@1.3.14 typings; cast keeps runtime behaviour while + // satisfying the type checker. + ...{ + error(ws, err) { + logger('error', 'WebSocket', `Bun WebSocket error from ${ws.data?.remoteAddress || 'unknown'}: ${err.message}`); + const wrapper = ws.data?.wrapper; + if (wrapper && wrapper.listenerCount('error') > 0) { + try { + wrapper.emit('error', err); + } + catch { } + } + } + } + } + }); + logger('started', 'Server', `Successfully listening on ${host}:${port} (Bun Native)`); + return server; +} +/** + * Cleans up Bun WebSocket server resources + * @param context - Server context + * @param server - The Bun server instance to clean up + * @internal + */ +export async function cleanupBunServer(context, server) { + try { + logger('info', 'WebSocket', 'Stopping Bun server...'); + // Gracefully close every active session with the same code Node uses, + // so clients see a clean 1000 close frame and reconnect normally. + // Without this, Bun.stop(true) tears TCP connections down without + // sending close frames, surfacing as ECONNRESET on the client. + let closedCount = 0; + for (const session of context.sessions.activeSessions.values()) { + if (!session.socket) + continue; + try { + session.socket.close(1000, 'Server shutdown'); + closedCount++; + } + catch (_e) { + try { + ; + session.socket.destroy?.(); + } + catch (_destroyErr) { + logger('debug', 'WebSocket', `Failed to close/destroy socket for session ${session.id}`); + } + } + } + context.sessions.activeSessions.clear(); + context.sessions.resumableSessions.clear(); + logger('info', 'WebSocket', `Signalled close to ${closedCount} WebSocket connection(s)`); + // Prefer graceful stop so the close frames above flush. If clients + // don't drain within 1.5s (slow networks, half-open peers), fall + // back to force-stop so shutdown still completes promptly. + await new Promise((resolveStop) => { + let settled = false; + const finish = () => { + if (settled) + return; + settled = true; + resolveStop(); + }; + const forceTimer = setTimeout(() => { + server.stop(true).then(finish, finish); + }, 1500); + server.stop(false).then(() => { + clearTimeout(forceTimer); + finish(); + }, () => { + clearTimeout(forceTimer); + server.stop(true).then(finish, finish); + }); + }); + try { + server.unref(); + } + catch { } + logger('info', 'WebSocket', 'Bun server stopped successfully'); + } + catch (e) { + const error = e; + logger('error', 'WebSocket', `Error stopping Bun server: ${error?.message ?? String(e)}`); + } +} diff --git a/dist/src/sources/amazonmusic.js b/dist/src/sources/amazonmusic.js index 7f916046..0246800c 100644 --- a/dist/src/sources/amazonmusic.js +++ b/dist/src/sources/amazonmusic.js @@ -1,5 +1,5 @@ import crypto from 'node:crypto'; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; /** * User agent string used for general browsing and scraping operations. * @internal @@ -191,13 +191,15 @@ export default class AmazonMusicSource { 'x-amzn-device-language': 'en_US', 'x-amzn-currency-of-preference': 'USD', 'x-amzn-os-version': '1.0', - 'x-amzn-application-version': '1.0.9172.0', + 'x-amzn-application-version': '1.0.10905.0', 'x-amzn-device-time-zone': 'America/New_York', 'x-amzn-timestamp': String(Date.now()), 'x-amzn-csrf': this.buildCsrfHeader(cfg.csrf), 'x-amzn-music-domain': 'music.amazon.com', 'x-amzn-page-url': pageUrl, - 'x-amzn-feature-flags': 'hd-supported,uhd-supported' + 'x-amzn-feature-flags': 'hd-supported,uhd-supported', + 'x-amnz-age-band': 'ADULT', + 'x-amzn-has-profile-id': 'true', }; } /** diff --git a/dist/src/sources/anghami.js b/dist/src/sources/anghami.js index df86951f..bfbcef9e 100644 --- a/dist/src/sources/anghami.js +++ b/dist/src/sources/anghami.js @@ -1,4 +1,4 @@ -import { encodeTrack, getBestMatch, logger, makeRequest } from "../utils.js"; +import { encodeTrack, getBestMatch, logger, makeRequest } from '../utils.js'; const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'; const AnghamiSongBatchDecoder = { decode(buffer) { diff --git a/dist/src/sources/applemusic.js b/dist/src/sources/applemusic.js index 2d47a772..72de3cac 100644 --- a/dist/src/sources/applemusic.js +++ b/dist/src/sources/applemusic.js @@ -1,4 +1,4 @@ -import { encodeTrack, getBestMatch, http1makeRequest } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest } from '../utils.js'; /** * Apple Music source implementation. * Provides integration with the Apple Music Catalog API for track resolution and searching. @@ -230,7 +230,7 @@ export default class AppleMusicSource { */ async search(query, _sourceName, searchType = 'track') { try { - const limit = this.nodelink.options.maxSearchResults || 10; + const limit = this.nodelink.options.search.maxResults || 10; const typeMap = { track: 'songs', album: 'albums', diff --git a/dist/src/sources/audiomack.js b/dist/src/sources/audiomack.js index 32059489..dd1e84ca 100644 --- a/dist/src/sources/audiomack.js +++ b/dist/src/sources/audiomack.js @@ -1,6 +1,6 @@ import crypto from 'node:crypto'; import { PassThrough } from 'node:stream'; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const AUDIOMACK_PATTERNS = [ /https?:\/\/(?:www\.)?audiomack\.com\/[^/]+\/song\/[^/]+(?:\?.*)?$/i, /https?:\/\/(?:www\.)?audiomack\.com\/[^/]+\/album\/[^/]+(?:\?.*)?$/i, diff --git a/dist/src/sources/audius.js b/dist/src/sources/audius.js index d510687c..49f108c3 100644 --- a/dist/src/sources/audius.js +++ b/dist/src/sources/audius.js @@ -1,4 +1,4 @@ -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * Base URL for Audius discovery nodes. * @internal @@ -211,7 +211,7 @@ export default class AudiusSource { */ async search(query) { try { - const limit = this.nodelink.options.maxSearchResults || 10; + const limit = this.nodelink.options.search.maxResults || 10; const endpoint = `/v1/tracks/search?query=${encodeURIComponent(query)}&limit=${limit}`; const data = await this._apiRequest(endpoint); if (!data || data.length === 0) { diff --git a/dist/src/sources/bandcamp.js b/dist/src/sources/bandcamp.js index d3c41b79..e1f21527 100644 --- a/dist/src/sources/bandcamp.js +++ b/dist/src/sources/bandcamp.js @@ -1,14 +1,11 @@ -import { PassThrough } from 'node:stream'; -import { encodeTrack, logger, makeRequest } from "../utils.js"; +import { PassThrough, pipeline } from 'node:stream'; +import { encodeTrack, logger, makeRequest } from '../utils.js'; const BANDCAMP_BASE_URL = 'https://bandcamp.com'; +const BANDCAMP_SEARCH_API_URL = `${BANDCAMP_BASE_URL}/api/bcsearch_public_api/1/autocomplete_elastic`; const BANDCAMP_TRACK_PATTERN = /^https?:\/\/([^/]+)\.bandcamp\.com\/(track|album)\/([^/?]+)/; -const SEARCH_RESULT_REGEX = /
  • /g; -const SEARCH_URL_REGEX = //; -const SEARCH_TITLE_REGEX = /
    \s*]*>\s*(.+?)\s*<\/a>/; -const SEARCH_SUBHEAD_REGEX = /
    ([\s\S]*?)<\/div>/; -const SEARCH_ARTWORK_REGEX = /
    \s*([\s\S]*?)<\/script>/; /** * Bandcamp source implementation. */ @@ -60,43 +57,60 @@ export default class BandcampSource { return this.patterns.some((pattern) => pattern.test(link)); } /** - * Searches Bandcamp track results for a plain-text query. + * Searches Bandcamp track results using the internal JSON search API. + * + * The previous HTML-scraping approach broke because `bandcamp.com/search` + * now returns a client-challenge page that requires JavaScript. The + * internal autocomplete API used by the Bandcamp frontend returns + * structured JSON and does not require authentication. * * @param query Search string received from the API or unified search flow. * @returns Search results, an empty payload, or a structured exception. */ async search(query) { try { - const request = await makeRequest(`${this.baseUrl}/search?q=${encodeURIComponent(query)}&item_type=t&from=results`, { method: 'GET' }); + const request = await makeRequest(BANDCAMP_SEARCH_API_URL, { + method: 'POST', + disableBodyCompression: true, + body: { + search_text: query, + search_filter: 't', + full_page: true, + fan_id: null + } + }); if (request.error || request.statusCode !== 200) { return { loadType: 'error', exception: { message: request.error ?? - `BandCamp returned an invalid status: ${request.statusCode}`, + `BandCamp search API returned status ${request.statusCode}.`, severity: 'fault', cause: 'Request Failed' } }; } - const body = this.getResponseText(request); - if (body === null) { - return this.createSourceException('BandCamp search returned an unreadable response body.', 'fault', 'Invalid Response'); - } - const resultBlocks = body.match(SEARCH_RESULT_REGEX); - if (!resultBlocks || resultBlocks.length === 0) { + const response = this.getJsonBody(request.body); + if (!response?.auto?.results || response.auto.results.length === 0) { logger('debug', 'Sources', `No results found on BandCamp for: "${query}"`); return { loadType: 'empty', data: {} }; } const tracks = []; const maxResults = this.getMaxSearchResults(); - for (const block of resultBlocks) { + for (const item of response.auto.results) { if (tracks.length >= maxResults) break; - const result = this.parseSearchResult(block); - if (!result) + if (!item.name || !item.item_url_path) continue; - tracks.push(this.buildTrack(result)); + tracks.push(this.buildTrack({ + identifier: item.id != null ? String(item.id) : null, + title: item.name, + author: item.band_name || null, + uri: item.item_url_path, + artworkUrl: item.art_id + ? this.createArtworkUrl(item.art_id) + : (item.img ?? null) + })); } if (tracks.length === 0) { logger('warn', 'Sources', 'Search results found on BandCamp, but no tracks could be parsed.'); @@ -112,21 +126,33 @@ export default class BandcampSource { /** * Resolves a Bandcamp track or album URL into a track or playlist payload. * + * Uses `data-tralbum` as the primary metadata source and enriches with + * JSON-LD structured data (ISRC, duration, artwork) when available. + * * @param url Canonical Bandcamp URL to resolve. * @returns A track, playlist, empty result, or a structured exception. */ async resolve(url) { try { - const tralbumData = await this.extractTralbumData(url); - if (!tralbumData?.trackinfo || tralbumData.trackinfo.length === 0) { + const pageData = await this.fetchPageData(url); + if (!pageData) { + logger('warn', 'Sources', `Failed to fetch BandCamp page for: ${url}`); + return { loadType: 'empty', data: {} }; + } + const { tralbum, jsonLd } = pageData; + if (!tralbum?.trackinfo || tralbum.trackinfo.length === 0) { logger('warn', 'Sources', `No 'tralbum' data found on BandCamp for: ${url}`); return { loadType: 'empty', data: {} }; } - const artworkUrl = this.createArtworkUrl(tralbumData.art_id); - const author = this.normalizeText(tralbumData.artist) ?? 'Unknown Artist'; - if (tralbumData.trackinfo.length > 1) { + const artworkUrl = this.createArtworkUrl(tralbum.art_id) ?? + (typeof jsonLd?.image === 'string' ? jsonLd.image : null); + const author = this.normalizeText(tralbum.artist) ?? + this.normalizeText(jsonLd?.byArtist?.name) ?? + 'Unknown Artist'; + const pageIsrc = tralbum.current?.isrc ?? jsonLd?.isrcCode ?? null; + if (tralbum.trackinfo.length > 1) { const tracks = []; - for (const item of tralbumData.trackinfo) { + for (const item of tralbum.trackinfo) { const trackUrl = item.title_link ? this.buildAbsoluteTrackUrl(item.title_link, url) : null; @@ -148,8 +174,7 @@ export default class BandcampSource { } const playlist = { info: { - name: this.normalizeText(tralbumData.current?.title) ?? - 'BandCamp Playlist', + name: this.normalizeText(tralbum.current?.title) ?? 'BandCamp Playlist', selectedTrack: 0 }, pluginInfo: {}, @@ -157,7 +182,7 @@ export default class BandcampSource { }; return { loadType: 'playlist', data: playlist }; } - const trackData = tralbumData.trackinfo[0]; + const trackData = tralbum.trackinfo[0]; if (!trackData) { return { loadType: 'empty', data: {} }; } @@ -165,11 +190,13 @@ export default class BandcampSource { identifier: this.getTrackIdentifier(trackData, url), isSeekable: true, author, - length: this.toDurationMilliseconds(trackData.duration), + length: this.toDurationMilliseconds(trackData.duration) ?? + this.parseIsoDuration(jsonLd?.duration), isStream: false, title: this.normalizeText(trackData.title), uri: url, - artworkUrl + artworkUrl, + isrc: pageIsrc }); return { loadType: 'track', data: track }; } @@ -180,6 +207,11 @@ export default class BandcampSource { /** * Extracts the direct Bandcamp MP3 stream URL from a track page. * + * When possible, the stream URL is extracted directly from the + * `data-tralbum` payload to avoid an additional HTTP round-trip. + * Falls back to a regex scan of the full page body when the structured + * extraction does not yield a URL. + * * @param track Decoded track information produced by the source manager. * @returns A direct stream URL descriptor or a structured exception. */ @@ -209,8 +241,9 @@ export default class BandcampSource { } }; } - const streamUrlMatch = page.match(STREAM_URL_REGEX); - if (!streamUrlMatch) { + // Try extracting stream URL from the structured tralbum data first. + const streamUrl = this.extractStreamUrlFromPage(page, track.identifier); + if (!streamUrl) { return { loadType: 'error', exception: { @@ -221,7 +254,7 @@ export default class BandcampSource { }; } return { - url: this.decodeHtmlEntities(streamUrlMatch[0]), + url: streamUrl, protocol: 'https', format: 'mp3' }; @@ -251,7 +284,10 @@ export default class BandcampSource { try { const response = await makeRequest(url, { method: 'GET', - streamOnly: true + streamOnly: true, + headers: { + Referer: decodedTrack.uri + } }); if (response.error || response.statusCode !== 200 || !response.stream) { return { @@ -265,7 +301,15 @@ export default class BandcampSource { }; } const stream = new PassThrough(); - response.stream.pipe(stream); + stream.once('close', () => { + ; + response.stream.destroy?.(); + }); + pipeline(response.stream, stream, (error) => { + if (error && error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Sources', `BandCamp stream error: ${error.message}`); + } + }); return { stream }; } catch (error) { @@ -283,12 +327,12 @@ export default class BandcampSource { } } /** - * Fetches and parses the `data-tralbum` payload from a Bandcamp page. + * Fetches a Bandcamp page and extracts both `data-tralbum` and JSON-LD data. * * @param url Bandcamp track or album URL. - * @returns Parsed `data-tralbum` content or `null` when extraction fails. + * @returns Parsed page metadata or `null` when extraction fails. */ - async extractTralbumData(url) { + async fetchPageData(url) { const { body, error, statusCode } = await makeRequest(url, { method: 'GET' }); @@ -299,17 +343,9 @@ export default class BandcampSource { const page = this.getResponseText({ body }); if (page === null) return null; - const match = page.match(TRALBUM_REGEX); - if (!match?.[2]) - return null; - try { - const decodedString = this.decodeHtmlEntities(match[2]); - return JSON.parse(decodedString); - } - catch (error) { - logger('warn', 'Sources', `Failed to parse BandCamp tralbum payload for ${url}: ${error instanceof Error ? error.message : 'invalid JSON'}`); - return null; - } + const tralbum = this.parseTralbumFromPage(page); + const jsonLd = this.parseJsonLdFromPage(page); + return { tralbum, jsonLd, rawPage: page }; } /** * Converts parsed Bandcamp metadata into an encoded track payload. @@ -329,7 +365,7 @@ export default class BandcampSource { title: partialInfo.title?.trim() || 'Unknown Title', uri: partialInfo.uri, artworkUrl: partialInfo.artworkUrl, - isrc: null, + isrc: partialInfo.isrc ?? null, sourceName: 'bandcamp', details: [] }; @@ -350,36 +386,67 @@ export default class BandcampSource { return match ? `${match[1]}:${match[3]}` : url; } /** - * Extracts a usable search result from a raw Bandcamp HTML block. + * Parses the `data-tralbum` JSON payload from a Bandcamp page body. * - * @param block Raw HTML fragment for a single search result entry. - * @returns Parsed search metadata or `null` when the entry is incomplete. + * @param page Full HTML page body. + * @returns Parsed tralbum data, or `null` when not found or invalid. */ - parseSearchResult(block) { - const urlMatch = block.match(SEARCH_URL_REGEX); - const titleMatch = block.match(SEARCH_TITLE_REGEX); - const subheadMatch = block.match(SEARCH_SUBHEAD_REGEX); - const artworkMatch = block.match(SEARCH_ARTWORK_REGEX); - if (!titleMatch?.[1] || !subheadMatch?.[1] || !urlMatch?.[1]) { + parseTralbumFromPage(page) { + const match = page.match(TRALBUM_REGEX); + if (!match?.[1]) return null; + try { + const decoded = this.decodeHtmlEntities(match[1]); + return JSON.parse(decoded); } - const rawTitle = titleMatch[1]; - const rawSubhead = subheadMatch[1]; - const rawUri = urlMatch[1]; - const title = this.normalizeText(this.stripHtml(rawTitle)); - const fullSubhead = this.normalizeText(this.stripHtml(rawSubhead)); - const uri = rawUri.split('?')[0]; - if (!title || !fullSubhead || !uri) { + catch (error) { + logger('warn', 'Sources', `Failed to parse BandCamp tralbum payload: ${error instanceof Error ? error.message : 'invalid JSON'}`); return null; } - const artistSegments = fullSubhead.split(' de '); - const author = artistSegments[artistSegments.length - 1]?.trim() || 'Unknown Artist'; - return { - title, - author, - uri, - artworkUrl: artworkMatch?.[1] ?? null - }; + } + /** + * Parses the JSON-LD `MusicRecording` block from a Bandcamp page body. + * + * @param page Full HTML page body. + * @returns Parsed JSON-LD data, or `null` when not found or invalid. + */ + parseJsonLdFromPage(page) { + const match = page.match(JSON_LD_REGEX); + if (!match?.[1]) + return null; + try { + return JSON.parse(match[1].trim()); + } + catch { + return null; + } + } + /** + * Extracts the MP3 stream URL from a Bandcamp page body. + * + * Tries the structured `data-tralbum` `trackinfo[].file["mp3-128"]` field + * first, then falls back to a regex scan for a `t4.bcbits.com/stream` URL. + */ + extractStreamUrlFromPage(page, trackId) { + // Try structured extraction from tralbum first. + const tralbum = this.parseTralbumFromPage(page); + if (tralbum?.trackinfo) { + // Find the specific track if an ID is provided, otherwise default to the first + const trackData = trackId + ? tralbum.trackinfo.find((t) => String(t.track_id) === trackId || String(t.id) === trackId) || tralbum.trackinfo[0] + : tralbum.trackinfo[0]; + if (trackData?.file) { + const mp3Url = trackData.file['mp3-128']; + if (mp3Url) { + return this.decodeHtmlEntities(mp3Url); + } + } + } + // Fallback: regex scan of the full page. + const decodedPage = this.decodeHtmlEntities(page); + // Fix: The regex must allow `&` to capture the token parameters. + const streamUrlMatch = decodedPage.match(/https?:\/\/t4\.bcbits\.com\/stream\/[^"'\s]+/); + return streamUrlMatch ? streamUrlMatch[0] : null; } /** * Converts an HTTP helper response body into UTF-8 text. @@ -397,8 +464,34 @@ export default class BandcampSource { return null; } /** - * Decodes the small subset of HTML entities used by the Bandcamp pages this - * source parses. + * Safely parses a JSON body from an HTTP response. + * + * @param body Raw response body from the HTTP helper. + * @returns The parsed JSON object, or `null` when parsing fails. + */ + getJsonBody(body) { + if (body !== null && + body !== undefined && + typeof body === 'object' && + !Buffer.isBuffer(body)) { + return body; + } + const text = this.getResponseText({ body }); + if (text === null) + return null; + try { + return JSON.parse(text); + } + catch { + return null; + } + } + /** + * Decodes HTML entities commonly found in Bandcamp page attributes and + * JSON payloads embedded in HTML. + * + * Handles named entities, decimal numeric entities, and hexadecimal + * numeric entities. * * @param value Raw HTML fragment or encoded attribute value. * @returns A decoded string safe to use in URLs and titles. @@ -408,19 +501,14 @@ export default class BandcampSource { .replaceAll('"', '"') .replaceAll('"', '"') .replaceAll(''', "'") + .replaceAll(''', "'") .replaceAll(''', "'") - .replaceAll('&', '&') .replaceAll('<', '<') - .replaceAll('>', '>'); - } - /** - * Removes HTML tags from a fragment extracted from the Bandcamp search page. - * - * @param value Raw HTML fragment. - * @returns Plain-text content with tags removed. - */ - stripHtml(value) { - return value.replace(/<[^>]+>/g, ' '); + .replaceAll('>', '>') + .replaceAll(' ', ' ') + .replaceAll('&', '&') + .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16))) + .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10))); } /** * Normalizes parsed HTML text into a trimmed human-readable value. @@ -445,6 +533,26 @@ export default class BandcampSource { toDurationMilliseconds(durationSeconds) { return durationSeconds ? Math.round(durationSeconds * 1000) : -1; } + /** + * Parses an ISO 8601 duration string into milliseconds. + * + * Handles the `P00H05M20S` format used by Bandcamp's JSON-LD. + * + * @param iso ISO 8601 duration string. + * @returns Duration in milliseconds, or `-1` when parsing fails. + */ + parseIsoDuration(iso) { + if (!iso) + return -1; + const match = iso.match(/P(?:(\d+)D)?(?:T)?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?/); + if (!match) + return -1; + const days = parseInt(match[1] || '0', 10); + const hours = parseInt(match[2] || '0', 10); + const minutes = parseInt(match[3] || '0', 10); + const seconds = parseFloat(match[4] || '0'); + return Math.round((days * 86400 + hours * 3600 + minutes * 60 + seconds) * 1000); + } /** * Builds the public Bandcamp artwork URL from an `art_id` value. * @@ -492,7 +600,7 @@ export default class BandcampSource { */ getMaxSearchResults() { const options = this.nodelink.options; - const limit = options.maxSearchResults; + const limit = options.search.maxResults; return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : 10; diff --git a/dist/src/sources/bilibili.js b/dist/src/sources/bilibili.js index 805910c5..83ebfac6 100644 --- a/dist/src/sources/bilibili.js +++ b/dist/src/sources/bilibili.js @@ -1,7 +1,7 @@ import crypto from 'node:crypto'; import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, http1makeRequest, logger, makeRequest } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Mixin key encoding table for Bilibili WBI signatures. * @internal @@ -161,7 +161,7 @@ export default class BilibiliSource { const res = await makeRequest('https://api.bilibili.com/x/web-interface/nav', { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; if (res.error || !body?.data?.wbi_img) { @@ -227,7 +227,7 @@ export default class BilibiliSource { Cookie: cookie, Referer: 'https://search.bilibili.com/' }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); body = searchResponse.body; if (!body?.data || @@ -241,7 +241,7 @@ export default class BilibiliSource { Cookie: cookie, Referer: 'https://search.bilibili.com/' }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); body = allSearchResponse.body; } @@ -263,7 +263,7 @@ export default class BilibiliSource { return { loadType: 'empty', data: {} }; } const tracks = []; - const limit = this.nodelink.options.maxSearchResults || 10; + const limit = this.nodelink.options.search.maxResults || 10; for (const item of videos.slice(0, limit)) { const durationParts = String(item.duration || '0:0') .split(':') @@ -322,7 +322,7 @@ export default class BilibiliSource { headers: HEADERS, maxRedirects: 3, timeout: 5000, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); if (typeof res.body === 'string') { const match = res.body.match(/rel=["']canonical["'][^>]+href=["']([^"']+)["']/); @@ -482,10 +482,10 @@ export default class BilibiliSource { const res = await makeRequest(apiUrl, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0) { + if (body?.code !== 0) { throw new Error(`API Error: ${body?.message || 'Video not found'}`); } const data = body.data; @@ -518,10 +518,10 @@ export default class BilibiliSource { const res = await makeRequest(apiUrl, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0) + if (body?.code !== 0) throw new Error(`Bangumi API Error: ${body?.message}`); const result = body.result; if (!result) @@ -584,10 +584,10 @@ export default class BilibiliSource { const res = await makeRequest(`https://www.bilibili.com/audio/music-service-c/web/song/info?sid=${id}`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0) + if (body?.code !== 0) throw new Error(`Audio API Error: ${body?.msg}`); const data = body.data; if (!data) @@ -617,10 +617,10 @@ export default class BilibiliSource { const albumResRaw = await makeRequest(`https://www.bilibili.com/audio/music-service-c/web/song/of-menu?sid=${id}&pn=1&ps=100`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const albumRes = albumResRaw.body; - if (!albumRes || albumRes.code !== 0) + if (albumRes?.code !== 0) throw new Error(`Album API Error: ${albumRes?.msg}`); const tracks = (albumRes.data?.data || []).map((song) => { const trackInfo = { @@ -645,7 +645,7 @@ export default class BilibiliSource { const infoResRaw = await makeRequest(`https://www.bilibili.com/audio/music-service-c/web/menu/info?sid=${id}`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const infoRes = infoResRaw.body; return { @@ -675,10 +675,10 @@ export default class BilibiliSource { const res = await makeRequest(`https://api.live.bilibili.com/room/v1/Room/get_info?room_id=${id}`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0) + if (body?.code !== 0) throw new Error(`Live API Error: ${body?.msg}`); if (body.data?.live_status !== 1) throw new Error('Room is not live.'); @@ -724,10 +724,10 @@ export default class BilibiliSource { const res = await makeRequest(`https://api.bilibili.com/x/space/wbi/arc/search?${queryParams}`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0) + if (body?.code !== 0) throw new Error(`Space API Error: ${body?.message}`); const list = body.data?.list?.vlist; if (!list?.length) @@ -803,10 +803,10 @@ export default class BilibiliSource { const res = await makeRequest(`https://www.bilibili.com/audio/music-service-c/web/url?sid=${sid}`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0 || !body.data?.cdns?.[0]) { + if (body?.code !== 0 || !body.data?.cdns?.[0]) { throw new Error('Failed to get audio stream.'); } return { @@ -820,11 +820,10 @@ export default class BilibiliSource { const res = await makeRequest(`https://api.live.bilibili.com/xlive/web-room/v2/index/getRoomPlayInfo?room_id=${roomId}&protocol=0,1&format=0,2&codec=0,1&qn=10000&platform=web&pt=web&no_playurl=0&mask=0`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || - body.code !== 0 || + if (body?.code !== 0 || !body.data?.playurl_info) { throw new Error('Failed to get live stream info.'); } @@ -882,10 +881,10 @@ export default class BilibiliSource { const res = await makeRequest(`https://api.bilibili.com/x/web-interface/view?bvid=${bvid}`, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0 || !body.data) { + if (body?.code !== 0 || !body.data) { throw new Error('Failed to fetch video metadata for stream.'); } const pMatch = track.identifier.match(/\?p=(\d+)/); @@ -902,10 +901,10 @@ export default class BilibiliSource { Referer: 'https://www.bilibili.com/', Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); const body = res.body; - if (!body || body.code !== 0 || !body.data) { + if (body?.code !== 0 || !body.data) { throw new Error(`Playurl API Error: ${body?.message}`); } const { durl, dash } = body.data; @@ -968,7 +967,7 @@ export default class BilibiliSource { type: 'mpegts', localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, startTime: additionalData?.startTime || 0, - proxy: this.config.proxy + proxy: this.config.network?.proxy }), type: 'mpegts' }; @@ -977,7 +976,7 @@ export default class BilibiliSource { method: 'GET', headers, streamOnly: true, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); if (res.error || !res.stream) throw new Error(res.error || 'Failed to get stream.'); diff --git a/dist/src/sources/bluesky.js b/dist/src/sources/bluesky.js index 4cd5125a..552a0a25 100644 --- a/dist/src/sources/bluesky.js +++ b/dist/src/sources/bluesky.js @@ -1,7 +1,7 @@ import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { parse as parsePlaylist } from "../playback/hls/PlaylistParser.js"; -import { encodeTrack, http1makeRequest, logger, makeRequest } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { parse as parsePlaylist } from '../playback/hls/PlaylistParser.js'; +import { encodeTrack, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Bluesky source implementation. */ @@ -31,9 +31,8 @@ export default class BlueskySource { const options = nodelink.options; this.nodelink = nodelink; this.config = { - maxSearchResults: typeof options.maxSearchResults === 'number' - ? options.maxSearchResults - : undefined + maxSearchResults: options.sources?.bluesky + ?.maxSearchResults ?? options.search?.maxResults }; this.searchTerms = ['bksearch']; this.patterns = [ diff --git a/dist/src/sources/deezer.js b/dist/src/sources/deezer.js index 747ff1d3..24075f23 100644 --- a/dist/src/sources/deezer.js +++ b/dist/src/sources/deezer.js @@ -1,8 +1,8 @@ import { Buffer } from 'node:buffer'; import crypto from 'node:crypto'; import { PassThrough } from 'node:stream'; -import BlowfishCBC from "../decrypters/blowfish-cbc.js"; -import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from "../utils.js"; +import BlowfishCBC from '../decrypters/blowfish-cbc.js'; +import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Static IV used by Deezer's Blowfish-CBC chunk decryption scheme. */ @@ -34,7 +34,7 @@ export default class DeezerSource { /** * Search aliases handled by this source. */ - searchTerms = ['dzsearch']; + searchTerms = ['dzsearch', 'dzisrc']; /** * Recommendation aliases handled by this source. */ @@ -289,7 +289,7 @@ export default class DeezerSource { if (tracks.length === 0) return { loadType: 'empty', data: {} }; return { - loadType: type, + loadType: 'playlist', data: { info: { name: entity.title ?? 'Unknown Deezer Collection', @@ -397,7 +397,26 @@ export default class DeezerSource { } } catch (error) { - logger('warn', 'Deezer', `Direct stream failed for ${decodedTrack.title}: ${this.getErrorMessage(error)}. Falling back to default search.`); + const errMsg = this.getErrorMessage(error); + if (errMsg.toLowerCase().includes('csrf') && !forceRefresh) { + logger('warn', 'Deezer', `CSRF token expired (${errMsg}). Evicting cache and refreshing credentials...`); + const cm = this.nodelink.credentialManager; + cm?.delete?.('deezer_csrf_token'); + cm?.delete?.('deezer_license_token'); + cm?.delete?.('deezer_cookie'); + this.csrfToken = null; + this.licenseToken = null; + this.cookie = null; + const success = await this.performSetup(); + if (success && this.cookie && this.csrfToken && this.licenseToken) { + logger('info', 'Deezer', 'Credentials refreshed. Retrying direct stream...'); + return this.getTrackUrl(decodedTrack, _itag, true); + } + logger('warn', 'Deezer', 'Failed to refresh credentials. Falling back to search.'); + } + else { + logger('warn', 'Deezer', `Direct stream failed for ${decodedTrack.title}: ${errMsg}. Falling back to default search.`); + } } } const sourceManager = this.getSourceManager(); @@ -951,7 +970,7 @@ export default class DeezerSource { * @returns Maximum number of search results to return. */ getMaxSearchResults() { - const limit = this.config.maxSearchResults; + const limit = this.config.search?.maxResults; return typeof limit === 'number' && limit > 0 ? limit : 10; } /** @@ -961,7 +980,7 @@ export default class DeezerSource { * @returns Maximum collection length for albums, playlists, or artists. */ getMaxCollectionLength(fallback) { - const limit = this.config.maxAlbumPlaylistLength; + const limit = this.config.playback?.maxPlaylistLength; return typeof limit === 'number' && limit > 0 ? limit : fallback; } /** diff --git a/dist/src/sources/eternalbox.js b/dist/src/sources/eternalbox.js index f463f11d..3f0529fc 100644 --- a/dist/src/sources/eternalbox.js +++ b/dist/src/sources/eternalbox.js @@ -1,6 +1,6 @@ import { PassThrough } from 'node:stream'; import * as MP4Box from 'mp4box'; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * Common sampling rates for AAC audio. * @internal @@ -129,7 +129,7 @@ export default class EternalboxSource { return this.resolve(this._buildJukeboxUrl(query)); } const limit = this.config.searchResults || - this.nodelink.options.maxSearchResults || + this.nodelink.options.search.maxResults || 10; const url = `${this.baseUrl}/api/analysis/search?query=${encodeURIComponent(query)}&results=${limit}`; try { diff --git a/dist/src/sources/flowery.js b/dist/src/sources/flowery.js index ced14ecf..5d1a1b80 100644 --- a/dist/src/sources/flowery.js +++ b/dist/src/sources/flowery.js @@ -1,6 +1,6 @@ -import { PassThrough } from 'node:stream'; +import { PassThrough, pipeline } from 'node:stream'; import { URL } from 'node:url'; -import { encodeTrack, logger, makeRequest } from "../utils.js"; +import { encodeTrack, logger, makeRequest } from '../utils.js'; /** * Flowery TTS source implementation. */ @@ -525,15 +525,18 @@ export default class FlowerySource { throw new Error(`Flowery TTS returned status ${response.statusCode}`); } const stream = new PassThrough(); - response.stream.pipe(stream); - response.stream.on('end', () => { - stream.emit('finishBuffering'); + stream.once('close', () => { + ; + response.stream.destroy?.(); }); - response.stream.on('error', (error) => { - logger('error', 'Sources', `Flowery TTS stream error: ${error.message}`); - if (!stream.destroyed) { - stream.destroy(error); + pipeline(response.stream, stream, (error) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Sources', `Flowery TTS stream error: ${error.message}`); + } + return; } + stream.emit('finishBuffering'); }); return { stream }; } diff --git a/dist/src/sources/gaana.js b/dist/src/sources/gaana.js index 58409417..c8352a2e 100644 --- a/dist/src/sources/gaana.js +++ b/dist/src/sources/gaana.js @@ -1,8 +1,8 @@ import { createDecipheriv } from 'node:crypto'; import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { parse as parsePlaylist } from "../playback/hls/PlaylistParser.js"; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { parse as parsePlaylist } from '../playback/hls/PlaylistParser.js'; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'; const API_URL = 'https://gaana.com/apiv2'; const STREAM_URL_API = 'https://gaana.com/api/stream-url'; @@ -60,16 +60,16 @@ export default class GaanaSource { */ constructor(nodelink) { this.nodelink = nodelink; - const sourceConfig = this.asRecord(this.nodelink.options.sources?.gaana); - this.config = sourceConfig || {}; + const sourceConfig = this.nodelink.options.sources.gaana; + this.config = sourceConfig; this.searchTerms = ['gnsearch', 'gaanasearch']; this.patterns = [ /^@?(?:https?:\/\/)?(?:www\.)?gaana\.com\/(?song|album|playlist|artist)\/(?[\w-]+)(?:[?#].*)?$/ ]; this.priority = 70; this.maxSearchResults = - this.asNumber(this.nodelink.options.maxSearchResults) ?? 10; - const maxAlbumPlaylistLength = this.asNumber(this.nodelink.options.maxAlbumPlaylistLength) ?? 100; + this.asNumber(this.nodelink.options.search.maxResults) ?? 10; + const maxAlbumPlaylistLength = this.asNumber(this.nodelink.options.playback.maxPlaylistLength) ?? 100; this.playlistLoadLimit = this.asNumber(this.config.playlistLoadLimit) ?? maxAlbumPlaylistLength; this.albumLoadLimit = @@ -832,7 +832,7 @@ export default class GaanaSource { * @returns Proxy configuration object or null. */ getProxyConfig() { - const proxy = this.asRecord(this.config.proxy); + const proxy = this.asRecord(this.config.network?.proxy); const url = this.asString(proxy?.url); if (!url) return undefined; diff --git a/dist/src/sources/genius.js b/dist/src/sources/genius.js index d7538efb..41325a66 100644 --- a/dist/src/sources/genius.js +++ b/dist/src/sources/genius.js @@ -1,4 +1,4 @@ -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const GENIUS_HEADERS = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36', Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8', diff --git a/dist/src/sources/google-tts.js b/dist/src/sources/google-tts.js index b72dc722..a3d5c7b0 100644 --- a/dist/src/sources/google-tts.js +++ b/dist/src/sources/google-tts.js @@ -1,5 +1,5 @@ -import { PassThrough } from 'node:stream'; -import { encodeTrack, logger, makeRequest } from "../utils.js"; +import { PassThrough, pipeline } from 'node:stream'; +import { encodeTrack, logger, makeRequest } from '../utils.js'; /** * Google TTS source implementation. */ @@ -37,7 +37,7 @@ export default class GoogleTTSSource { this.nodelink = nodelink; this.config = this.getConfig(); this.language = this.config.language ?? 'en-US'; - this.searchTerms = ['gtts', 'speak']; + this.searchTerms = ['gtts', 'speak', 'tts']; this.baseUrl = 'https://translate.google.com'; this.priority = 50; } @@ -246,15 +246,18 @@ export default class GoogleTTSSource { throw new Error(`Google TTS returned status ${response.statusCode}`); } const stream = new PassThrough(); - response.stream.pipe(stream); - response.stream.on('end', () => { - stream.emit('finishBuffering'); + stream.once('close', () => { + ; + response.stream.destroy?.(); }); - response.stream.on('error', (error) => { - logger('error', 'Sources', `Google TTS stream error: ${error.message}`); - if (!stream.destroyed) { - stream.destroy(error); + pipeline(response.stream, stream, (error) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Sources', `Google TTS stream error: ${error.message}`); + } + return; } + stream.emit('finishBuffering'); }); return { stream }; } diff --git a/dist/src/sources/googledrive.js b/dist/src/sources/googledrive.js index 33a3a3ef..d6375168 100644 --- a/dist/src/sources/googledrive.js +++ b/dist/src/sources/googledrive.js @@ -1,6 +1,6 @@ import crypto from 'node:crypto'; import { PassThrough } from 'node:stream'; -import { encodeTrack, http1makeRequest, logger, makeRequest } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Google Drive source implementation. * Follows HttpSource pattern. diff --git a/dist/src/sources/http.js b/dist/src/sources/http.js index 5f6933cb..0b1c8d65 100644 --- a/dist/src/sources/http.js +++ b/dist/src/sources/http.js @@ -1,5 +1,5 @@ import { PassThrough, Transform } from 'node:stream'; -import { encodeTrack, getVersion, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getVersion, http1makeRequest, logger } from '../utils.js'; /** * Default user agent for HTTP source requests. * @internal @@ -214,6 +214,9 @@ export default class HttpSource { let data = await http1makeRequest(url, { method: 'HEAD', headers: requestHeaders + }).catch((err) => { + logger('warn', 'HTTP Source', `HEAD request failed for URL: ${url} with error: ${err.message} - falling back to GET request (this is expected for some servers that do not support HEAD)`); + return { error: err }; }); const headContentType = headerToString(data.headers?.['content-type']); const headOk = !data.error && diff --git a/dist/src/sources/iheartradio.js b/dist/src/sources/iheartradio.js index 14a53253..257111f3 100644 --- a/dist/src/sources/iheartradio.js +++ b/dist/src/sources/iheartradio.js @@ -1,4 +1,4 @@ -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const IHEART_API_V2 = 'https://us.api.iheart.com/api/v2'; const IHEART_API_V1 = 'https://api2.iheart.com/api/v1'; const IHEART_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'; @@ -46,10 +46,10 @@ export default class IheartradioSource { this.nodelink = nodelink; const options = nodelink.options; this.maxSearchResults = - typeof options.maxSearchResults === 'number' && - Number.isInteger(options.maxSearchResults) && - options.maxSearchResults > 0 - ? options.maxSearchResults + typeof options.search?.maxResults === 'number' && + Number.isInteger(options.search?.maxResults) && + options.search?.maxResults > 0 + ? options.search.maxResults : 10; } /** diff --git a/dist/src/sources/instagram.js b/dist/src/sources/instagram.js index 6d70ad02..3db08024 100644 --- a/dist/src/sources/instagram.js +++ b/dist/src/sources/instagram.js @@ -1,6 +1,6 @@ import { PassThrough } from 'node:stream'; import { URLSearchParams } from 'node:url'; -import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Instagram source implementation. * @@ -135,11 +135,15 @@ export default class InstagramSource { if (!value) return value; return value - .replace(/&/g, '&') + .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => String.fromCodePoint(Number.parseInt(hex, 16))) + .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec))) + .replace(/&/g, '&') .replace(/'/g, "'") - .replace(/"/g, '"') - .replace(/</g, '<') - .replace(/>/g, '>') + .replace(/"/g, '"') + .replace(//g, '>') + .replace(/'/g, "'") + .replace(/ /g, ' ') .trim(); } /** @@ -549,7 +553,7 @@ export default class InstagramSource { 'X-FB-LSD': this.apiConfig.fbLsd ?? '', 'X-ASBD-ID': '129477', 'Sec-Fetch-Site': 'same-origin', - 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36', + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', Origin: 'https://www.instagram.com', Referer: `https://www.instagram.com/reels/audio/${audioId}/` }; @@ -644,6 +648,11 @@ export default class InstagramSource { audioInfo = metadata?.music_info; infoSource = 'music_info'; } + if (!audioInfo) { + const items = payload?.items; + audioInfo = items?.[0]?.media?.clips_metadata?.music_info; + infoSource = 'music_info'; + } if (!audioInfo) { return { data: null, @@ -669,7 +678,11 @@ export default class InstagramSource { else { const musicAsset = audioInfo.music_asset_info; const musicConsumption = audioInfo.music_consumption_info; - audioUrl = musicAsset?.progressive_download_url || null; + audioUrl = + musicAsset?.fast_start_progressive_download_url || + audioInfo.progressive_download_url || + null; + // there is no difference between fast_start and progressive, but fast_start always appears first so. if (!audioUrl && musicConsumption?.dash_manifest) { const urlMatch = String(musicConsumption.dash_manifest).match(/(.*?)<\/BaseURL>/); if (urlMatch?.[1]) { @@ -679,10 +692,17 @@ export default class InstagramSource { if (!audioUrl) { audioUrl = audioInfo.progressive_download_url || null; } - artist = musicAsset?.artist_name || 'User Unknown'; + artist = + musicAsset?.display_artist || + musicAsset?.artist_name || + 'User Unknown'; title = musicAsset?.title || 'Instagram Audio'; duration = musicAsset?.duration_in_ms || 0; - thumbnail = musicAsset?.cover_artwork_thumbnail_uri || ''; + // cover_artwork_uri gives better quality i see. + thumbnail = + musicAsset?.cover_artwork_uri || + audioInfo.cover_artwork_thumbnail_uri || + ''; } if (!audioUrl) { return { @@ -706,6 +726,73 @@ export default class InstagramSource { exception: null }; } + /** + * Fetches a video from Instagram's logged-out clips query. + * + * @param postId - Instagram shortcode for the video. + * @returns Video data when found, otherwise `null`. + */ + async _fetchFromClipsQuery(postId) { + try { + const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'; + let mediaId = 0n; + for (const character of postId) { + mediaId = mediaId * 64n + BigInt(alphabet.indexOf(character)); + } + const variables = JSON.stringify({ + data: { + chaining_mode: 'same_author', + clips_media_id: mediaId.toString() + }, + __relay_internal__pv__PolarisReelsRecoDebugOverlayEnabledrelayprovider: false, + __relay_internal__pv__PolarisShortDramaEnabledrelayprovider: false + }); + const query = new URLSearchParams({ + doc_id: '27695069083459414', + variables + }); + const response = await makeRequest(`https://www.instagram.com/graphql/query/?${query.toString()}`, { method: 'GET' }); + if (response.error || response.statusCode !== 200) + return null; + const responseData = typeof response.body === 'string' + ? JSON.parse(response.body) + : response.body; + const edges = responseData.data + ?.xdt_api__v1__clips__clips_on_logged_out_connection_v2?.edges; + const media = edges + ?.map((edge) => edge.node.media) + .find((item) => item?.code === postId); + if (media?.media_type !== 2) + return null; + const videoVersions = media.video_versions; + const videoUrl = videoVersions?.find((version) => typeof version.url === 'string')?.url; + if (!videoUrl) + return null; + const user = media.user; + const caption = media.caption; + const imageVersions = media.image_versions2; + const imageCandidates = imageVersions?.candidates; + const manifest = media.video_dash_manifest; + const manifestDuration = manifest?.match(/mediaPresentationDuration="PT([\d.]+)S"/)?.[1]; + return { + data: { + videoUrl, + author: user?.username || 'User Unknown', + length: Math.round(Number(manifestDuration || 0) * 1000), + thumbnail: imageCandidates?.find((candidate) => typeof candidate.url === 'string')?.url || '', + title: caption?.text || 'Instagram Video', + isStream: false, + isSeekable: true + }, + exception: null + }; + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + logger('debug', 'Sources', `Instagram clips query failed for ${postId}: ${message}`); + return null; + } + } /** * Fetches post/reel media information from the Instagram GraphQL API. * @@ -722,6 +809,8 @@ export default class InstagramSource { exception: { message: 'Post ID not provided', severity: 'common' } }; } + // this no longer works btw... + // only is working from clips, but there are ways to do it on /embed/ too. const headers = { Accept: '*/*', 'Accept-Language': 'en-US,en;q=0.9', @@ -882,18 +971,18 @@ export default class InstagramSource { let trackData = null; let fetchError = null; if (type === 'post') { - ; + const clipsResult = await this._fetchFromClipsQuery(contentId); ({ data: trackData, exception: fetchError } = - await this._fetchFromGraphQL(contentId, pathSegment)); + clipsResult ?? (await this._fetchFromGraphQL(contentId, pathSegment))); } else if (type === 'audio') { ; ({ data: trackData, exception: fetchError } = - await this._fetchAudioOgMetadata(contentId)); + await this._fetchFromAudioAPI(contentId)); if (fetchError) { - logger('debug', 'Sources', `Instagram audio OG metadata fallback triggered for ${contentId}: ${fetchError.message}`); + logger('debug', 'Sources', `Instagram audio API fallback triggered for ${contentId}: ${fetchError.message}`); ({ data: trackData, exception: fetchError } = - await this._fetchFromAudioAPI(contentId)); + await this._fetchAudioOgMetadata(contentId)); } } else { @@ -987,35 +1076,44 @@ export default class InstagramSource { let trackData = null; let fetchError = null; if (type === 'post') { - ; + const clipsResult = await this._fetchFromClipsQuery(contentId); ({ data: trackData, exception: fetchError } = - await this._fetchFromGraphQL(contentId, pathSegment)); + clipsResult ?? (await this._fetchFromGraphQL(contentId, pathSegment))); } else if (type === 'audio') { - let mirrorTrack = track; - let preferredQuery = null; - if (!track.title || - track.title === 'Instagram Audio' || - track.author === 'User Unknown') { - const ogMetadata = await this._fetchAudioOgMetadata(contentId); - if (!ogMetadata.exception && ogMetadata.data) { - mirrorTrack = { - title: ogMetadata.data.title || track.title, - author: ogMetadata.data.author || track.author, - length: track.length, - uri: track.uri - }; - preferredQuery = - ogMetadata.data.searchQuery || null; - } - } - const mirrorResult = await this._resolveAudioMirrorTrack(mirrorTrack, preferredQuery); - if (!mirrorResult?.exception) { - return mirrorResult; - } - logger('warn', 'Sources', `Instagram audio mirror failed for ${contentId}: ${mirrorResult.exception.message}. Falling back to direct stream lookup.`); + ; ({ data: trackData, exception: fetchError } = await this._fetchFromAudioAPI(contentId)); + if (!trackData) { + let mirrorTrack = track; + let preferredQuery = null; + if (!track.title || + track.title === 'Instagram Audio' || + track.author === 'User Unknown') { + const ogMetadata = await this._fetchAudioOgMetadata(contentId); + if (!ogMetadata.exception && ogMetadata.data) { + mirrorTrack = { + title: ogMetadata.data.title || track.title, + author: ogMetadata.data.author || track.author, + length: track.length, + uri: track.uri + }; + preferredQuery = + ogMetadata.data.searchQuery || null; + } + } + const mirrorResult = await this._resolveAudioMirrorTrack(mirrorTrack, preferredQuery); + if (!mirrorResult?.exception) { + return mirrorResult; + } + logger('warn', 'Sources', `Instagram audio mirror failed for ${contentId}: ${mirrorResult.exception.message}.`); + return { + exception: { + message: 'Audio API request failed', + severity: 'common' + } + }; + } } else { return { diff --git a/dist/src/sources/jiosaavn.js b/dist/src/sources/jiosaavn.js index 69469829..b96e0a61 100644 --- a/dist/src/sources/jiosaavn.js +++ b/dist/src/sources/jiosaavn.js @@ -1,6 +1,6 @@ import { PassThrough } from 'node:stream'; -import { desEcbDecryptBase64ToUtf8 } from "../decrypters/des-ecb.js"; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { desEcbDecryptBase64ToUtf8 } from '../decrypters/des-ecb.js'; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const API_BASE = 'https://www.jiosaavn.com/api.php'; const J_BUFFER = Buffer.from('38346591'); const HEADERS = { @@ -289,7 +289,7 @@ export default class JioSaavnSource { const { stream, error, statusCode } = await http1makeRequest(url, { method: 'GET', streamOnly: true, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); if (error || statusCode !== 200 || !stream) { return this.exceptionLoadResult(`Failed to load stream: ${error || statusCode || 'unknown'}`); @@ -333,7 +333,7 @@ export default class JioSaavnSource { const { body, error, statusCode } = await http1makeRequest(url.toString(), { method: 'GET', headers: HEADERS, - proxy: this.config.proxy + proxy: this.config.network?.proxy }); if (error || statusCode !== 200) { throw new Error(`JioSaavn API request failed: ${statusCode || 'unknown'}`); diff --git a/dist/src/sources/kwai.js b/dist/src/sources/kwai.js index e63ee450..268b59cf 100644 --- a/dist/src/sources/kwai.js +++ b/dist/src/sources/kwai.js @@ -1,5 +1,5 @@ -import { PassThrough } from 'node:stream'; -import { encodeTrack, http1makeRequest, logger, makeRequest } from "../utils.js"; +import { PassThrough, pipeline } from 'node:stream'; +import { encodeTrack, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Kwai source implementation. */ @@ -140,15 +140,17 @@ export default class KwaiSource { throw new Error(`Kwai returned status ${response.statusCode}`); } const stream = new PassThrough(); - response.stream.on('data', (chunk) => { - stream.write(chunk); + stream.once('close', () => { + ; + response.stream.destroy?.(); }); - response.stream.on('end', () => { - stream.emit('finishBuffering'); - }); - response.stream.on('error', (error) => { - logger('error', 'Kwai', `Upstream stream error: ${error.message}`); - stream.emit('error', error); + pipeline(response.stream, stream, (error) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Kwai', `Stream error: ${error.message}`); + } + return; + } stream.emit('finishBuffering'); }); return { stream, type: 'mp4' }; @@ -191,7 +193,12 @@ export default class KwaiSource { if (!value) { return null; } - return value.replace(/\\u([\dA-Fa-f]{4})/g, (_match, code) => String.fromCharCode(Number.parseInt(code, 16))); + try { + return JSON.parse(`"${value}"`); + } + catch { + return value; + } } /** * Fetches and parses the Kwai page metadata used by this source. @@ -206,7 +213,7 @@ export default class KwaiSource { const response = await makeRequest(url, { method: 'GET', headers: { - 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3', + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', Accept: '*/*' } }); @@ -217,27 +224,27 @@ export default class KwaiSource { throw new Error('Error fetching video info'); } const body = response.body; - const mediaSection = body.match(/share_info:c,main_mv_urls:\s*\[(.*?)\]/)?.[1]; - const author = body.match(/kwai_id\s*:\s*"([^"]+)"/)?.[1] ?? 'Unknown'; - const durationText = body.match(/duration:\s*([\d]+)/)?.[1]; - let thumbnailUrl = body.match(/poster="([^"]+)"/)?.[1] ?? null; - if (!thumbnailUrl) { - const thumbnailMatch = body.match(/cover_thumbnail_urls:\[\{cdn:p,url:\s*"([^"]+)"/); - thumbnailUrl = this.decodeUnicodeEscapes(thumbnailMatch?.[1] ?? null); + const photoIndex = body.indexOf(`photo_id_str:"${videoId}"`); + if (photoIndex === -1) { + throw new Error('Video data not found in response'); } - if (!mediaSection) { - throw new Error('Video URL not found in response'); - } - const videoUrlMatch = mediaSection.match(/url:\s*"([^"]+)"/)?.[1]; - const videoUrl = this.decodeUnicodeEscapes(videoUrlMatch ?? null); + const entryStart = body.lastIndexOf(']={', photoIndex); + const entryEnd = body.indexOf('};', photoIndex); + const videoData = body.slice(entryStart + 3, entryEnd); + const videoUrl = this.decodeUnicodeEscapes(videoData.match(/main_mv_urls:\[\{[^}]*url:"((?:\\.|[^"])*)"/)?.[1] ?? + null); if (!videoUrl) { - throw new Error('Could not extract video URL'); + throw new Error('Video URL not found in response'); } + const author = this.decodeUnicodeEscapes(videoData.match(/user_name:"((?:\\.|[^"])*)"/)?.[1] ?? null) ?? 'Unknown'; + const title = this.decodeUnicodeEscapes(videoData.match(/caption:"((?:\\.|[^"])*)"/)?.[1] ?? null) ?? (author === 'Unknown' ? 'Kwai Video' : `Kwai - ${author}`); + const durationText = videoData.match(/ext_params:\{[^}]*sound:(\d+)/)?.[1]; + const thumbnail = this.decodeUnicodeEscapes(videoData.match(/cover_thumbnail_urls:\[\{[^}]*url:"((?:\\.|[^"])*)"/)?.[1] ?? null); return { author, - title: author === 'Unknown' ? 'Kwai Video' : `Kwai - ${author}`, - length: durationText ? Number.parseInt(durationText, 10) * 1000 : 0, - thumbnail: thumbnailUrl, + title, + length: durationText ? Number.parseInt(durationText, 10) : 0, + thumbnail, videoUrl }; } diff --git a/dist/src/sources/lastfm.js b/dist/src/sources/lastfm.js index 5416475c..f1dc7299 100644 --- a/dist/src/sources/lastfm.js +++ b/dist/src/sources/lastfm.js @@ -1,4 +1,4 @@ -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const LASTFM_PATTERN = /^https?:\/\/(?:www\.)?last\.fm\/(?:[a-z]{2}\/)?music\/.+/; const YOUTUBE_LINK_PATTERN = /header-new-playlink[^>]*href="([^"]*youtube\.com[^"]+)"/; const YOUTUBE_URL_PATTERN = /https?:\/\/(?:www\.)?youtube\.com\/watch\?v=[a-zA-Z0-9_-]+/; @@ -72,7 +72,7 @@ export default class LastFMSource { } getMaxSearchResults() { const options = this.nodelink.options; - const limit = options.maxSearchResults; + const limit = options.search.maxResults; return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : 10; diff --git a/dist/src/sources/lazypytts.js b/dist/src/sources/lazypytts.js index 4a5046d8..1d78c88a 100644 --- a/dist/src/sources/lazypytts.js +++ b/dist/src/sources/lazypytts.js @@ -1,5 +1,5 @@ import { PassThrough } from 'node:stream'; -import { encodeTrack, logger, makeRequest } from "../utils.js"; +import { encodeTrack, logger, makeRequest } from '../utils.js'; const VOICES_URL = 'https://lazypy.ro/tts/assets/js/voices.json'; const REQUEST_URL = 'https://lazypy.ro/tts/request_tts.php'; const DEFAULT_SERVICE = 'Cerence'; diff --git a/dist/src/sources/letrasmus.js b/dist/src/sources/letrasmus.js index 9c2cdf67..2b3a3879 100644 --- a/dist/src/sources/letrasmus.js +++ b/dist/src/sources/letrasmus.js @@ -1,4 +1,4 @@ -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const LETRAS_PATTERN = /^https?:\/\/(?:www\.)?letras\.(?:mus\.br|com)\/[a-z0-9-]+\/[^/]+\/?/i; const ARTIST_PATTERN = /^https?:\/\/(?:www\.)?letras\.(?:mus\.br|com)\/([a-z0-9-]+)\//i; const SOLR_ENDPOINT = 'https://solr.sscdn.co/letras/m1/'; @@ -141,10 +141,10 @@ export default class LetrasMusSource { this.patterns = [LETRAS_PATTERN]; const options = nodelink.options; this.maxSearchResults = - typeof options.maxSearchResults === 'number' && - Number.isInteger(options.maxSearchResults) && - options.maxSearchResults > 0 - ? options.maxSearchResults + typeof options.search?.maxResults === 'number' && + Number.isInteger(options.search?.maxResults) && + options.search?.maxResults > 0 + ? options.search.maxResults : 10; } /** diff --git a/dist/src/sources/local.js b/dist/src/sources/local.js index 99ad3e2b..ac68169d 100644 --- a/dist/src/sources/local.js +++ b/dist/src/sources/local.js @@ -1,6 +1,6 @@ import fs from 'node:fs'; import path from 'node:path'; -import { encodeTrack, logger } from "../utils.js"; +import { encodeTrack, logger } from '../utils.js'; /** * Mapping between file extensions and the stream types returned by the local * source. diff --git a/dist/src/sources/mixcloud.js b/dist/src/sources/mixcloud.js index 1241c01f..819f6ad6 100644 --- a/dist/src/sources/mixcloud.js +++ b/dist/src/sources/mixcloud.js @@ -1,6 +1,6 @@ import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, http1makeRequest, logger, makeRequest } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger, makeRequest } from '../utils.js'; const DECRYPTION_KEY = 'IFYOUWANTTHEARTISTSTOGETPAIDDONOTDOWNLOADFROMMIXCLOUD'; const MIXCLOUD_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'; const DEFAULT_MAX_RESULTS = 10; @@ -217,7 +217,7 @@ export default class MixcloudSource { }; }) .filter((track) => track.info.uri.length > 0) - .slice(0, this.config.maxSearchResults || DEFAULT_MAX_RESULTS); + .slice(0, this.config.search.maxResults || DEFAULT_MAX_RESULTS); if (tracks.length === 0) return this.emptyResult(); return { loadType: 'search', data: tracks }; @@ -341,7 +341,7 @@ export default class MixcloudSource { let cursor = null; let hasNextPage = true; let playlistName = 'Mixcloud Playlist'; - const maxTracks = this.config.maxAlbumPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH; + const maxTracks = this.config.playback.maxPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH; while (hasNextPage && tracks.length < maxTracks) { const response = await this._request(queryTemplate(cursor)); const body = this.parseObjectBody(response.body); @@ -411,7 +411,7 @@ export default class MixcloudSource { let cursor = null; let hasNextPage = true; let userDisplayName = username; - const maxTracks = this.config.maxAlbumPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH; + const maxTracks = this.config.playback.maxPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH; while (hasNextPage && tracks.length < maxTracks) { const response = await this._request(queryTemplate(cursor)); const body = this.parseObjectBody(response.body); diff --git a/dist/src/sources/monochrome.js b/dist/src/sources/monochrome.js index 47cbde75..7ddcc910 100644 --- a/dist/src/sources/monochrome.js +++ b/dist/src/sources/monochrome.js @@ -1,7 +1,7 @@ import { PassThrough } from 'node:stream'; -import { DASHHandler } from "../playback/dash/DASHHandler.js"; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { DASHHandler } from '../playback/dash/DASHHandler.js'; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * NodeLink audio source provider for Monochrome (Tidal proxy). * @@ -28,6 +28,7 @@ class MonochromeSource { priority = 100; apiInstances = []; streamingInstances = []; + qobuzInstances = []; /** * Initializes the Monochrome source with health-tracked instance pools. * @param nodelink - The worker server context. @@ -51,6 +52,10 @@ class MonochromeSource { 'https://hund.qqdl.site', 'https://api.monochrome.tf' ]; + const defaultQobuzUrls = [ + 'https://qobuz.kennyy.com.br', + 'https://trypt-hifi-dl-456461932686.us-west1.run.app' + ]; const initPool = (urls) => urls.map((url) => ({ url: url.replace(/\/$/, ''), score: 100, @@ -65,8 +70,12 @@ class MonochromeSource { const streamingInstances = this.config.streamingInstances?.length ? this.config.streamingInstances : instances; + const qobuzInstances = this.config.qobuzInstances?.length + ? this.config.qobuzInstances + : defaultQobuzUrls; this.apiInstances = initPool(instances); this.streamingInstances = initPool(streamingInstances); + this.qobuzInstances = initPool(qobuzInstances); this.patterns = [ /^https?:\/\/monochrome\.tf\/(track|album|playlist|artist|video)\/[\w-]+/, /^https?:\/\/(?:www\.)?tidal\.com\/(?:browse\/)?(track|album|playlist|artist|video)\/[\w-]+/ @@ -85,51 +94,12 @@ class MonochromeSource { logger('warn', 'Monochrome', 'Source failed to initialize: No instances available.'); return false; } - logger('info', 'Monochrome', `Initializing latency check for ${apiCount} instances...`); - const checkInstance = async (instance) => { - const start = Date.now(); - try { - const { statusCode } = await http1makeRequest(`${instance.url}/`, { - method: 'GET', - timeout: 3000 - }); - const latency = Date.now() - start; - if (statusCode === 200 || statusCode === 404 || statusCode === 302) { - // Success (or at least reachable) - if (latency < 500) - instance.score = 100; - else if (latency < 1500) - instance.score = 80; - else if (latency < 3000) - instance.score = 50; - else - instance.score = 20; - logger('debug', 'Monochrome', `Instance ${instance.url} - Latency: ${latency}ms, Initial Score: ${instance.score}`); - } - else { - instance.score = 0; - instance.lastFailure = Date.now(); - logger('debug', 'Monochrome', `Instance ${instance.url} - Error: Status ${statusCode}, Score: 0`); - } - } - catch (_e) { - instance.score = 0; - instance.lastFailure = Date.now(); - logger('debug', 'Monochrome', `Instance ${instance.url} - Connection Failed, Score: 0`); - } - }; - await Promise.allSettled(this.apiInstances.map(checkInstance)); - // Sync streaming scores if they use the same URLs for (const s of this.streamingInstances) { const api = this.apiInstances.find((a) => a.url === s.url); if (api) s.score = api.score; } - const reachable = this.apiInstances.filter((i) => i.score > 0).length; - logger('info', 'Monochrome', `Source is ready with ${apiCount} API (${reachable} reachable) and ${streamCount} streaming instances.`); - if (reachable === 0) { - logger('warn', 'Monochrome', 'No reachable Monochrome instances at startup. Source will stay loaded but degraded.'); - } + logger('info', 'Monochrome', `Source is ready with ${apiCount} API and ${streamCount} streaming instances.`); return true; } catch (error) { @@ -331,7 +301,7 @@ class MonochromeSource { } }; } - // 3. Collection resolution (Album/Playlist) with exaustive pagination + // 3. Collection resolution (Album/Playlist) with exhaustive pagination const collectionMatch = url.match(/(album|playlist)\/([a-f0-9-]+|\d+)/); if (collectionMatch) { const type = collectionMatch[1] || ''; @@ -344,7 +314,7 @@ class MonochromeSource { let name = 'Unknown Collection'; while (tracks.length < total && tracks.length < - (this.nodelink.options.maxAlbumPlaylistLength || 1000)) { + (this.nodelink.options.playback.maxPlaylistLength || 1000)) { const res = await this.fetchWithRetry(`/${type}/?id=${id}&offset=${offset}&limit=${limit}`); if (!res) break; @@ -389,6 +359,17 @@ class MonochromeSource { */ async getTrackUrl(track) { const isVideo = track.uri.includes('/video/'); + if (!isVideo && track.isrc) { + const qobuzQuality = this.config.qobuzQuality ?? 6; + const qobuzUrl = await this.fetchQobuzProxyUrl(track.isrc, qobuzQuality); + if (qobuzUrl) { + return { + url: qobuzUrl, + protocol: 'https', + format: qobuzQuality > 5 ? 'audio/flac' : 'audio/mpeg' + }; + } + } const quality = this.config.quality || 'LOSSLESS'; const params = new URLSearchParams({ id: track.identifier, @@ -411,32 +392,28 @@ class MonochromeSource { ? `/video/?${params.toString()}` : `/trackManifests/?${params.toString()}`; const response = await this.fetchWithRetry(endpoint, 'streaming', '2.7'); - if (!response) - return { - exception: { - message: 'Failed to fetch playback manifest', - severity: 'fault' + if (response) { + const uri = this.extractStreamUrl(response); + if (uri) { + const attr = response?.data?.data?.attributes; + if (attr?.trackAudioNormalizationData) { + logger('debug', 'Monochrome', `Normalization for ${track.identifier}: Gain ${attr.trackAudioNormalizationData.replayGain} dB, Peak ${attr.trackAudioNormalizationData.peakAmplitude}`); } - }; - const uri = this.extractStreamUrl(response); - if (!uri) - return { - exception: { - message: 'Failed to extract playable URI from manifest', - severity: 'fault' - } - }; - const attr = response?.data?.data?.attributes; - if (attr?.trackAudioNormalizationData) { - logger('debug', 'Monochrome', `Normalization for ${track.identifier}: Gain ${attr.trackAudioNormalizationData.replayGain} dB, Peak ${attr.trackAudioNormalizationData.peakAmplitude}`); + return { + url: uri, + protocol: uri.includes('.mpd') + ? 'dash' + : uri.includes('.m3u8') + ? 'hls' + : 'http' + }; + } } return { - url: uri, - protocol: uri.includes('.mpd') - ? 'dash' - : uri.includes('.m3u8') - ? 'hls' - : 'http' + exception: { + message: 'Failed to fetch playback manifest', + severity: 'fault' + } }; } /** @@ -597,6 +574,94 @@ class MonochromeSource { return null; } } + /** + * Fetches a direct stream URL from the Qobuz proxy instances. + * Steps: search by ISRC → get track ID → download music. + * @param isrc - Track ISRC code. + * @returns Direct stream URL or null. + * @private + */ + async fetchQobuzProxyUrl(isrc, quality = 6) { + const pool = this.qobuzInstances.filter((i) => i.score > 0); + if (pool.length === 0) { + logger('warn', 'Monochrome', 'No Qobuz proxy instances available.'); + return null; + } + const proxyHeaders = { + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36', + Accept: '*/*', + 'Accept-Language': 'en;q=0.8', + Origin: 'https://monochrome.tf', + Referer: 'https://monochrome.tf/', + Pragma: 'no-cache', + 'Cache-Control': 'no-cache' + }; + for (const instance of pool) { + instance.activeRequests++; + try { + const searchUrl = `${instance.url}/api/get-music?q=${encodeURIComponent(isrc)}&offset=0`; + const { body: searchBody, statusCode: searchStatus } = await http1makeRequest(searchUrl, { + method: 'GET', + timeout: 5000, + headers: proxyHeaders + }); + if (searchStatus !== 200 || !searchBody) { + instance.score = Math.max(instance.score - 10, 0); + instance.failures++; + instance.lastFailure = Date.now(); + continue; + } + const searchData = typeof searchBody === 'string' + ? JSON.parse(searchBody) + : searchBody; + const tracks = searchData?.data + ?.tracks; + const items = tracks?.items; + const track = items?.[0]; + if (!track) { + instance.score = Math.max(instance.score - 5, 0); + continue; + } + const trackId = track.id; + if (!trackId) { + instance.score = Math.max(instance.score - 5, 0); + continue; + } + const downloadUrl = `${instance.url}/api/download-music?track_id=${trackId}&quality=${quality}`; + const { body: downloadBody, statusCode: downloadStatus } = await http1makeRequest(downloadUrl, { + method: 'GET', + timeout: 5000, + headers: proxyHeaders + }); + if (downloadStatus !== 200 || !downloadBody) { + instance.score = Math.max(instance.score - 10, 0); + instance.failures++; + instance.lastFailure = Date.now(); + continue; + } + const downloadData = typeof downloadBody === 'string' + ? JSON.parse(downloadBody) + : downloadBody; + const url = downloadData?.data + ?.url; + if (url) { + instance.score = Math.min(instance.score + 5, 100); + logger('debug', 'Monochrome', `Qobuz proxy resolved track ${isrc} via ${instance.url}`); + return url; + } + instance.score = Math.max(instance.score - 5, 0); + } + catch (e) { + instance.score = Math.max(instance.score - 20, 0); + instance.lastFailure = Date.now(); + logger('error', 'Monochrome', `Qobuz proxy error for ${isrc} on ${instance.url}: ${e instanceof Error ? e.message : String(e)}`); + } + finally { + instance.activeRequests--; + } + } + return null; + } /** * Normalizes a raw track object into NodeLink's TrackInfo structure. * @param t - Raw Tidal track data. diff --git a/dist/src/sources/netease.js b/dist/src/sources/netease.js index 2f90ceff..a292132e 100644 --- a/dist/src/sources/netease.js +++ b/dist/src/sources/netease.js @@ -1,4 +1,4 @@ -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const NETEASE_TRACK_PATTERN = /^https?:\/\/(?:www\.)?music\.163\.com\/?#?\/song\?id=(\d+)/; const NETEASE_ALBUM_PATTERN = /^https?:\/\/(?:www\.)?music\.163\.com\/?#?\/album\?id=(\d+)/; const NETEASE_PLAYLIST_PATTERN = /^https?:\/\/(?:www\.)?music\.163\.com\/?#?\/playlist\?id=(\d+)/; @@ -60,7 +60,7 @@ export default class NeteaseSource { ]; this.priority = 45; this.searchTerms = ['ntsearch']; - this.maxSearchResults = nodelink.options.maxSearchResults || 10; + this.maxSearchResults = nodelink.options.search.maxResults || 10; } /** * Initializes Netease source. diff --git a/dist/src/sources/newgrounds.js b/dist/src/sources/newgrounds.js new file mode 100644 index 00000000..a5b65fcf --- /dev/null +++ b/dist/src/sources/newgrounds.js @@ -0,0 +1,322 @@ +import { PassThrough, pipeline } from 'node:stream'; +import { encodeTrack, logger, makeRequest } from '../utils.js'; +const NEWGROUNDS_AUDIO_PATTERN = /^https?:\/\/(?:www\.)?newgrounds\.com\/audio\/listen\/(\d+)(?:[/?#]|$)/i; +const NEWGROUNDS_BASE_URL = 'https://www.newgrounds.com'; +const NEWGROUNDS_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36'; +/** + * Resolves and streams tracks from the Newgrounds Audio Portal. + * @public + */ +export default class NewgroundsSource { + nodelink; + patterns = [NEWGROUNDS_AUDIO_PATTERN]; + priority = 50; + /** + * Creates a Newgrounds source bound to the worker runtime. + * @param nodelink - Worker runtime shared with all sources. + */ + constructor(nodelink) { + this.nodelink = nodelink; + } + /** + * Initializes the Newgrounds source. + * @returns Always `true`; this source requires no credentials. + */ + async setup() { + logger('info', 'Sources', 'Loaded Newgrounds source.'); + return true; + } + /** + * Resolves a Newgrounds Audio Portal listen page. + * @param url - Newgrounds listen-page URL. + * @returns A normalized track, an empty result, or an extraction error. + */ + async resolve(url) { + if (!NEWGROUNDS_AUDIO_PATTERN.test(url)) { + return { loadType: 'empty', data: {} }; + } + try { + const audio = await this._fetchAudioPage(url); + if (!audio) + return { loadType: 'empty', data: {} }; + const canonicalUrl = this._buildListenUrl(audio.identifier); + const artworkUrl = this._buildArtworkUrl(audio.identifier, audio.version); + const info = { + identifier: audio.identifier, + isSeekable: true, + author: audio.author, + length: Math.round(audio.duration * 1000), + isStream: false, + position: 0, + title: audio.title, + uri: canonicalUrl, + artworkUrl, + isrc: null, + sourceName: 'newgrounds' + }; + const encodedInput = { ...info, details: [] }; + return { + loadType: 'track', + data: { + encoded: encodeTrack(encodedInput), + info, + pluginInfo: {} + } + }; + } + catch (error) { + const message = this._getErrorMessage(error); + logger('error', 'Newgrounds', `Failed to resolve audio: ${message}`); + return { + loadType: 'error', + exception: { + message, + severity: 'fault', + cause: 'Newgrounds page extraction failed' + } + }; + } + } + /** + * Refreshes the direct Newgrounds media URL before playback. + * @param track - Decoded Newgrounds track metadata. + * @returns The direct audio URL or a structured exception. + */ + async getTrackUrl(track) { + try { + if (!/^\d+$/.test(track.identifier)) { + throw new Error('Invalid Newgrounds audio identifier'); + } + const audio = await this._fetchAudioPage(this._buildListenUrl(track.identifier)); + if (!audio) { + const directory = Math.floor(Number(track.identifier) / 1000) * 1000; + const title = track.title + .trim() + .replace(/[^\p{L}\p{N}\s-]/gu, '') + .replace(/\s+/g, '-'); + const version = track.artworkUrl?.match(/[?&]f(\d+)/)?.[1]; + if (!title) + throw new Error('Newgrounds audio is unavailable'); + return { + url: `https://audio-download.ngfiles.com/${directory}/${track.identifier}_${title}.mp3${version ? `?f${version}` : ''}`, + protocol: 'https', + format: 'mp3' + }; + } + return { + url: audio.streamUrl, + protocol: 'https', + format: 'mp3' + }; + } + catch (error) { + return { + exception: { + message: this._getErrorMessage(error), + severity: 'fault', + cause: 'Newgrounds stream extraction failed' + } + }; + } + } + /** + * Opens a Newgrounds audio stream for playback. + * @param track - Decoded track metadata used for request context. + * @param url - Direct Newgrounds media URL. + * @returns A readable MP3 stream or a structured exception. + */ + async loadStream(track, url) { + try { + const response = await makeRequest(url, { + method: 'GET', + streamOnly: true, + headers: { + Accept: 'audio/mpeg,audio/*;q=0.9,*/*;q=0.8', + Referer: track.uri, + 'User-Agent': NEWGROUNDS_USER_AGENT + } + }); + if (response.error || + !response.statusCode || + response.statusCode < 200 || + response.statusCode >= 300 || + !response.stream) { + throw new Error(response.error || + `Newgrounds returned stream status ${response.statusCode ?? 'unknown'}`); + } + const stream = new PassThrough(); + stream.once('close', () => { + ; + response.stream.destroy?.(); + }); + pipeline(response.stream, stream, (error) => { + if (error && error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Newgrounds', `Stream error: ${error.message}`); + } + }); + return { stream, type: 'audio/mpeg' }; + } + catch (error) { + const message = this._getErrorMessage(error); + logger('error', 'Newgrounds', `Failed to load stream: ${message}`); + return { + exception: { + message, + severity: 'fault', + cause: 'Newgrounds stream request failed' + } + }; + } + } + /** + * Fetches and parses the player payload embedded in a listen page. + * @param url - Newgrounds listen-page URL. + * @returns Parsed audio metadata, or `null` for a missing submission. + * @internal + */ + async _fetchAudioPage(url) { + const response = await makeRequest(url, { + method: 'GET', + headers: { + Accept: 'text/html,application/xhtml+xml', + 'User-Agent': NEWGROUNDS_USER_AGENT + } + }); + if (response.statusCode === 403) { + const identifier = url.match(NEWGROUNDS_AUDIO_PATTERN)?.[1]; + if (!identifier) + return null; + const previewResponse = await makeRequest(`https://cardyb.bsky.app/v1/extract?url=${encodeURIComponent(url)}`, { + method: 'GET', + headers: { 'User-Agent': NEWGROUNDS_USER_AGENT } + }); + const preview = previewResponse.body; + const title = preview.title?.trim(); + if (previewResponse.statusCode !== 200 || preview.error || !title) { + return null; + } + const directory = Math.floor(Number(identifier) / 1000) * 1000; + const filename = title + .replace(/[^\p{L}\p{N}\s-]/gu, '') + .replace(/\s+/g, '-'); + return { + identifier, + streamUrl: `https://audio-download.ngfiles.com/${directory}/${identifier}_${filename}.mp3`, + version: Number(preview.image?.match(/f(\d+)/)?.[1] || 0), + duration: 0, + title, + author: 'Unknown Artist' + }; + } + if (response.statusCode === 404) + return null; + if (response.error || response.statusCode !== 200) { + throw new Error(response.error || + `Newgrounds returned page status ${response.statusCode ?? 'unknown'}`); + } + const html = this._getResponseText(response.body); + if (!html) + throw new Error('Newgrounds returned an unreadable page'); + const playerMatch = html.match(/NgAudioPlayer\.fromListenPage\(\s*\{([\s\S]*?)\}\s*,\s*\d+\s*\)/); + const player = playerMatch?.[1]; + if (!player) + return null; + const identifier = this._extractNumber(player, 'generic_id'); + const streamUrl = this._extractString(player, 'url'); + const version = this._extractNumber(player, 'version'); + const duration = this._extractNumber(player, 'duration'); + const title = this._extractString(player, 'title'); + const author = this._extractString(player, 'author'); + if (identifier === null || + !streamUrl || + version === null || + duration === null || + !title || + !author) { + throw new Error('Newgrounds player metadata is incomplete'); + } + return { + identifier: String(identifier), + streamUrl: streamUrl.startsWith('//') ? `https:${streamUrl}` : streamUrl, + version, + duration, + title, + author + }; + } + /** + * Extracts a JSON-encoded string field from the player object literal. + * @param player - Player object literal body. + * @param field - Field name to extract. + * @returns Decoded field value, or `null` when absent or invalid. + * @internal + */ + _extractString(player, field) { + const match = player.match(new RegExp(`['"]${field}['"]\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`)); + if (!match?.[1]) + return null; + try { + const value = JSON.parse(match[1]); + return typeof value === 'string' && value ? value : null; + } + catch { + return null; + } + } + /** + * Extracts a finite numeric field from the player object literal. + * @param player - Player object literal body. + * @param field - Field name to extract. + * @returns Numeric field value, or `null` when absent or invalid. + * @internal + */ + _extractNumber(player, field) { + const match = player.match(new RegExp(`['"]${field}['"]\\s*:\\s*(-?\\d+(?:\\.\\d+)?)`)); + if (!match?.[1]) + return null; + const value = Number(match[1]); + return Number.isFinite(value) ? value : null; + } + /** + * Converts a request body into HTML text. + * @param body - Response body returned by the request helper. + * @returns UTF-8 text, or `null` for an unsupported body value. + * @internal + */ + _getResponseText(body) { + if (typeof body === 'string') + return body; + if (Buffer.isBuffer(body)) + return body.toString('utf8'); + return null; + } + /** + * Builds the canonical listen-page URL for an audio identifier. + * @param identifier - Newgrounds audio identifier. + * @returns Canonical listen-page URL. + * @internal + */ + _buildListenUrl(identifier) { + return `${NEWGROUNDS_BASE_URL}/audio/listen/${identifier}`; + } + /** + * Builds the medium-size Newgrounds audio thumbnail URL. + * @param identifier - Newgrounds audio identifier. + * @param version - Media version used for cache busting. + * @returns Medium-size artwork URL. + * @internal + */ + _buildArtworkUrl(identifier, version) { + const directory = Math.floor(Number(identifier) / 1000); + return `https://aicon.ngfiles.com/${directory}/${identifier}_medium.png?f${version}`; + } + /** + * Normalizes unknown exceptions into loggable messages. + * @param error - Caught exception value. + * @returns Human-readable error message. + * @internal + */ + _getErrorMessage(error) { + return error instanceof Error ? error.message : String(error); + } +} diff --git a/dist/src/sources/nicovideo.js b/dist/src/sources/nicovideo.js index 53547aa9..bc0a3990 100644 --- a/dist/src/sources/nicovideo.js +++ b/dist/src/sources/nicovideo.js @@ -1,5 +1,5 @@ -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * NicoVideo source implementation. */ diff --git a/dist/src/sources/pandora.js b/dist/src/sources/pandora.js index 8c20e955..56082b8c 100644 --- a/dist/src/sources/pandora.js +++ b/dist/src/sources/pandora.js @@ -3,7 +3,7 @@ * Provides search, playlist, station, artist, and podcast resolution. * @module sources/pandora */ -import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Default credential cache TTL (24 hours). * @internal @@ -270,7 +270,7 @@ export default class PandoraSource { types: ['TR'], listener: null, start: 0, - count: this.options.maxSearchResults ?? 10, + count: this.options.search.maxResults ?? 10, annotate: true, searchTime: 0, annotationRecipe: 'CLASS_OF_2019' @@ -424,7 +424,7 @@ export default class PandoraSource { * @internal */ getMaxPlaylistLength() { - return this.options.maxAlbumPlaylistLength ?? 100; + return (this.options.playback.maxPlaylistLength ?? 100); } /** * Resolves an artist, album, or track by ID. @@ -831,8 +831,7 @@ export default class PandoraSource { } try { let searchResult = await sources.searchWithDefault(decodedTrack.isrc ? `"${decodedTrack.isrc}"` : query); - if (!searchResult || - searchResult.loadType !== 'search' || + if (searchResult?.loadType !== 'search' || !Array.isArray(searchResult.data) || searchResult.data.length === 0) { searchResult = await sources.searchWithDefault(query); diff --git a/dist/src/sources/pinterest.js b/dist/src/sources/pinterest.js index cb36ec90..10229781 100644 --- a/dist/src/sources/pinterest.js +++ b/dist/src/sources/pinterest.js @@ -1,5 +1,6 @@ import { PassThrough } from 'node:stream'; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * Pinterest source implementation. */ @@ -152,10 +153,10 @@ export default class PinterestSource { null); } /** - * Selects the first MP4-compatible format from the Pinterest payload. + * Selects the first MP4 or HLS format from the Pinterest payload. * * @param videoList - Available Pinterest video variants. - * @returns First playable MP4-capable format, or `null` when none are found. + * @returns First playable format, or `null` when none are found. */ getPlayableFormat(videoList) { if (!videoList) { @@ -168,7 +169,7 @@ export default class PinterestSource { if (videoList.V_360P?.url) return videoList.V_360P; for (const format of Object.values(videoList)) { - if (format?.url?.endsWith('.mp4')) { + if (format?.url?.includes('.mp4') || format?.url?.includes('.m3u8')) { return format; } } @@ -298,7 +299,7 @@ export default class PinterestSource { * @param decodedTrack - Decoded track information previously returned by the * resolver. * @returns Direct HTTP track URL and its container metadata. - * @throws Error when Pinterest does not expose a playable MP4 stream. + * @throws Error when Pinterest does not expose a playable media stream. */ async getTrackUrl(decodedTrack) { const videoId = decodedTrack.identifier; @@ -309,9 +310,14 @@ export default class PinterestSource { } const format = this.getPlayableFormat(this.getVideoList(data)); if (!format?.url) { - throw new Error('No MP4 format found for Pinterest video'); + throw new Error('No playable format found for Pinterest video'); } - return { url: format.url, protocol: 'http', format: 'mp4' }; + const isHls = format.url.includes('.m3u8'); + return { + url: format.url, + protocol: isHls ? 'hls' : 'http', + format: 'mp4' + }; } catch (error) { const message = error instanceof Error ? error.message : 'Failed to get track URL.'; @@ -328,20 +334,35 @@ export default class PinterestSource { * * @param _decodedTrack - Decoded track metadata, unused by this source. * @param url - Direct media URL returned by `getTrackUrl(...)`. - * @param _protocol - Protocol hint, unused by this source. - * @param _additionalData - Additional stream metadata, unused by this source. + * @param protocol - Protocol hint returned by `getTrackUrl(...)`. + * @param additionalData - Additional stream metadata. * @returns Playable stream payload, or an exception object when the upstream * request fails. */ - async loadStream(_decodedTrack, url, _protocol, _additionalData) { + async loadStream(_decodedTrack, url, protocol, additionalData) { try { + const headers = { + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', + Accept: '*/*' + }; + if (protocol === 'hls' || url.includes('.m3u8')) { + return { + stream: new HLSHandler(url, { + type: 'fmp4', + strategy: 'segmented', + headers, + localAddress: this.nodelink.routePlanner?.getIP?.() ?? null, + startTime: typeof additionalData?.startTime === 'number' + ? additionalData.startTime + : 0 + }), + type: 'mp4' + }; + } const response = await http1makeRequest(url, { method: 'GET', streamOnly: true, - headers: { - 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3', - Accept: '*/*' - } + headers }); if (response.error || !response.stream) { throw new Error(typeof response.error === 'string' && response.error.length > 0 diff --git a/dist/src/sources/pipertts.js b/dist/src/sources/pipertts.js index 7a6b6448..81eb6c7e 100644 --- a/dist/src/sources/pipertts.js +++ b/dist/src/sources/pipertts.js @@ -1,5 +1,5 @@ -import { PassThrough } from 'node:stream'; -import { encodeTrack, logger, makeRequest } from "../utils.js"; +import { PassThrough, pipeline } from 'node:stream'; +import { encodeTrack, logger, makeRequest } from '../utils.js'; /** * Piper TTS source implementation. */ @@ -259,15 +259,18 @@ export default class PiperSource { throw new Error(`Piper TTS returned status ${response.statusCode}`); } const stream = new PassThrough(); - response.stream.pipe(stream); - response.stream.on('end', () => { - stream.emit('finishBuffering'); + stream.once('close', () => { + ; + response.stream.destroy?.(); }); - response.stream.on('error', (error) => { - logger('error', 'Sources', `Piper TTS stream error: ${error.message}`); - if (!stream.destroyed) { - stream.destroy(error); + pipeline(response.stream, stream, (error) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Sources', `Piper TTS stream error: ${error.message}`); + } + return; } + stream.emit('finishBuffering'); }); return { stream, type: 'wav' }; } diff --git a/dist/src/sources/qobuz.js b/dist/src/sources/qobuz.js index 9cc1680a..a46a78b1 100644 --- a/dist/src/sources/qobuz.js +++ b/dist/src/sources/qobuz.js @@ -1,5 +1,5 @@ import crypto from 'node:crypto'; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const API_URL = 'https://www.qobuz.com/api.json/0.2'; const WEB_PLAYER_BASE_URL = 'https://play.qobuz.com'; /** @@ -54,7 +54,7 @@ export default class QobuzSource { constructor(nodelink) { this.nodelink = nodelink; this.config = nodelink.options; - this.searchTerms = ['qbsearch']; + this.searchTerms = ['qbsearch', 'qbisrc']; this.recommendationTerm = ['qbrec']; this.patterns = [ /https?:\/\/(?:www\.|play\.|open\.)?qobuz\.com\/(?:(?:[a-z]{2}-[a-z]{2}\/)?(track|album|playlist|artist)\/(?:.+?\/)?([a-zA-Z0-9]+)|(playlist)\/(\d+))/ @@ -631,14 +631,14 @@ export default class QobuzSource { * @returns Max search size. */ getMaxSearchResults() { - return this.asNumber(this.config.maxSearchResults) ?? 10; + return this.asNumber(this.config.search.maxResults) ?? 10; } /** * Reads max playlist/album load size from runtime config. * @returns Max playlist size. */ getMaxAlbumPlaylistLength() { - return this.asNumber(this.config.maxAlbumPlaylistLength) ?? 100; + return this.asNumber(this.config.playback.maxPlaylistLength) ?? 100; } /** * Converts unknown search results into TrackInfo list. diff --git a/dist/src/sources/reddit.js b/dist/src/sources/reddit.js index 5c3f9663..d96b5f31 100644 --- a/dist/src/sources/reddit.js +++ b/dist/src/sources/reddit.js @@ -1,7 +1,9 @@ -import { PassThrough } from 'node:stream'; -import { encodeTrack, logger, makeRequest } from "../utils.js"; -const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'; +import { PassThrough, pipeline } from 'node:stream'; +import { encodeTrack, logger, makeRequest } from '../utils.js'; +const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36'; const REDDIT_BASE = 'https://www.reddit.com'; +const LOID_CACHE_KEY = 'reddit_loid'; +const LOID_FALLBACK_TTL_MS = 24 * 60 * 60 * 1000; const COMMENTS_REGEX = /\/comments\/([^/?]+)/; const VIDEO_REGEX = /\/video\/([^/?]+)/; const SHARE_REGEX = /\/r\/([^/]+)\/s\/([^/?]+)/; @@ -34,6 +36,56 @@ async function resolveRedirectingUrl(url, headers) { const finalUrl = new URL(location, url).toString(); return COMMENTS_REGEX.exec(finalUrl)?.[1] ?? null; } +async function getLoid(nodelink) { + // seems like a loid cookie can take up 2+ years to expire... idk why but it does... + const cachedLoid = nodelink.credentialManager?.get(LOID_CACHE_KEY) ?? null; + if (cachedLoid) { + return cachedLoid; + } + try { + const res = await makeRequest(`${REDDIT_BASE}/`, { + headers: { 'User-Agent': USER_AGENT } + }); + if (res.error) { + return null; + } + const text = (await res.body); + const token = /name="token"\s+value="([^"]+)"/.exec(text)?.[1]; + const secret = /await\([^)]*\)\("([0-9a-f]+)"\)/.exec(text)?.[1]; + if (!token || !secret) { + return null; + } + const url = new URL(`${REDDIT_BASE}/`); + url.searchParams.set('solution', secret + secret); + url.searchParams.set('js_challenge', '1'); + url.searchParams.set('token', token); + url.searchParams.set('jsc_orig_r', ''); + const res2 = await makeRequest(url.toString(), { + headers: { + 'User-Agent': USER_AGENT, + Referer: `${REDDIT_BASE}/` + } + }); + const setCookie = res2.headers?.['set-cookie']; + const loid = /(?:^|,\s*)loid=([^;]+)/.exec(setCookie ?? '')?.[1]; + if (!loid) { + return null; + } + const maxAge = /;\s*max-age=(\d+)/i.exec(setCookie ?? '')?.[1]; + const expires = /;\s*expires=([^;]+)/i.exec(setCookie ?? '')?.[1]; + const expiresAt = expires ? Date.parse(expires) : Number.NaN; + const ttlMs = maxAge + ? Number(maxAge) * 1000 + : Number.isFinite(expiresAt) && expiresAt > Date.now() + ? expiresAt - Date.now() + : LOID_FALLBACK_TTL_MS; + nodelink.credentialManager?.set(LOID_CACHE_KEY, loid, ttlMs); + return loid; + } + catch { + return null; + } +} /** * Reddit source implementation. */ @@ -180,7 +232,15 @@ export default class RedditSource { throw new Error(`Reddit returned status ${response.statusCode}`); } const stream = new PassThrough(); - response.stream.pipe(stream); + stream.once('close', () => { + ; + response.stream.destroy?.(); + }); + pipeline(response.stream, stream, (error) => { + if (error && error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Sources', `Reddit stream error: ${error.message}`); + } + }); const type = url.endsWith('.mp3') ? 'mp3' : 'mp4'; return { stream, type }; } @@ -245,7 +305,11 @@ export default class RedditSource { if (!currentParams.id) { return { error: 'fetch.short_link' }; } - const response = await makeRequest(`${REDDIT_BASE}/comments/${currentParams.id}.json`, { method: 'GET', headers }); + const loid = await getLoid(this.nodelink); + const response = await makeRequest(`${REDDIT_BASE}/comments/${currentParams.id}.json`, { + method: 'GET', + headers: loid ? { ...headers, Cookie: `loid=${loid}` } : headers + }); if (response.error || response.statusCode !== 200 || !Array.isArray(response.body)) { @@ -270,7 +334,8 @@ export default class RedditSource { const author = typeof postData.author === 'string' && postData.author.length > 0 ? `u/${postData.author}` : 'Reddit'; - const thumbnail = postData.thumbnail || postData.preview?.images?.[0]?.source?.url || null; + const thumbnailUrl = postData.preview?.images?.[0]?.source?.url || postData.thumbnail; + const thumbnail = thumbnailUrl?.replaceAll('&', '&') || null; const commonData = { resolvedId: currentParams.id, title: postData.title || 'Reddit Video', diff --git a/dist/src/sources/rss.js b/dist/src/sources/rss.js index a10f5c17..30d8e7bf 100644 --- a/dist/src/sources/rss.js +++ b/dist/src/sources/rss.js @@ -1,4 +1,4 @@ -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const RSS_PATTERN = /https?:\/\/.+(\.rss|\.rrs)(\?.*)?$/i; const PODCAST_RSS_PATTERN = /https?:\/\/.+\/podcast\/rss(\?.*)?$/i; /** diff --git a/dist/src/sources/shazam.js b/dist/src/sources/shazam.js index 409a8cf5..b4576bd8 100644 --- a/dist/src/sources/shazam.js +++ b/dist/src/sources/shazam.js @@ -1,6 +1,9 @@ -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; const SHAZAM_PATTERN = /^https?:\/\/(?:www\.)?shazam\.com\/song\/\d+(?:\/[^/?#]+)?\/?(?:[?#].*)?$/; const SHAZAM_SEARCH_BASE = 'https://www.shazam.com/services/amapi/v1/catalog/US/search'; +const SHAZAM_VALIDATION_URL = 'https://www.shazam.com/services/partner/oauth/commerce/validate'; +const SHAZAM_COMMERCE_SEARCH_BASE = 'https://api.music.apple.com/v1/catalog/US/search'; // amp- :) +const SHAZAM_ANDROID_USER_AGENT = 'Dalvik/2.1.0 (Linux; U; Android 12; SM-G9980 Build/af013b0.2) Shazam/v16.51.1'; /** * Shazam source implementation. */ @@ -58,7 +61,7 @@ export default class ShazamSource { */ getMaxSearchResults() { const options = this.nodelink.options; - const limit = options.maxSearchResults; + const limit = options.search?.maxResults; return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : 10; @@ -125,7 +128,53 @@ export default class ShazamSource { if (!this.patterns.some((pattern) => pattern.test(url))) { return { loadType: 'empty', data: {} }; } - const { body, statusCode, error } = await http1makeRequest(url); + const { body, statusCode, error } = await http1makeRequest(url, { + headers: { + 'sec-ch-ua': '"Chromium";v="148", "Google Chrome";v="148", "Not/A)Brand";v="99"' + } + }); + if (statusCode === 403) { + const validationResponse = await http1makeRequest(SHAZAM_VALIDATION_URL, { + method: 'GET', + headers: { + Origin: 'https://www.shazam.com', + 'User-Agent': SHAZAM_ANDROID_USER_AGENT + } + }); + const validationHeader = validationResponse.headers?.['x-shz-validation']; + const validation = Array.isArray(validationHeader) + ? validationHeader[0] + : validationHeader; + if (validationResponse.error || + validationResponse.statusCode !== 200 || + typeof validation !== 'string' || + !validation) { + return { loadType: 'empty', data: {} }; + } + const pathParts = new URL(url).pathname.split('/').filter(Boolean); + const identifier = pathParts[1]; + const slug = pathParts[2]; + if (!identifier || !slug) { + return { loadType: 'empty', data: {} }; + } + const searchUrl = `${SHAZAM_COMMERCE_SEARCH_BASE}?limit=5&types=songs&term=` + + encodeURIComponent(decodeURIComponent(slug).replace(/[-_]+/g, ' ')); + const searchResponse = await http1makeRequest(searchUrl, { + headers: { + Authorization: `Bearer ${validation}`, + Origin: 'https://www.shazam.com', + 'User-Agent': SHAZAM_ANDROID_USER_AGENT + } + }); + if (searchResponse.error || searchResponse.statusCode !== 200) { + return { loadType: 'empty', data: {} }; + } + const song = this.extractSearchSongs(searchResponse.body).find((item) => item.id === identifier); + const track = song ? this.buildTrack(song) : null; + return track + ? { loadType: 'track', data: track } + : { loadType: 'empty', data: {} }; + } if (error || statusCode !== 200) { return { loadType: 'empty', data: {} }; } diff --git a/dist/src/sources/songlink.js b/dist/src/sources/songlink.js index 7098a989..649c1e73 100644 --- a/dist/src/sources/songlink.js +++ b/dist/src/sources/songlink.js @@ -1,4 +1,4 @@ -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const SONG_LINK_PATTERN = /^https?:\/\/(?:www\.)?(song\.link|album\.link|artist\.link|pods\.link|odesli\.co)\/.+/i; const DEFAULT_PLATFORM_ORDER = [ 'spotify', @@ -104,11 +104,7 @@ export default class SongLinkSource { */ constructor(nodelink) { this.nodelink = nodelink; - const sourceConfig = this.nodelink.options.sources?.songlink; - this.config = - sourceConfig && typeof sourceConfig === 'object' - ? sourceConfig - : {}; + this.config = this.nodelink.options.sources.songlink; this.searchTerms = ['slsearch']; this.patterns = [SONG_LINK_PATTERN]; this.priority = 95; @@ -208,7 +204,7 @@ export default class SongLinkSource { */ async search(query, _sourceTerm, _searchType = 'track') { try { - const maxSearchRaw = this.nodelink.options.maxSearchResults; + const maxSearchRaw = this.nodelink.options.search?.maxResults; const limit = typeof maxSearchRaw === 'number' && Number.isFinite(maxSearchRaw) ? maxSearchRaw : 10; @@ -565,7 +561,7 @@ export default class SongLinkSource { * @returns True when source can be used. */ _isSourceAvailable(sourceName) { - const sourceConfig = this.nodelink.options.sources?.[sourceName]; + const sourceConfig = this.nodelink.options.sources[sourceName]; if (!sourceConfig?.enabled) return false; return !!this.nodelink.sources.getSource(sourceName); diff --git a/dist/src/sources/soundcloud.js b/dist/src/sources/soundcloud.js index 79c18e75..9d001496 100644 --- a/dist/src/sources/soundcloud.js +++ b/dist/src/sources/soundcloud.js @@ -1,12 +1,12 @@ import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { SEARCH_TYPE_MAP } from "../typings/sources/soundcloud.types.js"; -import { encodeTrack, http1makeRequest, logger, makeRequest } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { SEARCH_TYPE_MAP } from '../typings/sources/soundcloud.types.js'; +import { encodeTrack, http1makeRequest, logger, makeRequest } from '../utils.js'; const BASE_URL = 'https://api-v2.soundcloud.com'; const SOUNDCLOUD_URL = 'https://soundcloud.com'; const ASSET_PATTERN = /https:\/\/a-v2\.sndcdn\.com\/assets\/[a-zA-Z0-9-]+\.js/g; const CLIENT_ID_PATTERN = /(?:[?&/]?(?:client_id)[\s:=&]*"?|"data":{"id":")([A-Za-z0-9]{32})"?/; -const TRACK_PATTERN = /^https?:\/\/(?:www\.|m\.)?soundcloud\.com\/[^/\s]+\/(?:sets\/)?[^/\s]+$/; +const TRACK_PATTERN = /^https?:\/\/(?:www\.|m\.)?soundcloud\.com\/[^/\s]+\/(?:sets\/)?[^/\s?]+(\?.*)?$/; const SEARCH_URL_PATTERN = /^https?:\/\/(?:www\.)?soundcloud\.com\/search(?:\/(sounds|people|albums|sets))?(?:\?|$)/; const BATCH_SIZE = 50; const DEFAULT_PRIORITY = 85; @@ -20,6 +20,10 @@ export default class SoundCloudSource { this.clientId = nodelink.options?.sources?.soundcloud?.clientId ?? null; } async setup() { + if (this.clientId) { + logger('info', 'Sources', `Loaded SoundCloud (clientId: ${this.clientId}) from config`); + return true; + } const cachedId = this.nodelink.credentialManager.get('soundcloud_client_id'); if (cachedId) { this.clientId = cachedId; @@ -121,7 +125,7 @@ export default class SoundCloudSource { const params = new URLSearchParams({ q: searchQuery, client_id: this.clientId ?? '', - limit: String(this.nodelink.options.maxSearchResults ?? 50), + limit: String(this.nodelink.options.search.maxResults ?? 50), offset: '0', linked_partitioning: '1' }); @@ -181,7 +185,7 @@ export default class SoundCloudSource { } } _processUsers(collection) { - const max = this.nodelink.options.maxSearchResults ?? 50; + const max = this.nodelink.options.search.maxResults ?? 50; const users = []; for (let i = 0; i < collection.length && users.length < max; i++) { const user = collection[i]; @@ -214,7 +218,7 @@ export default class SoundCloudSource { return users; } _processAlbums(collection) { - const max = this.nodelink.options.maxSearchResults ?? 50; + const max = this.nodelink.options.search.maxResults ?? 50; const albums = []; for (let i = 0; i < collection.length && albums.length < max; i++) { const album = collection[i]; @@ -247,7 +251,7 @@ export default class SoundCloudSource { return albums; } _processPlaylists(collection) { - const max = this.nodelink.options.maxSearchResults ?? 50; + const max = this.nodelink.options.search.maxResults ?? 50; const playlists = []; for (let i = 0; i < collection.length && playlists.length < max; i++) { const playlist = collection[i]; @@ -280,7 +284,7 @@ export default class SoundCloudSource { return playlists; } _processAll(collection) { - const max = this.nodelink.options.maxSearchResults ?? 50; + const max = this.nodelink.options.search.maxResults ?? 50; const results = []; for (let i = 0; i < collection.length && results.length < max; i++) { const item = collection[i]; @@ -410,7 +414,7 @@ export default class SoundCloudSource { ids.push(t.id); } } - const limit = this.nodelink.options.maxAlbumPlaylistLength ?? 100; + const limit = this.nodelink.options.playback.maxPlaylistLength ?? 100; const neededIds = ids.slice(0, Math.max(0, limit - complete.length)); if (neededIds.length > 0) { const chunks = []; @@ -451,7 +455,7 @@ export default class SoundCloudSource { }; } _processTracks(collection) { - const max = this.nodelink.options.maxSearchResults ?? 50; + const max = this.nodelink.options.search.maxResults ?? 50; const tracks = []; if (!Array.isArray(collection)) return []; diff --git a/dist/src/sources/spotify.js b/dist/src/sources/spotify.js index a674f0c1..43dc77e0 100644 --- a/dist/src/sources/spotify.js +++ b/dist/src/sources/spotify.js @@ -1,6 +1,6 @@ -import { getLocalToken } from "../modules/spotifyAuth.js"; -import { fetchCanvas } from "../modules/spotifyCanvas.js"; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { getLocalToken } from '../modules/spotifyAuth.js'; +import { fetchCanvas } from '../modules/spotifyCanvas.js'; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; /** * Base URL for the official Spotify Web API. * Used for standard catalog data and public resource resolution. @@ -41,11 +41,11 @@ const QUERIES = { }, getPlaylist: { name: 'fetchPlaylist', - hash: 'bb67e0af06e8d6f52b531f97468ee4acd44cd0f82b988e15c2ea47b1148efc77' + hash: 'e4b2953f160e58e38ac025d79b5a9b3aceee5c4c716598e9830bfceb69faff5f' }, getArtist: { name: 'queryArtistOverview', - hash: '35648a112beb1794e39ab931365f6ae4a8d45e65396d641eeda94e4003d41497' + hash: 'ae0e2958a4ab645b35ca19ac04d0495ae12d9c5d7b7286217674801a9aab281a' }, getRecommendations: { name: 'internalLinkRecommenderTrack', @@ -53,7 +53,7 @@ const QUERIES = { }, searchDesktop: { name: 'searchDesktop', - hash: 'fcad5a3e0d5af727fb76966f06971c19cfa2275e6ff7671196753e008611873c' + hash: 'db61238974d27839a136c9dc02bfdbe3fab7635f21cf85976ebff9a1ee281345' } }; /** @@ -143,6 +143,11 @@ export default class SpotifySource { * @internal */ refreshPromises = new Map(); + /** + * Predictive token refresh timers. + * @internal + */ + tokenRefreshTimers = new Map(); /** * Creates a new SpotifySource instance. * @param nodelink - The worker context providing managers and options. @@ -168,12 +173,21 @@ export default class SpotifySource { const cm = this.nodelink.credentialManager; if (!cm) return false; - this.accessToken = cm.get('spotify_access_token'); - this.anonymousToken = cm.get('spotify_anonymous_token'); - this.mobileToken = cm.get('spotify_mobile_token'); + const accessToken = cm.getEntry?.('spotify_access_token'); + const anonymousToken = cm.getEntry?.('spotify_anonymous_token'); + const mobileToken = cm.getEntry?.('spotify_mobile_token'); + this.accessToken = + accessToken?.value ?? cm.get('spotify_access_token'); + this.accessTokenExpiry = accessToken?.expiresAt ?? null; + this.anonymousToken = + anonymousToken?.value ?? cm.get('spotify_anonymous_token'); + this.anonymousTokenExpiry = anonymousToken?.expiresAt ?? null; + this.mobileToken = + mobileToken?.value ?? cm.get('spotify_mobile_token'); + this.mobileTokenExpiry = mobileToken?.expiresAt ?? null; const hasOfficial = !!(this.config.clientId && this.config.clientSecret); try { - if (hasOfficial && !this.accessToken) + if (hasOfficial) await this._ensureToken('official'); await this._ensureToken('anonymous'); await this._ensureToken('mobile'); @@ -214,7 +228,9 @@ export default class SpotifySource { token = this.mobileToken; expiry = this.mobileTokenExpiry; } - if (token && (!expiry || now < expiry - TOKEN_REFRESH_MARGIN_MS)) { + if (token && + typeof expiry === 'number' && + now < expiry - TOKEN_REFRESH_MARGIN_MS) { return true; } const inflight = this.refreshPromises.get(type); @@ -229,6 +245,24 @@ export default class SpotifySource { this.refreshPromises.delete(type); } } + /** + * Schedules a background token refresh to prevent latency during playback. + * @internal + */ + _scheduleTokenRefresh(type, expiry) { + const existing = this.tokenRefreshTimers.get(type); + if (existing) + clearTimeout(existing); + const now = Date.now(); + const timeUntilRefresh = expiry - now - TOKEN_REFRESH_MARGIN_MS; + if (timeUntilRefresh > 0) { + const timer = setTimeout(() => { + this._refreshToken(type).catch(() => { }); + }, timeUntilRefresh); + timer.unref?.(); + this.tokenRefreshTimers.set(type, timer); + } + } /** * Implementation logic for refreshing various Spotify token tiers. * Handles Client Credentials flow, local Web Player generation, and session cookie flows. @@ -261,6 +295,7 @@ export default class SpotifySource { const ttl = (body.expires_in || 3600) * 1000; this.accessTokenExpiry = Date.now() + ttl; cm.set('spotify_access_token', this.accessToken, ttl); + this._scheduleTokenRefresh('official', this.accessTokenExpiry); return true; } } @@ -278,11 +313,13 @@ export default class SpotifySource { this.mobileToken = data.accessToken; this.mobileTokenExpiry = expiry; cm.set('spotify_mobile_token', this.mobileToken, Math.max(ttl, 60000)); + this._scheduleTokenRefresh('mobile', expiry); } else { this.anonymousToken = data.accessToken; this.anonymousTokenExpiry = expiry; cm.set('spotify_anonymous_token', this.anonymousToken, Math.max(ttl, 60000)); + this._scheduleTokenRefresh('anonymous', expiry); } return true; } @@ -303,6 +340,7 @@ export default class SpotifySource { : 3600000; this.anonymousTokenExpiry = Date.now() + Math.max(ttl, 60000); cm.set('spotify_anonymous_token', this.anonymousToken, Math.max(ttl, 60000)); + this._scheduleTokenRefresh('anonymous', this.anonymousTokenExpiry); return true; } } @@ -318,6 +356,16 @@ export default class SpotifySource { return false; } } + /** + * Cleans up all pending timers. + * @public + */ + cleanup() { + for (const timer of this.tokenRefreshTimers.values()) { + clearTimeout(timer); + } + this.tokenRefreshTimers.clear(); + } /** * Unified HTTP client for executing Spotify API calls. * Handles tiered authentication selection, automatic retries on token failure, @@ -572,13 +620,7 @@ export default class SpotifySource { if (term && this.recommendationTerm.includes(term)) return this.getRecommendations(query); try { - let limit = this.config.playlistLoadLimit || 10; - // fixes the error Argument for field /searchV2 cannot be greater than 1000 - // this is a config issue from the user side, but if this can be used as a workaround, - // we set it to 10 to avoid the error :p. - if (limit > 999) { - limit = 10; - } + const limit = Math.min(Math.max(this.nodelink.options.search.maxResults ?? 10, 1), 50); // Priority 1: Internal Search (Rich nodes + Local matching) if (this.anonymousToken || this.config.sp_dc) { const data = await this._internalApiRequest(QUERIES.searchDesktop || { @@ -830,7 +872,7 @@ export default class SpotifySource { * @internal */ async _resolveAlbum(id) { - const maxTracks = this.nodelink.options.maxAlbumPlaylistLength || 1000; + const maxTracks = this.nodelink.options.playback.maxPlaylistLength || 1000; const tracks = []; let name = 'Unknown Album'; if (this.anonymousToken || this.config.sp_dc) { @@ -916,7 +958,7 @@ export default class SpotifySource { * @internal */ async _resolvePlaylist(id) { - const maxTracks = this.nodelink.options.maxAlbumPlaylistLength || 1000; + const maxTracks = this.nodelink.options.playback.maxPlaylistLength || 1000; const tracks = []; let name = 'Unknown Playlist'; if (this.anonymousToken || id.startsWith('37i9dQZ')) { diff --git a/dist/src/sources/telegram.js b/dist/src/sources/telegram.js index f923013a..8ea03e82 100644 --- a/dist/src/sources/telegram.js +++ b/dist/src/sources/telegram.js @@ -1,5 +1,5 @@ import { PassThrough } from 'node:stream'; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * Telegram source implementation. */ diff --git a/dist/src/sources/tidal.js b/dist/src/sources/tidal.js index c5d75d8e..d981c40c 100644 --- a/dist/src/sources/tidal.js +++ b/dist/src/sources/tidal.js @@ -4,7 +4,7 @@ */ import path from 'node:path'; import { PassThrough } from 'node:stream'; -import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from '../utils.js'; const API_BASE = 'https://api.tidal.com/v1/'; const CACHE_VALIDITY_DAYS = 7; const TIDAL_ASSET_URL = 'https://tidal.com/assets/index-CJ0DsMmf.js'; @@ -136,7 +136,7 @@ export default class TidalSource { return this.getRecommendations(query); } try { - const limit = this.asNumber(this.nodelink.options.maxSearchResults) ?? 10; + const limit = this.asNumber(this.nodelink.options.search.maxResults) ?? 10; const data = await this.getJson('search', { query, limit, diff --git a/dist/src/sources/tiktok.js b/dist/src/sources/tiktok.js new file mode 100644 index 00000000..797319c5 --- /dev/null +++ b/dist/src/sources/tiktok.js @@ -0,0 +1,265 @@ +import { PassThrough } from 'node:stream'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; +/** + * Browser user agent sent with TikTok requests. + * @internal + */ +const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36'; +/** + * TikTok player API endpoint used by embeds. + * @internal + */ +const API_BASE = 'https://www.tiktok.com/player/api/v1/items'; +/** + * Regex pattern to extract the video ID from a TikTok URL. + * @internal + */ +const VIDEO_ID_RE = /\/video\/(\d{15,})/; +/** + * Returns the first valid string from an array of unknown values. + * @param list - Array of unknown values (usually strings from API). + * @returns The first valid string, or an empty string if none found. + * @internal + */ +function firstString(list) { + if (Array.isArray(list)) { + for (const v of list) { + if (typeof v === 'string' && v.length) + return v; + } + } + return ''; +} +/** + * TikTok source implementation. + * + * Resolves `tiktok.com/@user/video/ID` URLs and extracts MP4 playback streams + * using the TikTok player API endpoint. + * @public + */ +export default class TiktokSource { + /** + * Runtime worker context. + */ + nodelink; + /** + * URL patterns this source handles. + */ + patterns; + /** + * Match priority used by the source manager (higher wins). + */ + priority; + /** + * Creates a new TikTok source wrapper. + * @param nodelink - Worker runtime context. + */ + constructor(nodelink) { + this.nodelink = nodelink; + this.patterns = [ + /^https?:\/\/(?:www\.)?tiktok\.com\/@[\w.-]+\/video\/(\d+)/i, + /^https?:\/\/(?:www\.)?vm\.tiktok\.com\/([\w-]+)/i, + /^https?:\/\/(?:www\.)?m\.tiktok\.com\/([\w-]+)/i + ]; + this.priority = 60; + } + /** + * Initializes source resources. No async setup required. + * @returns `true` when the source is ready to accept requests. + */ + async setup() { + logger('info', 'Sources', 'Loaded TikTok source.'); + return true; + } + /** + * TikTok does not support keyword search. + * @param _query - Unused search query. + * @param _sourceName - Unused source name. + * @param _searchType - Unused search type. + * @returns An empty result. + */ + async search(_query, _sourceName, _searchType) { + return { loadType: 'empty', data: {} }; + } + /** + * Resolves a TikTok video URL into a playable track. + * + * Fetches metadata and playback URLs from the TikTok player API endpoint. + * @param url - Public TikTok video URL. + * @param _type - Unused type hint kept for source-manager compatibility. + * @returns A track result, an empty payload, or a structured exception. + */ + async resolve(url, _type) { + const match = url.match(VIDEO_ID_RE); + const videoId = match?.[1]; + if (!videoId) + return { loadType: 'empty', data: {} }; + try { + const params = new URLSearchParams({ + item_ids: videoId, + language: 'en', + aid: '1284', + app_name: 'tiktok_web', + device_platform: 'web_pc' + }); + const response = await http1makeRequest(`${API_BASE}?${params}`, { + method: 'GET', + headers: { + 'User-Agent': USER_AGENT, + Referer: `https://www.tiktok.com/player/v1/${videoId}`, + Accept: 'application/json, text/plain, */*' + } + }); + if (response.error || response.statusCode !== 200) { + return { + loadType: 'error', + exception: { + message: `TikTok API failed: ${response.error || `Status ${response.statusCode}`}`, + severity: 'fault' + } + }; + } + let data = response.body; + if (typeof data === 'string') { + try { + data = JSON.parse(data); + } + catch { + return { + loadType: 'error', + exception: { message: 'Invalid TikTok JSON', severity: 'fault' } + }; + } + } + const items = data?.items; + const item = (Array.isArray(items) ? items[0] : undefined); + if (!item) + return { loadType: 'empty', data: {} }; + const vi = item.video_info ?? {}; + const profile = Array.isArray(vi.profiles) ? vi.profiles[0] : null; + const directUrl = firstString(profile?.play_addr?.url_list) || firstString(vi.url_list); + if (!directUrl) { + return { + loadType: 'error', + exception: { + message: 'No playback URL in TikTok response', + severity: 'fault' + } + }; + } + const author = item.author_info?.nickname || 'TikTok User'; + const desc = item.desc || ''; + const title = desc.split('#')[0]?.trim() || 'TikTok Video'; + const rawDuration = vi.meta?.duration ?? 0; + const durationMs = rawDuration > 0 + ? rawDuration < 1000 + ? rawDuration * 1000 + : rawDuration + : -1; + const thumbnail = firstString(vi.cover?.url_list) || null; + const info = { + identifier: videoId, + isSeekable: true, + author, + length: durationMs, + isStream: false, + position: 0, + title, + uri: url, + artworkUrl: thumbnail, + isrc: null, + sourceName: 'tiktok', + details: [] + }; + const trackData = { + encoded: encodeTrack(info), + info: info, + pluginInfo: { directUrl, videoId } + }; + return { loadType: 'track', data: trackData }; + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + logger('error', 'TikTok', `Resolve failed: ${message}`); + return { loadType: 'error', exception: { message, severity: 'fault' } }; + } + } + /** + * Returns the cached or resolved direct playback URL. + * + * When the track already carries a `pluginInfo.directUrl`, the URL is + * returned immediately. Otherwise the video is re-resolved. + * @param trackInfo - Decoded TikTok track information. + * @param _itag - Unused itag placeholder kept for source-manager compatibility. + * @param _isRecovering - Whether this is a recovery attempt. + * @returns Direct playback URL metadata or a structured exception. + */ + async getTrackUrl(trackInfo, _itag, _isRecovering) { + const pluginInfo = trackInfo + .pluginInfo; + const directUrl = pluginInfo?.directUrl; + if (directUrl && typeof directUrl === 'string') { + return { url: directUrl, protocol: 'https', format: 'mp4' }; + } + const uri = trackInfo.uri; + if (uri && VIDEO_ID_RE.test(uri)) { + const result = await this.resolve(uri); + if (result.loadType === 'track') { + const trackData = result.data; + const url = trackData?.pluginInfo?.directUrl; + if (url) + return { url, protocol: 'https', format: 'mp4' }; + } + } + return { + url: undefined, + protocol: undefined, + format: undefined, + exception: { + message: 'No playable URL for TikTok track', + severity: 'fault' + } + }; + } + /** + * Loads the MP4 stream for a TikTok video. + * + * Proxies the direct playback URL through a `PassThrough` stream. + * @param track - Decoded track information. + * @param url - Resolved playback URL. + * @param _protocol - Optional protocol hint (unused). + * @param _additionalData - Optional additional data (unused). + * @returns A readable stream or a structured exception. + */ + async loadStream(_track, url, _protocol, _additionalData) { + try { + const response = await http1makeRequest(url, { + method: 'GET', + streamOnly: true, + headers: { + 'User-Agent': USER_AGENT, + Referer: 'https://www.tiktok.com/' + } + }); + if (response.error || !response.stream) { + throw new Error(response.error || 'No stream returned'); + } + const stream = new PassThrough(); + response.stream.on('data', (chunk) => stream.write(chunk)); + response.stream.on('end', () => { + stream.emit('finishBuffering'); + stream.end(); + }); + response.stream.on('error', (err) => stream.destroy(err)); + return { stream, type: 'video/mp4' }; + } + catch (e) { + const message = e instanceof Error ? e.message : String(e); + return { + stream: undefined, + type: undefined, + exception: { message, severity: 'fault' } + }; + } + } +} diff --git a/dist/src/sources/tumblr.js b/dist/src/sources/tumblr.js index 4d840c7d..dea5e313 100644 --- a/dist/src/sources/tumblr.js +++ b/dist/src/sources/tumblr.js @@ -1,5 +1,5 @@ import { PassThrough } from 'node:stream'; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const TUMBLR_USER_AGENT = 'WhatsApp/2.0'; const TUMBLR_STREAM_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'; export default class TumblrSource { diff --git a/dist/src/sources/twitch.js b/dist/src/sources/twitch.js index 9b0adbbd..82e6c980 100644 --- a/dist/src/sources/twitch.js +++ b/dist/src/sources/twitch.js @@ -1,6 +1,6 @@ import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; /** * Base URL for the Twitch GraphQL API. * @internal @@ -300,7 +300,7 @@ export default class TwitchSource { }; const res = (await this._gqlRequest(payload)); const stream = res.data?.user?.stream; - if (!stream || stream.type !== 'live') { + if (stream?.type !== 'live') { return { loadType: 'error', exception: { diff --git a/dist/src/sources/twitter.js b/dist/src/sources/twitter.js index 87b987db..b25e3037 100644 --- a/dist/src/sources/twitter.js +++ b/dist/src/sources/twitter.js @@ -1,6 +1,6 @@ import { PassThrough } from 'node:stream'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, http1makeRequest, logger } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const TWITTER_AUTH_BEARER = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA'; const TWITTER_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'; const TWITTER_PATTERN = /https?:\/\/(?:(?:www|m(?:obile)?)\.)?(?:twitter|x)\.com\/(?:[^/]+)\/status\/(\d+)/i; @@ -356,7 +356,7 @@ export default class TwitterSource { */ getMaxSearchResults() { const options = this.nodelink.options; - const limit = options.maxSearchResults; + const limit = options.search?.maxResults; return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : 10; diff --git a/dist/src/sources/vimeo.js b/dist/src/sources/vimeo.js index 1c47c0b8..6e5662a6 100644 --- a/dist/src/sources/vimeo.js +++ b/dist/src/sources/vimeo.js @@ -1,11 +1,9 @@ import { Buffer } from 'node:buffer'; -import { spawn } from 'node:child_process'; -import http from 'node:http'; -import https from 'node:https'; +import { once } from 'node:events'; import { PassThrough } from 'node:stream'; -import zlib from 'node:zlib'; -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, logger } from "../utils.js"; +import { pipeline } from 'node:stream/promises'; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, http1makeRequest, logger } from '../utils.js'; const VIMEO_PATTERNS = [ /^https?:\/\/(?:www\.)?vimeo\.com\/(\d+)(?:|[/?#])/i, /^https?:\/\/player\.vimeo\.com\/video\/(\d+)(?:|[/?#])/i, @@ -15,646 +13,150 @@ const VIMEO_PATTERNS = [ /^https?:\/\/(?:www\.)?vimeo\.com\/showcase\/\d+\/video\/(\d+)(?:|[/?#])/i ]; const VIMEO_BASE = 'https://vimeo.com'; -const VIMEO_PLAYER_BASE = 'https://player.vimeo.com'; +const VIMEO_API_BASE = 'https://api.vimeo.com'; const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36'; -const CDN_PRIORITY = ['akfire_interconnect_quic', 'fastly_skyfire']; const REQUEST_TIMEOUT = 15000; -const MAX_REDIRECTS = 5; -const SEGMENT_HIGH_WATER_MARK = 64 * 1024; -const PROGRESSIVE_HIGH_WATER_MARK = 16 * 1024; const HANDOFF_TTL = 15000; const HANDOFF_MAX = 20; -const HTTP_AGENT = new http.Agent({ - keepAlive: true, - maxSockets: 16, - maxFreeSockets: 4 -}); -const HTTPS_AGENT = new https.Agent({ - keepAlive: true, - maxSockets: 16, - maxFreeSockets: 4 -}); -const _CONFIG_PATTERNS = [ - /window\.playerConfig\s*=\s*(\{[\s\S]*?\});\s*(?:window\.|<\/script>|if\s*\()/i, - /window\.playerConfig\s*=\s*(\{[\s\S]*?"video"[\s\S]*?\})\s*;/i, - /"config"\s*:\s*(\{[\s\S]*?"request"[\s\S]*?\})\s*[,}]/i -]; -const _functions = { - parseJson(data) { - try { - const str = Buffer.isBuffer(data) ? data.toString('utf8') : data; - return JSON.parse(str); - } - catch { - return null; - } - }, - unescapeString(text) { - if (!text) - return ''; - const s = String(text); - return s - .replaceAll('\\u002F', '/') - .replaceAll('\\/', '/') - .replaceAll('\\u0026', '&') - .replaceAll('\\u003C', '<') - .replaceAll('\\u003E', '>') - .replaceAll('\\"', '"') - .replaceAll('&', '&'); - }, - extractVideoId(url) { - if (!url) - return null; - for (const pattern of VIMEO_PATTERNS) { - const match = url.match(pattern); - if (match?.[1]) - return match[1]; - } +const CDN_PRIORITY = ['akfire_interconnect_quic', 'fastly_skyfire']; +const PLAYER_QUERY = 'autoplay=0&muted=0&badge=1&title=0&portrait=0&byline=0&share=1&like=1&watch_later=1&transparent=0&ask_ai=0&transcript=0&preload=auto&chapters=1&airplay=1&audio_tracks=1&chromecast=1&cc=1&cc_track_menu=1&disable_context_menu=0&colors=000000%2C00adef%2Cffffff%2C000000&fullscreen=1&vimeo_logo=1&pip=1&playbar=1&play_button_position=auto&quality_selector=1&speed=1&skipping_forward=1&volume=1&outro=beginning'; +function parseNextData(html) { + const json = html.match(/]*\bid\s*=\s*["']__NEXT_DATA__["'][^>]*>([\s\S]*?)<\/script>/i)?.[1]; + if (!json) return null; - }, - extractHashParam(url) { - try { - return new URL(url).searchParams.get('h'); - } - catch { - return null; - } - }, - decompressBody(body, encoding) { - if (!encoding || !body) - return body; - const enc = Array.isArray(encoding) ? encoding[0] : encoding; - try { - switch (enc) { - case 'gzip': - return zlib.gunzipSync(body); - case 'deflate': - return zlib.inflateSync(body); - case 'br': - return zlib.brotliDecompressSync(body); - default: - return body; - } - } - catch { - return body; - } - }, - sortTracksByQuality(tracks) { - return [...tracks].sort((a, b) => { - const aSampleRate = a.sample_rate || a.audio_sample_rate || 0; - const bSampleRate = b.sample_rate || b.audio_sample_rate || 0; - const aIs48k = aSampleRate >= 44100; - const bIs48k = bSampleRate >= 44100; - if (aIs48k && !bIs48k) - return -1; - if (bIs48k && !aIs48k) - return 1; - const aBitrate = a.avg_bitrate || a.bitrate || 0; - const bBitrate = b.avg_bitrate || b.bitrate || 0; - return bBitrate - aBitrate; - }); - }, - selectBestAudioTrack(tracks) { - if (!Array.isArray(tracks) || tracks.length === 0) - return null; - const validTracks = tracks.filter((t) => (t?.segments?.length ?? 0) > 0); - if (validTracks.length === 0) - return null; - const mp42Aac = validTracks.filter((t) => { - const codecs = t.codecs || ''; - const format = t.format || ''; - return (codecs.includes('mp4a') && - (format === 'mp42' || format === 'iso5' || format === 'iso6')); - }); - if (mp42Aac.length) - return _functions.sortTracksByQuality(mp42Aac)[0] ?? null; - const aac = validTracks.filter((t) => (t.codecs || '').includes('mp4a')); - if (aac.length) - return _functions.sortTracksByQuality(aac)[0] ?? null; - let best = validTracks[0] ?? null; - for (const t of validTracks) { - const bw = t?.avg_bitrate || t?.bitrate || 0; - if (bw > ((best?.avg_bitrate ?? 0) || (best?.bitrate ?? 0))) { - best = t; - } - } - return best; - }, - playlistDir(playlistUrl) { - const urlWithoutQuery = playlistUrl.split('?')[0] || ''; - return urlWithoutQuery.substring(0, urlWithoutQuery.lastIndexOf('/') + 1); - }, - buildSegmentUrl(playlistDir, basePath, trackPath, segmentPath) { - try { - const relativePath = (basePath || '') + (trackPath || '') + segmentPath; - return new URL(relativePath, playlistDir).href; - } - catch (err) { - logger('error', 'Sources', `[vimeo] Failed to build segment URL: ${err instanceof Error ? err.message : String(err)}`); - return null; - } - }, - resolveRedirectUrl(currentUrl, location) { - if (!location) - return null; - if (location.startsWith('/')) { - const u = new URL(currentUrl); - return `${u.protocol}//${u.host}${location}`; - } - return location; - }, - makeHeaders(extra) { - return { - 'User-Agent': USER_AGENT, - Accept: '*/*', - 'Accept-Language': 'en-US,en;q=0.9', - Connection: 'keep-alive', - ...extra - }; - }, - async httpRequest(url, options = {}) { - let currentUrl = url; - const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS; - for (let i = 0; i <= maxRedirects; i++) { - const urlObj = new URL(currentUrl); - const isHttps = urlObj.protocol === 'https:'; - const httpLib = isHttps ? https : http; - const headers = _functions.makeHeaders({ - 'Accept-Encoding': 'gzip, deflate, br', - ...options.headers - }); - const { timeout = REQUEST_TIMEOUT } = options; - const res = await new Promise((resolve, reject) => { - const req = httpLib.request({ - hostname: urlObj.hostname, - port: urlObj.port || (isHttps ? 443 : 80), - path: urlObj.pathname + urlObj.search, - method: options.method || 'GET', - headers, - timeout, - agent: isHttps ? HTTPS_AGENT : HTTP_AGENT - }, resolve); - req.once('error', reject); - req.once('timeout', () => req.destroy(new Error('Request timeout'))); - req.end(); - }); - if (res.statusCode !== undefined && - res.statusCode >= 300 && - res.statusCode < 400 && - res.headers.location) { - res.resume(); - const redirectUrl = _functions.resolveRedirectUrl(currentUrl, res.headers.location); - if (!redirectUrl) - throw new Error('Redirect without location'); - currentUrl = redirectUrl; - continue; - } - const chunks = []; - let totalSize = 0; - const maxSize = options.maxSize || 10 * 1024 * 1024; - const statusCode = res.statusCode ?? 0; - const resHeaders = res.headers; - const body = await new Promise((resolve, reject) => { - res.on('data', (chunk) => { - totalSize += chunk.length; - if (totalSize > maxSize) { - res.destroy(new Error('Response too large')); - return; - } - chunks.push(chunk); - }); - res.once('error', (err) => { - chunks.length = 0; - reject(err); - }); - res.once('end', () => { - const raw = Buffer.concat(chunks, totalSize); - chunks.length = 0; - resolve(_functions.decompressBody(raw, resHeaders['content-encoding'])); - }); - }); - return { statusCode, headers: resHeaders, body }; - } - throw new Error('Too many redirects'); - }, - async pumpUrlToWritable(url, writable, options = {}) { - let currentUrl = url; - const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS; - const timeout = options.timeout ?? REQUEST_TIMEOUT; - const maxSize = options.maxSize ?? 0; - let req = null; - let res = null; - let done = false; - const cancel = (err) => { - if (done) - return; - done = true; - if (res && !res.destroyed) - res.destroy(err); - if (req && !req.destroyed) - req.destroy(err); - }; - const onWritableClose = () => cancel(new Error('Destination closed')); - const onWritableError = (err) => cancel(err); - writable.once('close', onWritableClose); - writable.once('error', onWritableError); - try { - for (let i = 0; i <= maxRedirects; i++) { - if (writable.destroyed) - throw new Error('Destination destroyed'); - const urlObj = new URL(currentUrl); - const isHttps = urlObj.protocol === 'https:'; - const httpLib = isHttps ? https : http; - const headers = _functions.makeHeaders({ - 'Accept-Encoding': 'identity', - ...options.headers - }); - res = await new Promise((resolve, reject) => { - const newReq = httpLib.request({ - hostname: urlObj.hostname, - port: urlObj.port || (isHttps ? 443 : 80), - path: urlObj.pathname + urlObj.search, - method: 'GET', - headers, - timeout, - agent: isHttps ? HTTPS_AGENT : HTTP_AGENT - }, resolve); - req = newReq; - newReq.once('error', reject); - newReq.once('timeout', () => newReq.destroy(new Error('Request timeout'))); - newReq.end(); - }); - const code = res.statusCode ?? 0; - if (code >= 300 && code < 400 && res.headers.location) { - res.resume(); - const redirectUrl = _functions.resolveRedirectUrl(currentUrl, res.headers.location); - if (!redirectUrl) - throw new Error('Redirect without location'); - currentUrl = redirectUrl; - req = null; - res = null; - continue; - } - if (code >= 400) { - res.resume(); - throw new Error(`HTTP ${code}`); - } - const currentRes = res; - const bytes = await new Promise((resolve, reject) => { - let total = 0; - let draining = false; - const cleanup = () => { - currentRes.removeListener('data', onData); - currentRes.removeListener('end', onEnd); - currentRes.removeListener('error', onErr); - currentRes.removeListener('close', onClose); - writable.removeListener('drain', onDrain); - }; - const onDrain = () => { - draining = false; - if (!currentRes.destroyed && !writable.destroyed) - currentRes.resume(); - }; - const onData = (chunk) => { - total += chunk.length; - if (maxSize && total > maxSize) { - cleanup(); - currentRes.destroy(new Error('Response too large')); - return; - } - if (writable.destroyed) { - cleanup(); - currentRes.destroy(new Error('Destination destroyed')); - return; - } - if (!writable.write(chunk) && !draining) { - draining = true; - currentRes.pause(); - writable.once('drain', onDrain); - } - }; - const onEnd = () => { - cleanup(); - resolve(total); - }; - const onErr = (err) => { - cleanup(); - reject(err); - }; - const onClose = () => { - if (done) - return; - cleanup(); - reject(new Error('Response closed early')); - }; - currentRes.on('data', onData); - currentRes.once('end', onEnd); - currentRes.once('error', onErr); - currentRes.once('close', onClose); - }); - return bytes; - } - throw new Error('Too many redirects'); - } - finally { - done = true; - writable.removeListener('close', onWritableClose); - writable.removeListener('error', onWritableError); - req = null; - res = null; - } + try { + return JSON.parse(json); } -}; -function curlRequest(url, options = {}) { - return new Promise((resolve, reject) => { - const args = [ - '-s', - '-L', - '-A', - USER_AGENT, - '-H', - 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', - '-H', - 'Accept-Language: en-US,en;q=0.9', - '-H', - 'Accept-Encoding: gzip, deflate, br', - '-H', - 'DNT: 1', - '-H', - 'Connection: keep-alive', - '-H', - 'Upgrade-Insecure-Requests: 1', - '-H', - 'Sec-Fetch-Dest: iframe', - '-H', - 'Sec-Fetch-Mode: navigate', - '-H', - 'Sec-Fetch-Site: cross-site', - '--compressed', - '-w', - '\n%{http_code}', - '-m', - String(Math.floor(REQUEST_TIMEOUT / 1000)) - ]; - if (options.referer) - args.push('-H', `Referer: ${options.referer}`); - if (options.origin) - args.push('-H', `Origin: ${options.origin}`); - args.push(url); - const curlProcess = spawn('curl', args); - const outputChunks = []; - let completed = false; - const cleanup = () => { - outputChunks.length = 0; - curlProcess.stdout.removeAllListeners(); - curlProcess.stderr.removeAllListeners(); - curlProcess.removeAllListeners(); - }; - const timeoutId = setTimeout(() => { - if (completed) - return; - completed = true; - curlProcess.kill('SIGTERM'); - cleanup(); - reject(new Error('curl timeout')); - }, REQUEST_TIMEOUT); - timeoutId.unref?.(); - curlProcess.stdout.on('data', (chunk) => outputChunks.push(chunk)); - curlProcess.stderr.resume(); - curlProcess.once('error', (err) => { - clearTimeout(timeoutId); - if (completed) - return; - completed = true; - cleanup(); - reject(err); - }); - curlProcess.once('close', (exitCode) => { - clearTimeout(timeoutId); - if (completed) - return; - completed = true; - if (exitCode !== 0) { - cleanup(); - return reject(new Error(`curl exited with code ${exitCode}`)); - } - const output = Buffer.concat(outputChunks).toString('utf8'); - outputChunks.length = 0; - const lastNewlineIndex = output.lastIndexOf('\n'); - const statusCode = parseInt(output.slice(lastNewlineIndex + 1), 10) || 0; - const bodyText = output.slice(0, lastNewlineIndex); - cleanup(); - resolve({ - statusCode, - headers: {}, - body: Buffer.from(bodyText, 'utf8') - }); - }); - }); -} -class SegmentStreamer { - constructor(playlistData, outputStream) { - this.playlistData = playlistData; - this.outputStream = outputStream; - this.aborted = false; - this.segmentsFetched = 0; - this.bytesWritten = 0; - this._playlistDir = null; + catch { + return null; } - abort() { - this.aborted = true; +} +function getSignature(pageProps) { + const signature = pageProps.pageMetadata?.clipSignature; + const jwt = pageProps.viewerBootstrap?.jwt; + if (!pageProps.clipId || !signature || !jwt) + return null; + return { + videoId: String(pageProps.clipId), + value: signature, + jwt + }; +} +function extractVideoId(url) { + for (const pattern of VIMEO_PATTERNS) { + const match = url.match(pattern); + if (match?.[1]) + return match[1]; } - async start() { - const { playlistUrl, basePath, trackPath, initSegment, segments, isDashFormat } = this.playlistData || {}; - if (!playlistUrl || !Array.isArray(segments) || !this.outputStream) { - if (this.outputStream && !this.outputStream.destroyed) { - this.outputStream.destroy(new Error('Invalid Vimeo playlist data')); - } - return; - } - const outputStream = this.outputStream; - const playlistDir = _functions.playlistDir(playlistUrl); - this._playlistDir = playlistDir; - const onClose = () => this.abort(); - const onError = () => this.abort(); - outputStream.once('close', onClose); - outputStream.once('error', onError); - try { - if (initSegment && !this.aborted) { - const initBuffer = Buffer.from(initSegment, 'base64'); - logger('debug', 'Sources', `[vimeo] Writing init segment: ${initBuffer.length} bytes (dash: ${isDashFormat})`); - if (outputStream.destroyed || this.aborted) - return; - if (!outputStream.write(initBuffer)) { - await new Promise((resolve) => { - const onDrain = () => { - cleanup(); - resolve(); - }; - const onClose2 = () => { - cleanup(); - resolve(); - }; - const cleanup = () => { - outputStream.removeListener('drain', onDrain); - outputStream.removeListener('close', onClose2); - }; - outputStream.once('drain', onDrain); - outputStream.once('close', onClose2); - }); - } - this.bytesWritten += initBuffer.length; - } - for (let i = 0; i < segments.length; i++) { - if (this.aborted || outputStream.destroyed) - break; - const segmentPath = segments[i]?.url; - if (!segmentPath) - continue; - const segmentUrl = _functions.buildSegmentUrl(playlistDir, basePath || '', trackPath || '', segmentPath); - if (!segmentUrl) { - logger('warn', 'Sources', `[vimeo] Failed to build segment URL: ${segmentPath}`); - continue; - } - try { - const bytes = await _functions.pumpUrlToWritable(segmentUrl, outputStream, { - headers: { - Accept: '*/*', - Origin: VIMEO_BASE, - Referer: `${VIMEO_BASE}/`, - 'Sec-Fetch-Dest': 'empty', - 'Sec-Fetch-Mode': 'cors', - 'Sec-Fetch-Site': 'cross-site' - }, - timeout: REQUEST_TIMEOUT, - maxSize: 5 * 1024 * 1024 - }); - if (this.aborted || outputStream.destroyed) - break; - if (bytes > 0) { - this.segmentsFetched++; - this.bytesWritten += bytes; - } - else { - logger('warn', 'Sources', `[vimeo] Empty segment ${i + 1}/${segments.length}`); - } - } - catch (err) { - if (this.aborted || outputStream.destroyed) - break; - logger('warn', 'Sources', `[vimeo] Segment fetch error (${i + 1}/${segments.length}): ${err instanceof Error ? err.message : String(err)}`); - } - } - logger('debug', 'Sources', `[vimeo] Streaming complete: ${this.segmentsFetched}/${segments.length} segments, ${this.bytesWritten} bytes`); - if (!this.aborted && !outputStream.destroyed) { - outputStream.emit('finishBuffering'); - outputStream.end(); - } - } - catch (error) { - logger('error', 'Sources', `[vimeo] Segment streaming error: ${error instanceof Error ? error.message : String(error)}`); - if (!outputStream.destroyed) { - outputStream.destroy(error instanceof Error ? error : new Error(String(error))); - } - } - finally { - outputStream.removeListener('close', onClose); - outputStream.removeListener('error', onError); - this.cleanup(); - } + return null; +} +function extractHashParam(url) { + try { + return new URL(url).searchParams.get('h'); } - cleanup() { - this.aborted = true; - this.playlistData = null; - this.outputStream = null; - this._playlistDir = null; + catch { + return null; } } +function getPlaylistDirectory(url) { + const parsed = new URL(url); + parsed.pathname = parsed.pathname.slice(0, parsed.pathname.lastIndexOf('/') + 1); + parsed.search = ''; + parsed.hash = ''; + return parsed.toString(); +} +function buildSegmentUrl(playlistUrl, basePath, trackPath, segmentPath) { + if (/^https?:\/\//i.test(segmentPath)) + return segmentPath; + return new URL(`${basePath}${trackPath}${segmentPath}`, getPlaylistDirectory(playlistUrl)).toString(); +} +function selectAudioTrack(tracks) { + const playable = tracks.filter((track) => track.segments?.length && track.init_segment); + const candidates = playable.filter((track) => /mp4a|aac/i.test(track.codecs ?? '')); + return (candidates.sort((a, b) => { + const aSampleRate = a.sample_rate ?? a.audio_sample_rate ?? 0; + const bSampleRate = b.sample_rate ?? b.audio_sample_rate ?? 0; + if (aSampleRate !== bSampleRate) + return bSampleRate - aSampleRate; + return ((b.avg_bitrate ?? b.bitrate ?? 0) - (a.avg_bitrate ?? a.bitrate ?? 0)); + })[0] ?? null); +} +/** + * Vimeo source implementation. + * + * Resolves public Vimeo pages through the anonymous player configuration flow + * and streams the selected adaptive audio track. + * + * @public + */ export default class VimeoSource { + nodelink; + config; + searchTerms; + patterns; + priority; + activeStreams = new Set(); + handoff = new Map(); + /** + * Creates the Vimeo source. + * + * @param nodelink - NodeLink worker context. + */ constructor(nodelink) { this.nodelink = nodelink; this.config = nodelink.options; this.searchTerms = []; this.patterns = VIMEO_PATTERNS; this.priority = 70; - this._curlAvailable = null; - this._activeStreams = new Set(); - this._handoff = new Map(); - } - _handoffGet(key) { - const entry = this._handoff.get(key); - if (!entry) - return null; - if (Date.now() >= entry.expiresAt) { - this._handoff.delete(key); - return null; - } - return entry.value; - } - _handoffSet(key, value) { - const now = Date.now(); - for (const [k, v] of this._handoff) { - if (now >= v.expiresAt) - this._handoff.delete(k); - } - while (this._handoff.size >= HANDOFF_MAX) { - const firstKey = this._handoff.keys().next().value; - if (firstKey !== undefined) - this._handoff.delete(firstKey); - } - this._handoff.set(key, { value, expiresAt: now + HANDOFF_TTL }); - } - _handoffTake(key) { - const value = this._handoffGet(key); - if (value) - this._handoff.delete(key); - return value; - } - async _checkCurlAvailability() { - if (this._curlAvailable !== null) - return this._curlAvailable; - return new Promise((resolve) => { - const curlProcess = spawn('curl', ['--version']); - curlProcess.once('error', () => { - this._curlAvailable = false; - resolve(false); - }); - curlProcess.once('close', (code) => { - this._curlAvailable = code === 0; - resolve(this._curlAvailable); - }); - curlProcess.stdout.resume(); - curlProcess.stderr.resume(); - }); } + /** + * Initializes the source. + * + * @returns `true` when the source is ready. + */ async setup() { - await this._checkCurlAvailability(); return true; } + /** + * Checks whether a URL belongs to Vimeo. + * + * @param url - Candidate URL. + * @returns Whether the URL contains a supported Vimeo video id. + */ match(url) { - return _functions.extractVideoId(url) !== null; + return extractVideoId(url) !== null; } + /** + * Vimeo does not expose text search through this source. + * + * @returns Empty search result. + */ async search() { return { loadType: 'empty', data: {} }; } + /** + * Resolves Vimeo metadata into an encoded track. + * + * @param url - Vimeo video URL. + * @returns Resolved track or an empty result. + */ async resolve(url) { - const videoId = _functions.extractVideoId(url); - const hashParam = _functions.extractHashParam(url); + const videoId = extractVideoId(url); + const hashParam = extractHashParam(url); if (!videoId) return { loadType: 'empty', data: {} }; - const metadata = await this._fetchVideoMetadata(videoId, hashParam); + const metadata = await this.fetchVideoMetadata(videoId, hashParam); if (!metadata?.title) return { loadType: 'empty', data: {} }; const trackInfo = { title: metadata.title, author: metadata.author || 'Unknown', - length: metadata.durationMs || 0, + length: metadata.durationMs, identifier: videoId, isSeekable: true, isStream: false, - uri: `https://vimeo.com/${videoId}${hashParam ? `?h=${hashParam}` : ''}`, - artworkUrl: metadata.artworkUrl || null, + uri: `${VIMEO_BASE}/${videoId}${hashParam ? `?h=${hashParam}` : ''}`, + artworkUrl: metadata.artworkUrl, isrc: null, sourceName: 'vimeo', position: 0, @@ -670,9 +172,15 @@ export default class VimeoSource { } }; } + /** + * Resolves the playable Vimeo stream. + * + * @param decodedTrack - Decoded Vimeo track. + * @returns Adaptive, HLS, or progressive stream descriptor. + */ async getTrackUrl(decodedTrack) { - const videoId = decodedTrack?.identifier; - const hashParam = decodedTrack?.userData?.vimeo?.h || null; + const videoId = decodedTrack.identifier; + const hashParam = decodedTrack.userData?.vimeo?.h ?? null; if (!videoId) { return { exception: { @@ -682,542 +190,415 @@ export default class VimeoSource { }; } try { - const result = await this._extractFromEmbed(videoId, hashParam); - if (result && 'playlistData' in result && result.playlistData) { - const key = `handoff:${videoId}:${hashParam || ''}`; - this._handoffSet(key, result); + const config = await this.fetchPlayerConfig(videoId, hashParam); + const result = await this.extractStream(config, videoId); + if ('playlistData' in result && result.playlistData) { + this.setHandoff(this.handoffKey(videoId, hashParam), result); } return result; } - catch (err) { - logger('warn', 'Sources', `[vimeo] Embed extraction failed for ${videoId}: ${err instanceof Error ? err.message : String(err)}`); + catch (error) { + const message = error instanceof Error ? error.message : 'Unknown Vimeo error'; + logger('warn', 'Vimeo', `Stream extraction failed: ${message}`); return { exception: { - message: 'Failed to extract Vimeo stream. Video may be private or require authentication.', + message: `Failed to extract Vimeo stream: ${message}`, severity: 'fault', cause: 'Upstream' } }; } } + /** + * Opens a Vimeo media stream. + * + * @param decodedTrack - Decoded Vimeo track. + * @param url - URL returned by `getTrackUrl`. + * @param protocol - Vimeo stream protocol. + * @returns Playable stream result. + */ async loadStream(decodedTrack, url, protocol) { if (protocol === 'hls') { - logger('debug', 'Sources', '[vimeo] Loading HLS stream'); return { stream: new HLSHandler(url, { - headers: { - 'User-Agent': USER_AGENT, - Referer: `${VIMEO_BASE}/`, - Origin: VIMEO_BASE - }, + headers: this.mediaHeaders(), localAddress: this.nodelink.routePlanner?.getIP?.() ?? undefined, type: 'mpegts' }), type: 'mpegts' }; } - const isProgressive = protocol === 'https' || protocol === 'http'; - const highWaterMark = isProgressive - ? PROGRESSIVE_HIGH_WATER_MARK - : SEGMENT_HIGH_WATER_MARK; const stream = new PassThrough({ - highWaterMark, + highWaterMark: 64 * 1024, emitClose: true, autoDestroy: true }); - this._activeStreams.add(stream); + this.activeStreams.add(stream); const cleanup = () => { - this._activeStreams.delete(stream); - stream._segmentStreamer = null; + this.activeStreams.delete(stream); }; stream.once('close', cleanup); stream.once('error', cleanup); - if (isProgressive) { - setImmediate(() => { - _functions - .pumpUrlToWritable(url, stream, { timeout: REQUEST_TIMEOUT }) - .then(() => { - if (!stream.destroyed) { - stream.emit('finishBuffering'); - stream.end(); - } - }) - .catch((err) => { - if (!stream.destroyed) - stream.destroy(err); - }); - }); - return { stream }; + if (protocol === 'http' || protocol === 'https') { + void this.pipeProgressive(url, stream); + return { stream, type: 'mp4' }; } if (protocol === 'segmented') { - const videoId = decodedTrack?.identifier; - const hashParam = decodedTrack?.userData?.vimeo?.h || ''; - const key = `handoff:${videoId}:${hashParam}`; - setImmediate(async () => { - try { - if (stream.destroyed) - return; - let playlistResult = this._handoffTake(key); - if (!playlistResult?.playlistData) { - playlistResult = await this._fetchPlaylist(url, videoId || 'unknown'); - } - if (!playlistResult?.playlistData) - throw new Error('Vimeo playlistData not found'); - const segmentStreamer = new SegmentStreamer(playlistResult.playlistData, stream); - stream._segmentStreamer = segmentStreamer; - await segmentStreamer.start(); - } - catch (err) { - if (!stream.destroyed) - stream.destroy(err instanceof Error ? err : new Error(String(err))); - } - }); - return { stream }; + const hashParam = decodedTrack.userData?.vimeo?.h ?? null; + const key = this.handoffKey(decodedTrack.identifier, hashParam); + const result = this.takeHandoff(key) ?? (await this.fetchPlaylist(url)); + if (!result.playlistData) { + stream.destroy(new Error('Vimeo playlist data is missing')); + return { stream }; + } + void this.pipeSegments(result.playlistData, stream); + return { stream, type: result.format }; } - stream.destroy(new Error(`Unsupported protocol: ${protocol}`)); + stream.destroy(new Error(`Unsupported Vimeo protocol: ${protocol}`)); return { stream }; } + /** + * Destroys active Vimeo streams and cached handoffs. + */ cleanupAllStreams() { - for (const stream of this._activeStreams) { + for (const stream of this.activeStreams) { if (!stream.destroyed) stream.destroy(); } - this._activeStreams.clear(); - this._handoff.clear(); + this.activeStreams.clear(); + this.handoff.clear(); } - async _fetchVideoMetadata(videoId, hashParam) { - try { - const targetUrl = hashParam - ? `https://vimeo.com/${videoId}?h=${hashParam}` - : `https://vimeo.com/${videoId}`; - const oembedUrl = `https://vimeo.com/api/oembed.json?url=${encodeURIComponent(targetUrl)}`; - const response = await _functions.httpRequest(oembedUrl, { - headers: { Accept: 'application/json' }, - maxSize: 1024 * 1024 - }); - if (response.statusCode >= 400) - return this._fetchMetadataFromApiV2(videoId); - const data = _functions.parseJson(response.body); - if (!data?.title) - return this._fetchMetadataFromApiV2(videoId); - return { - title: data.title, - author: data.author_name || 'Unknown', - durationMs: (data.duration || 0) * 1000, - artworkUrl: data.thumbnail_url || null - }; - } - catch { - return this._fetchMetadataFromApiV2(videoId); - } - } - async _fetchMetadataFromApiV2(videoId) { - try { - const response = await _functions.httpRequest(`https://vimeo.com/api/v2/video/${videoId}.json`, { - headers: { Accept: 'application/json' }, - maxSize: 1024 * 1024 - }); - if (response.statusCode >= 400) - return null; - const data = _functions.parseJson(response.body); - if (!Array.isArray(data) || !data[0]) - return null; - const video = data[0]; - return { - title: video.title || 'Unknown', - author: video.user_name || 'Unknown', - durationMs: (video.duration || 0) * 1000, - artworkUrl: video.thumbnail_large || video.thumbnail_medium || null - }; - } - catch { - return null; - } - } - async _extractFromEmbed(videoId, hashParam) { - const playerUrl = hashParam - ? `${VIMEO_PLAYER_BASE}/video/${videoId}?h=${hashParam}&app_id=122963` - : `${VIMEO_PLAYER_BASE}/video/${videoId}?app_id=122963`; - let response; - if (this._curlAvailable) { - try { - response = await curlRequest(playerUrl, { - referer: `${VIMEO_BASE}/${videoId}`, - origin: VIMEO_BASE - }); - } - catch { - response = (await _functions.httpRequest(playerUrl, { - headers: { - Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', - 'Sec-Fetch-Dest': 'iframe', - 'Sec-Fetch-Mode': 'navigate', - 'Sec-Fetch-Site': 'cross-site', - Referer: `${VIMEO_BASE}/${videoId}`, - Origin: VIMEO_BASE - }, - maxSize: 5 * 1024 * 1024 - })); - } - } - else { - response = (await _functions.httpRequest(playerUrl, { - headers: { - Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', - 'Sec-Fetch-Dest': 'iframe', - 'Sec-Fetch-Mode': 'navigate', - 'Sec-Fetch-Site': 'cross-site', - Referer: `${VIMEO_BASE}/${videoId}`, - Origin: VIMEO_BASE - }, - maxSize: 5 * 1024 * 1024 - })); - } - if (response.statusCode >= 400) - throw new Error(`HTTP ${response.statusCode}`); - const html = response.body.toString('utf8'); - if (html.includes('Just a moment') || html.includes('challenge-platform')) { - throw new Error('Cloudflare challenge detected'); - } - return this._parsePageForConfig(html, playerUrl, videoId); + requestOptions(headers = {}) { + return { + headers: { + 'User-Agent': USER_AGENT, + ...headers + }, + timeout: REQUEST_TIMEOUT, + maxResponseBodyBytes: 5 * 1024 * 1024 + }; } - async _parsePageForConfig(html, refererUrl, videoId) { - const cfgKeyIdx = html.indexOf('"config_url"'); - if (cfgKeyIdx !== -1) { - const q1 = html.indexOf('"', html.indexOf(':', cfgKeyIdx) + 1); - const q2 = q1 !== -1 ? html.indexOf('"', q1 + 1) : -1; - if (q1 !== -1 && q2 !== -1) { - const raw = html.slice(q1 + 1, q2); - try { - const result = await this._fetchConfigFromUrl(_functions.unescapeString(raw), refererUrl, videoId); - if (result) - return result; - } - catch { } - } - } - const cfgKeyIdx2 = html.indexOf('data-config-url="'); - if (cfgKeyIdx2 !== -1) { - const start = cfgKeyIdx2 + 'data-config-url="'.length; - const end = html.indexOf('"', start); - if (end !== -1) { - try { - const result = await this._fetchConfigFromUrl(_functions.unescapeString(html.slice(start, end)), refererUrl, videoId); - if (result) - return result; - } - catch { } - } - } - for (const pattern of _CONFIG_PATTERNS) { - const match = html.match(pattern); - if (!match?.[1]) - continue; - const config = this._parseJsonConfig(match[1]); - if (!config) - continue; - const result = await this._extractPlaylistFromConfig(config, refererUrl, videoId); - if (result) - return result; - } - const cdnMatch = html.match(/(https?:\/\/[^"'\s\\]*vimeocdn\.com[^"'\s\\]*playlist\.json[^"'\s\\]*)/i); - if (cdnMatch?.[1]) { - try { - const result = await this._fetchPlaylist(_functions.unescapeString(cdnMatch[1]), videoId); - if (result) - return result; - } - catch { } - } - const progressiveMatch = html.match(/"progressive"\s*:\s*\[([\s\S]*?)\]/i); - if (progressiveMatch?.[1]) { - const result = this._handleProgressiveUrls(progressiveMatch[1], videoId); - if (result) - return result; - } - throw new Error('No config found in embed page'); + mediaHeaders() { + return { + 'User-Agent': USER_AGENT, + Accept: '*/*', + Origin: VIMEO_BASE, + Referer: `${VIMEO_BASE}/` + }; } - _handleProgressiveUrls(progressiveJson, videoId) { + async fetchVideoMetadata(videoId, hashParam) { + const targetUrl = `${VIMEO_BASE}/${videoId}${hashParam ? `?h=${hashParam}` : ''}`; + const oembedUrl = `${VIMEO_BASE}/api/oembed.json?url=${encodeURIComponent(targetUrl)}`; try { - const parsed = _functions.parseJson(`[${progressiveJson}]`); - if (Array.isArray(parsed) && parsed.length) { - const sorted = [...parsed].sort((a, b) => (a?.height || 0) - (b?.height || 0)); - const best = sorted.find((p) => (p?.height || 0) >= 360) || - sorted[sorted.length - 1]; - if (best?.url) { - logger('warn', 'Sources', `[vimeo] Using progressive stream for ${videoId} (${best.height || 0}p)`); - return { - url: _functions.unescapeString(best.url), - protocol: 'https', - format: 'mp4', - additionalData: { - source: 'vimeo.progressive', - quality: best.quality, - height: best.height || 0 - } - }; - } - } - } - catch { } - try { - const urls = []; - let pos = 0; - while (true) { - const urlStart = progressiveJson.indexOf('"url"', pos); - if (urlStart === -1) - break; - const valueStart = progressiveJson.indexOf('"', urlStart + 5); - if (valueStart === -1) - break; - const valueEnd = progressiveJson.indexOf('"', valueStart + 1); - if (valueEnd === -1) - break; - const url = _functions.unescapeString(progressiveJson.substring(valueStart + 1, valueEnd)); - let height = 0; - const before = progressiveJson.substring(pos, urlStart); - const heightKey = before.lastIndexOf('"height"'); - if (heightKey !== -1) { - const colon = before.indexOf(':', heightKey); - if (colon !== -1) { - const num = before - .slice(colon + 1) - .trim() - .split(',')[0] || '0'; - height = parseInt(num, 10) || 0; - } - } - urls.push({ url, height }); - pos = valueEnd + 1; - } - urls.sort((a, b) => a.height - b.height); - const best = urls.find((p) => p.height >= 360) || urls[urls.length - 1]; - if (best?.url) { - logger('warn', 'Sources', `[vimeo] Using progressive stream for ${videoId} (${best.height}p)`); + const response = await http1makeRequest(oembedUrl, this.requestOptions({ Accept: 'application/json' })); + const data = response.body; + if (response.statusCode === 200 && data?.title) { return { - url: best.url, - protocol: 'https', - format: 'mp4', - additionalData: { source: 'vimeo.progressive', height: best.height } + title: data.title, + author: data.author_name ?? 'Unknown', + durationMs: (data.duration ?? 0) * 1000, + artworkUrl: data.thumbnail_url ?? null }; } } catch { } - return null; - } - _parseJsonConfig(configString) { try { - let braceDepth = 0; - let endIndex = 0; - for (let i = 0; i < configString.length; i++) { - const c = configString[i]; - if (c === '{') - braceDepth++; - else if (c === '}') - braceDepth--; - if (braceDepth === 0 && i > 0) { - endIndex = i + 1; - break; - } - } - return _functions.parseJson(configString.substring(0, endIndex || configString.length)); + const response = await http1makeRequest(`${VIMEO_BASE}/api/v2/video/${videoId}.json`, this.requestOptions({ Accept: 'application/json' })); + const data = response.body; + const video = Array.isArray(data) ? data[0] : undefined; + if (response.statusCode !== 200 || !video?.title) + return null; + return { + title: video.title, + author: video.user_name ?? 'Unknown', + durationMs: (video.duration ?? 0) * 1000, + artworkUrl: video.thumbnail_large ?? video.thumbnail_medium ?? null + }; } catch { return null; } } - async _fetchConfigFromUrl(configUrl, refererUrl, videoId) { - if (configUrl.startsWith('/')) { - const refUrl = new URL(refererUrl); - configUrl = `${refUrl.protocol}//${refUrl.host}${configUrl}`; - } - const response = await _functions.httpRequest(configUrl, { - headers: { - Accept: 'application/json', - Referer: refererUrl, - Origin: VIMEO_BASE - }, - maxSize: 2 * 1024 * 1024 + async fetchPlayerConfig(videoId, hashParam) { + const pageUrl = `${VIMEO_BASE}/${videoId}${hashParam ? `?h=${hashParam}` : ''}`; + const signature = getSignature(await this.fetchNextPageProps(videoId, hashParam)); + if (!signature) { + throw new Error('Vimeo anonymous credentials were not found'); + } + const apiUrl = new URL(`/videos/${signature.videoId}?${PLAYER_QUERY}`, VIMEO_API_BASE); + apiUrl.searchParams.set('anon_signature', signature.value); + apiUrl.searchParams.set('fields', 'type,embed_player_config_url,width,height,live.recurring_event.link,live.recurring_event.stream_privacy.unlisted_hash,player_embed_url'); + const api = await http1makeRequest(apiUrl.toString(), { + ...this.requestOptions({ + Accept: 'application/vnd.vimeo.*+json;version=3.4.12', + Authorization: `jwt ${signature.jwt}`, + 'Content-Type': 'application/json', + 'Vimeo-Page': '/video/[clipId]', + 'Accept-Language': 'en', + Referer: `${VIMEO_BASE}/` + }), + maxRetries: 0 }); - if (response.statusCode >= 400) - throw new Error(`HTTP ${response.statusCode}`); - const config = _functions.parseJson(response.body); - if (!config) - throw new Error('Invalid config JSON'); - return this._extractPlaylistFromConfig(config, configUrl, videoId); + const apiData = (typeof api.body === 'string' ? JSON.parse(api.body) : api.body); + if (api.statusCode !== 200 || !apiData?.embed_player_config_url) { + throw new Error(`Vimeo anonymous API returned HTTP ${api.statusCode ?? 0}`); + } + const config = await http1makeRequest(apiData.embed_player_config_url, this.requestOptions({ + Accept: 'application/json', + Referer: pageUrl, + Origin: VIMEO_BASE + })); + if (config.statusCode !== 200 || !config.body) { + throw new Error(`Vimeo player config returned HTTP ${config.statusCode ?? 0}`); + } + return config.body; } - async _extractPlaylistFromConfig(config, refererUrl, videoId) { - let files = config?.request?.files; - if (!files) - files = config?.video?.files || config?.files || config?.clip?.files; - if (!files) { - const nested = config?.config || config?.player?.config || config?.data?.config; - if (nested) - return this._extractPlaylistFromConfig(nested, refererUrl, videoId); + async fetchNextPageProps(videoId, hashParam) { + const watch = await http1makeRequest(`${VIMEO_BASE}/watch`, this.requestOptions({ + Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' + })); + if (watch.statusCode !== 200 || typeof watch.body !== 'string') { + throw new Error(`Vimeo bootstrap returned HTTP ${watch.statusCode ?? 0}`); + } + const nextData = parseNextData(watch.body); + if (!nextData?.buildId || !nextData.locale) { + throw new Error('Vimeo Next.js bootstrap data was not found'); + } + // i never hated the devtools debugger as much as i do now. im going crazy w vimeo. + const dataUrl = new URL(`/_next/data/${encodeURIComponent(nextData.buildId)}/${encodeURIComponent(nextData.locale)}/${encodeURIComponent(videoId)}.json`, VIMEO_BASE); + if (hashParam) + dataUrl.searchParams.set('h', hashParam); + const page = await http1makeRequest(dataUrl.toString(), { + ...this.requestOptions({ + Accept: 'application/json', + 'Accept-Language': nextData.locale, + 'x-nextjs-data': '1', + Referer: `${VIMEO_BASE}/watch` + }), + maxRetries: 0 + }); + const pageData = page.body; + if (page.statusCode !== 200 || !pageData?.pageProps) { + throw new Error(`Vimeo video data returned HTTP ${page.statusCode ?? 0}`); } + return pageData.pageProps; + } + async extractStream(config, videoId) { + const files = this.findFiles(config); if (!files) - throw new Error('No files in config'); - const pickCdn = (cdns, def) => { - for (const name of CDN_PRIORITY) - if (cdns?.[name]) - return cdns[name]; - return cdns?.[def || ''] ?? (cdns ? Object.values(cdns)[0] : null) ?? null; - }; + throw new Error('Vimeo player config has no files'); const dash = files.dash; if (dash?.cdns) { - const selected = pickCdn(dash.cdns, dash.default_cdn); - if (selected) { - let playlistUrl = _functions.unescapeString(selected.avc_url || selected.url || ''); - if (playlistUrl) { - if (!playlistUrl.includes('playlist.json') && - !playlistUrl.includes('master.json')) { - playlistUrl = playlistUrl.replace(/\/[^/?]+(\?|$)/, '/playlist.json$1'); - } - if (!playlistUrl.includes('omit=')) { - playlistUrl += `${playlistUrl.includes('?') ? '&' : '?'}omit=av1-hevc`; - } - try { - return await this._fetchPlaylist(playlistUrl, videoId); - } - catch { } + const cdn = this.pickCdn(dash.cdns, dash.default_cdn); + const playlistUrl = cdn?.url ?? cdn?.avc_url; + if (playlistUrl) { + try { + return await this.fetchPlaylist(playlistUrl); + } + catch (error) { + logger('debug', 'Vimeo', `DASH audio failed for ${videoId}: ${error instanceof Error ? error.message : String(error)}`); } } } const hls = files.hls; if (hls?.cdns) { - const selected = pickCdn(hls.cdns, hls.default_cdn); - if (selected?.url) { + const cdn = this.pickCdn(hls.cdns, hls.default_cdn); + if (cdn?.url) { return { - url: _functions.unescapeString(selected.url), + url: cdn.url, protocol: 'hls', format: 'mpegts', additionalData: { source: 'vimeo.hls' } }; } } - const progressive = files.progressive; - if (Array.isArray(progressive) && progressive.length) { - const sorted = [...progressive].sort((a, b) => (a.height || 0) - (b.height || 0)); - const best = sorted.find((p) => (p.height || 0) >= 360) || sorted[sorted.length - 1]; - if (best?.url) { - logger('warn', 'Sources', `[vimeo] Using progressive stream for ${videoId}`); - return { - url: best.url, - protocol: 'https', - format: 'mp4', - additionalData: { - source: 'vimeo.progressive', - quality: best.quality, - height: best.height - } - }; - } + const progressive = [...(files.progressive ?? [])].sort((a, b) => (b.height ?? 0) - (a.height ?? 0))[0]; + if (progressive?.url) { + return { + url: progressive.url, + protocol: 'https', + format: 'mp4', + additionalData: { + source: 'vimeo.progressive', + quality: progressive.quality, + height: progressive.height ?? 0 + } + }; } - throw new Error('No playable streams in config'); + throw new Error('Vimeo player config has no playable streams'); } - async _fetchPlaylist(playlistUrl, _videoId) { - const response = await _functions.httpRequest(playlistUrl, { - headers: { - Accept: '*/*', - Origin: VIMEO_BASE, - Referer: `${VIMEO_BASE}/`, - 'Sec-Fetch-Dest': 'empty', - 'Sec-Fetch-Mode': 'cors', - 'Sec-Fetch-Site': 'cross-site' - }, - maxSize: 2 * 1024 * 1024 + findFiles(config) { + const files = config.request?.files ?? + config.video?.files ?? + config.files ?? + config.clip?.files; + if (files) + return files; + const nested = config.config ?? config.player?.config ?? config.data?.config; + return nested ? this.findFiles(nested) : null; + } + pickCdn(cdns, defaultCdn) { + for (const name of CDN_PRIORITY) { + if (cdns[name]) + return cdns[name]; + } + return ((defaultCdn ? cdns[defaultCdn] : undefined) ?? + Object.values(cdns)[0] ?? + null); + } + async fetchPlaylist(playlistUrl) { + const response = await http1makeRequest(playlistUrl, { + ...this.requestOptions(this.mediaHeaders()), + maxResponseBodyBytes: 2 * 1024 * 1024 }); - if (response.statusCode >= 400) - throw new Error(`HTTP ${response.statusCode}`); - const playlist = _functions.parseJson(response.body); - if (!playlist) - throw new Error('Invalid playlist JSON'); - if (playlist.audio?.length) { - const audioTrack = _functions.selectBestAudioTrack(playlist.audio); - if (audioTrack) { - const segments = (audioTrack.segments || []).map((seg) => ({ - url: seg.url, - start: seg.start, - end: seg.end, - size: seg.size - })); - const sampleRate = audioTrack.sample_rate || audioTrack.audio_sample_rate || 48000; - const isDashFormat = audioTrack.format === 'dash'; - let basePath = playlist.base_url || ''; - let trackPath = audioTrack.base_url || ''; - if (!basePath && !trackPath) - basePath = '../../../../../'; - else if (basePath && !basePath.endsWith('/')) - basePath += '/'; - if (trackPath && !trackPath.endsWith('/')) - trackPath += '/'; - const playlistData = { - playlistUrl, - basePath, - trackPath, - initSegment: audioTrack.init_segment || null, - segments, - duration: audioTrack.duration, - bitrate: audioTrack.avg_bitrate || audioTrack.bitrate, - codecs: audioTrack.codecs, - sampleRate, - clipId: playlist.clip_id, - isDashFormat - }; - logger('debug', 'Sources', `[vimeo] Using audio: ${audioTrack.codecs} @ ${playlistData.bitrate}bps, ${sampleRate}Hz, ${segments.length} segments, format: ${audioTrack.format}`); - return { - url: playlistUrl, - protocol: 'segmented', - format: 'mp4', - playlistData, - additionalData: { - source: 'vimeo.adaptive', - bitrate: playlistData.bitrate, - codecs: playlistData.codecs, - segments: segments.length, - sampleRate, - format: audioTrack.format - } - }; + if (response.statusCode !== 200) { + throw new Error(`Vimeo playlist returned HTTP ${response.statusCode ?? 0}`); + } + const playlist = response.body; + const audio = selectAudioTrack(playlist.audio ?? []); + if (audio) + return this.buildAudioResult(playlistUrl, playlist, audio); + const video = [...(playlist.video ?? [])].sort((a, b) => (b.avg_bitrate ?? b.bitrate ?? 0) - (a.avg_bitrate ?? a.bitrate ?? 0))[0]; + if (video?.segments?.length) { + return this.buildVideoResult(playlistUrl, playlist, video); + } + throw new Error('Vimeo playlist has no compatible audio track'); + } + buildAudioResult(playlistUrl, playlist, audio) { + const codecs = audio.codecs ?? ''; + const playlistData = { + playlistUrl, + basePath: this.withTrailingSlash(playlist.base_url), + trackPath: this.withTrailingSlash(audio.base_url), + initSegment: audio.init_segment ?? null, + segments: audio.segments ?? [], + duration: audio.duration, + bitrate: audio.avg_bitrate ?? audio.bitrate, + codecs, + sampleRate: audio.sample_rate ?? audio.audio_sample_rate ?? 48000, + clipId: playlist.clip_id, + isDashFormat: audio.format === 'dash', + streamType: 'mp4' + }; + logger('debug', 'Vimeo', `Selected AAC audio: ${codecs}, ${playlistData.bitrate ?? 0}bps`); + return { + url: playlistUrl, + protocol: 'segmented', + format: 'mp4', + playlistData, + additionalData: { + source: 'vimeo.adaptive', + bitrate: playlistData.bitrate, + codecs, + segments: playlistData.segments.length, + sampleRate: playlistData.sampleRate, + format: audio.format + } + }; + } + buildVideoResult(playlistUrl, playlist, video) { + return { + url: playlistUrl, + protocol: 'segmented', + format: 'mp4', + playlistData: { + playlistUrl, + basePath: this.withTrailingSlash(playlist.base_url), + trackPath: this.withTrailingSlash(video.base_url), + initSegment: video.init_segment ?? null, + segments: video.segments ?? [], + duration: video.duration, + bitrate: video.avg_bitrate ?? video.bitrate, + codecs: video.codecs, + clipId: playlist.clip_id, + isDashFormat: video.format === 'dash', + streamType: 'mp4' + }, + additionalData: { + source: 'vimeo.video-fallback', + segments: video.segments?.length ?? 0 + } + }; + } + async pipeProgressive(url, output) { + try { + const response = await http1makeRequest(url, { + ...this.requestOptions(this.mediaHeaders()), + streamOnly: true + }); + if (response.statusCode !== 200 || !response.stream) { + throw new Error(`Vimeo progressive stream returned HTTP ${response.statusCode ?? 0}`); } + await pipeline(response.stream, output); + output.emit('finishBuffering'); } - if (playlist.video?.length) { - logger('warn', 'Sources', `[vimeo] No compatible audio tracks, falling back to video track`); - const video = playlist.video.reduce((best, v) => { - const bw = v.avg_bitrate || v.bitrate || 0; - return bw > (best?.avg_bitrate || best?.bitrate || 0) ? v : best; - }, null); - if (video?.segments?.length) { - const segments = video.segments.map((seg) => ({ - url: seg.url, - start: seg.start, - end: seg.end, - size: seg.size - })); - const playlistData = { - playlistUrl, - basePath: playlist.base_url || '', - trackPath: video.base_url || '', - initSegment: video.init_segment || null, - segments, - duration: video.duration, - bitrate: video.avg_bitrate || video.bitrate, - codecs: video.codecs, - clipId: playlist.clip_id, - isDashFormat: video.format === 'dash' - }; - return { - url: playlistUrl, - protocol: 'segmented', - format: 'mp4', - playlistData, - additionalData: { - source: 'vimeo.video-only', - segments: segments.length - } - }; + catch (error) { + if (!output.destroyed) { + output.destroy(error instanceof Error ? error : new Error(String(error))); } } - throw new Error('No compatible audio tracks in playlist'); + } + async pipeSegments(playlist, output) { + try { + if (playlist.initSegment) { + await this.write(output, Buffer.from(playlist.initSegment, 'base64')); + } + for (const segment of playlist.segments) { + if (output.destroyed || !segment.url) + return; + const url = buildSegmentUrl(playlist.playlistUrl, playlist.basePath, playlist.trackPath, segment.url); + const response = await http1makeRequest(url, { + ...this.requestOptions(this.mediaHeaders()), + responseType: 'buffer', + maxResponseBodyBytes: 5 * 1024 * 1024 + }); + if (response.statusCode !== 200 || !Buffer.isBuffer(response.body)) { + throw new Error(`Vimeo segment returned HTTP ${response.statusCode ?? 0}`); + } + await this.write(output, response.body); + } + if (!output.destroyed) { + output.emit('finishBuffering'); + output.end(); + } + } + catch (error) { + if (!output.destroyed) { + output.destroy(error instanceof Error ? error : new Error(String(error))); + } + } + } + async write(output, chunk) { + if (output.write(chunk)) + return; + await once(output, 'drain'); + } + withTrailingSlash(value) { + if (!value) + return ''; + return value.endsWith('/') ? value : `${value}/`; + } + handoffKey(videoId, hashParam) { + return `${videoId}:${hashParam ?? ''}`; + } + setHandoff(key, value) { + const now = Date.now(); + for (const [entryKey, entry] of this.handoff) { + if (entry.expiresAt <= now) + this.handoff.delete(entryKey); + } + while (this.handoff.size >= HANDOFF_MAX) { + const firstKey = this.handoff.keys().next().value; + if (typeof firstKey === 'string') + this.handoff.delete(firstKey); + } + this.handoff.set(key, { value, expiresAt: now + HANDOFF_TTL }); + } + takeHandoff(key) { + const entry = this.handoff.get(key); + this.handoff.delete(key); + if (!entry || entry.expiresAt <= Date.now()) + return null; + return entry.value; } } diff --git a/dist/src/sources/vkmusic.js b/dist/src/sources/vkmusic.js index 2398c7be..44e3d8fd 100644 --- a/dist/src/sources/vkmusic.js +++ b/dist/src/sources/vkmusic.js @@ -1,5 +1,5 @@ -import HLSHandler from "../playback/hls/HLSHandler.js"; -import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from "../utils.js"; +import HLSHandler from '../playback/hls/HLSHandler.js'; +import { encodeTrack, getBestMatch, http1makeRequest, logger, makeRequest } from '../utils.js'; /** * Base URL for the VK API. * @internal @@ -161,7 +161,7 @@ export default class VKMusicSource { body: 'version=1&app_id=6287487', disableBodyCompression: true, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); const body = res.body; if (res.error || @@ -207,7 +207,7 @@ export default class VKMusicSource { try { const res = await this._apiRequest('audio.search', { q: query, - count: String(this.nodelink.options.maxSearchResults || 10), + count: String(this.nodelink.options.search.maxResults || 10), extended: '1' }); if (!res?.items?.length) @@ -312,7 +312,7 @@ export default class VKMusicSource { const params = { owner_id: ownerId, extended: '1', - count: String(this.nodelink.options.maxAlbumPlaylistLength || 100) + count: String(this.nodelink.options.playback.maxPlaylistLength || 100) }; if (playlistId) params.album_id = playlistId; @@ -344,7 +344,7 @@ export default class VKMusicSource { try { const res = await http1makeRequest(url, { headers: { 'User-Agent': USER_AGENT, Cookie: this.cookie }, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); if (res.statusCode !== 200) throw new Error(`HTTP ${res.statusCode}`); @@ -424,7 +424,7 @@ export default class VKMusicSource { try { const res = await http1makeRequest(url, { headers: { 'User-Agent': USER_AGENT, Cookie: this.cookie }, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); if (res.statusCode !== 200) throw new Error(`HTTP ${res.statusCode}`); @@ -635,7 +635,7 @@ export default class VKMusicSource { type: 'mpegts', localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, startTime: additionalData?.startTime || 0, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }), type: 'mpegts' }; @@ -644,7 +644,7 @@ export default class VKMusicSource { method: 'GET', streamOnly: true, headers, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); if (res.error || !res.stream) throw new Error(res.error || 'Failed to fetch direct stream.'); @@ -672,7 +672,7 @@ export default class VKMusicSource { 'User-Agent': 'KateMobileAndroid/56 lite-460 (Android 4.4.2; SDK 19; x86; unknown Android SDK built for x86; en)' }, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); const body = res.body; if (res.error || res.statusCode !== 200 || body.error) { diff --git a/dist/src/sources/yandexmusic.js b/dist/src/sources/yandexmusic.js index 3d320fe6..7c612dfe 100644 --- a/dist/src/sources/yandexmusic.js +++ b/dist/src/sources/yandexmusic.js @@ -1,6 +1,6 @@ import crypto from 'node:crypto'; import { PassThrough } from 'node:stream'; -import { encodeTrack, getBestMatch, http1makeRequest, logger } from "../utils.js"; +import { encodeTrack, getBestMatch, http1makeRequest, logger } from '../utils.js'; /** * Base URL for the Yandex Music API. * @internal @@ -196,7 +196,7 @@ export default class YandexMusicSource { }); if (!data) return { loadType: 'empty', data: {} }; - const limit = this.nodelink.options.maxSearchResults || 10; + const limit = this.nodelink.options.search.maxResults || 10; if (searchType === 'album') { const albums = (data.albums?.results || []) .filter((item) => this.allowUnavailable || item.available) @@ -387,7 +387,7 @@ export default class YandexMusicSource { streamOnly: true, headers, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); }; let response = await requestStream(url); @@ -813,7 +813,7 @@ export default class YandexMusicSource { 'X-Yandex-Music-Client': CLIENT_HEADER }, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }); if (res.statusCode !== 200) { throw new Error(`Yandex API returned HTTP ${res.statusCode} for ${path}`); diff --git a/dist/src/sources/youtube/CipherManager.js b/dist/src/sources/youtube/CipherManager.js index b27efc5c..e853b4d9 100644 --- a/dist/src/sources/youtube/CipherManager.js +++ b/dist/src/sources/youtube/CipherManager.js @@ -1,4 +1,4 @@ -import { getVersion, http1makeRequest, logger, makeRequest } from "../../utils.js"; +import { getVersion, http1makeRequest, logger, makeRequest } from '../../utils.js'; const CACHE_DURATION_MS = 12 * 60 * 60 * 1000; const VERSION = getVersion(); /** @@ -73,8 +73,7 @@ export default class CipherManager { constructor(nodelink) { this.nodelink = nodelink; this.config = { - ...(nodelink.options.sources - ?.youtube?.cipher ?? {}) + ...(nodelink.options.sources?.youtube?.cipher ?? {}) }; if (this.config.url) { this.config.url = this.config.url.replace(/\/+$/, ''); @@ -272,7 +271,12 @@ export default class CipherManager { this.reportProxyStatus(proxy, !error && statusCode === 200, statusCode ?? 500, Date.now() - startTime); const parsedBody = (body ?? {}); if (error || statusCode !== 200 || !parsedBody.sts) { - throw new Error(`Failed to get STS: ${error || parsedBody.message || 'Invalid response'}`); + const detail = error || + parsedBody.message || + (typeof body === 'object' ? JSON.stringify(body) : body) || + 'Invalid response'; + logger('error', 'YouTube-Cipher', `Failed to get STS from cipher service (Status: ${statusCode ?? 'unknown'}): ${detail}`); + throw new Error(`Failed to get STS: ${detail}`); } logger('debug', 'YouTube-Cipher', `Received STS: ${parsedBody.sts}`); this.stsCache.set(playerUrl, parsedBody.sts); @@ -387,11 +391,16 @@ export default class CipherManager { } const { body, error, statusCode } = response; this.reportProxyStatus(proxy, !error && statusCode === 200, statusCode ?? 500, Date.now() - startTime); - logger('debug', 'YouTube-Cipher', `Received from cipher service (Status: ${statusCode})`); const parsedBody = (body ?? {}); if (error || statusCode !== 200 || !parsedBody.resolved_url) { - throw new Error(`Failed to resolve URL: ${error || parsedBody.message || 'Invalid response'}`); + const detail = error || + parsedBody.message || + (typeof body === 'object' ? JSON.stringify(body) : body) || + 'Invalid response'; + logger('error', 'YouTube-Cipher', `Failed to resolve URL via cipher service (Status: ${statusCode ?? 'unknown'}): ${detail}`); + throw new Error(`Failed to resolve URL: ${detail}`); } + logger('debug', 'YouTube-Cipher', `Received from cipher service (Status: ${statusCode}): ${parsedBody.resolved_url}`); logger('debug', 'YouTube-Cipher', `Resolved URL: ${parsedBody.resolved_url}`); return parsedBody.resolved_url; } @@ -430,7 +439,8 @@ export default class CipherManager { this.reportProxyStatus(proxy, !error && statusCode === 200, statusCode ?? 500, Date.now() - startTime); const watchPage = typeof body === 'string' ? body : ''; if (error || statusCode !== 200 || !watchPage) { - throw new Error(`Failed to fetch watch page for player script: ${error || statusCode || 'unknown'}`); + const reason = error || `Status ${statusCode ?? 'unknown'}`; + throw new Error(`Failed to fetch watch page for player script: ${reason}`); } const jsUrlMatch = watchPage.match(/"jsUrl":"([^"]+)"/); const scriptUrl = jsUrlMatch?.[1]; diff --git a/dist/src/sources/youtube/LiveChat.js b/dist/src/sources/youtube/LiveChat.js index 6fc69132..a0f7c8be 100644 --- a/dist/src/sources/youtube/LiveChat.js +++ b/dist/src/sources/youtube/LiveChat.js @@ -1,5 +1,5 @@ -import { logger, makeRequest } from "../../utils.js"; -import Web from "./clients/Web.js"; +import { logger, makeRequest } from '../../utils.js'; +import Web from './clients/Web.js'; /** * Helper responsible for bootstrapping and polling YouTube live chat. * diff --git a/dist/src/sources/youtube/OAuth.js b/dist/src/sources/youtube/OAuth.js index b3b6377a..eeeb46ad 100644 --- a/dist/src/sources/youtube/OAuth.js +++ b/dist/src/sources/youtube/OAuth.js @@ -1,4 +1,4 @@ -import { logger, makeRequest } from "../../utils.js"; +import { logger, makeRequest } from '../../utils.js'; const CLIENT_ID = '861556708454-d6dlm3lh05idd8npek18k6be8ba3oc68.apps.googleusercontent.com'; const CLIENT_SECRET = 'SboVhoG9s0rNafixCSGGKXAT'; const SCOPES = 'http://gdata.youtube.com https://www.googleapis.com/auth/youtube'; diff --git a/dist/src/sources/youtube/YouTube.js b/dist/src/sources/youtube/YouTube.js index edc3f751..7c7bb37c 100644 --- a/dist/src/sources/youtube/YouTube.js +++ b/dist/src/sources/youtube/YouTube.js @@ -1,20 +1,11 @@ import { PassThrough } from 'node:stream'; -import HLSHandler from "../../playback/hls/HLSHandler.js"; -import { getBestMatch, http1makeRequest, logger, makeRequest } from "../../utils.js"; -import CipherManager from "./CipherManager.js"; -import Android from "./clients/Android.js"; -import AndroidVR from "./clients/AndroidVR.js"; -import IOS from "./clients/IOS.js"; -import Music from "./clients/Music.js"; -import TV from "./clients/TV.js"; -import TVCast from "./clients/TVCast.js"; -import Web from "./clients/Web.js"; -import WebRemix from "./clients/Web_Remix.js"; -import WebEmbedded from "./clients/WebEmbedded.js"; -import { checkURLType, YOUTUBE_CONSTANTS } from "./common.js"; -import YouTubeLiveChat from "./LiveChat.js"; -import OAuth from "./OAuth.js"; -import { SabrStream } from "./sabr/sabr.js"; +import HLSHandler from '../../playback/hls/HLSHandler.js'; +import { getBestMatch, http1makeRequest, logger, makeRequest } from '../../utils.js'; +import CipherManager from './CipherManager.js'; +import { checkURLType, YOUTUBE_CONSTANTS } from './common.js'; +import YouTubeLiveChat from './LiveChat.js'; +import OAuth from './OAuth.js'; +import { SabrStream } from './sabr/sabr.js'; /** Size in bytes of each range-request chunk for direct HTTP streaming. */ const CHUNK_SIZE = 64 * 1024; /** Maximum consecutive errors before triggering URL recovery. */ @@ -23,6 +14,13 @@ const MAX_RETRIES = 3; const MAX_URL_REFRESH = 10; /** Interval in milliseconds between visitor data refreshes. */ const VISITOR_DATA_INTERVAL = 3_600_000; +/** PassThrough buffer size. 48KB = ~3s of 128kbps Opus, enough to cover reconnect gaps. */ +const STREAM_BUFFER_SIZE = 48 * 1024; +/** Refresh URL before YouTube's ~6h expiry. */ +const URL_MAX_AGE_MS = 4.5 * 60 * 60 * 1000; +/** Recovery base delay with exponential backoff. So 2s, 4s, 8s, etc. */ +const RECOVER_BASE_DELAY_MS = 2000; +const MAX_RETRY_DELAY_MS = 8000; /** * Manages a scored pool of proxies with automatic health tracking. * @@ -145,6 +143,8 @@ export default class YouTubeSource { oauth; /** Interval handle for periodic visitor data refresh, or `null` when not running. */ visitorDataInterval; + /** Interval handle to clear failingClientsByTrack periodically. */ + failingClientsInterval; /** Cipher/signature decryption manager shared across all innertube clients. */ cipherManager; /** Live chat connection handler for YouTube live streams. */ @@ -153,8 +153,12 @@ export default class YouTubeSource { activeStreams; /** Set of fallback-mirror lookup keys currently in flight, used to prevent infinite recursion loops. */ mirrorFallbackInFlight; + /** Map of track identifiers to a set of client names that failed to provide a playable URL. */ + failingClientsByTrack; /** YouTube innertube request context sent with every API call (device info, locale, visitor data). */ ytContext; + /** Dynamic bandwidth estimate in bits per second (starts at 128kbps/16KB/s). */ + bandwidthEstimate = 128_000; // -- Public fields consumed by the framework -- /** Additional source names this source can proxy through (e.g. `['ytmusic']`). */ additionalsSourceName; @@ -172,7 +176,8 @@ export default class YouTubeSource { */ constructor(nodelink) { this.nodelink = nodelink; - this.config = nodelink.options.sources?.youtube; + this.config = nodelink.options.sources + .youtube; this.proxyManager = new YouTubeProxyManager(this.config.proxies || []); this.additionalsSourceName = ['ytmusic']; this.searchTerms = ['ytsearch', 'ytmsearch']; @@ -186,6 +191,7 @@ export default class YouTubeSource { this.clients = {}; this.oauth = null; this.visitorDataInterval = null; + this.failingClientsInterval = null; this.cipherManager = new CipherManager(nodelink); this.liveChat = new YouTubeLiveChat(nodelink, { getProxy: this.getProxy.bind(this), @@ -193,6 +199,7 @@ export default class YouTubeSource { }); this.activeStreams = new Map(); this.mirrorFallbackInFlight = new Set(); + this.failingClientsByTrack = new Map(); this.ytContext = { client: { screenDensityFloat: 1, @@ -234,6 +241,18 @@ export default class YouTubeSource { async setup() { logger('info', 'YouTube', 'Setting up YouTube source...'); this.oauth = new OAuth(this.nodelink); + const [{ default: Android }, { default: AndroidVR }, { default: IOS }, { default: Music }, { default: WebRemix }, { default: TV }, { default: TV_DOWN }, { default: TVCast }, { default: Web }, { default: WebEmbedded }] = await Promise.all([ + import('./clients/Android.js'), + import('./clients/AndroidVR.js'), + import('./clients/IOS.js'), + import('./clients/Music.js'), + import('./clients/Web_Remix.js'), + import('./clients/TV.js'), + import('./clients/TV_downgraded.js'), + import('./clients/TVCast.js'), + import('./clients/Web.js'), + import('./clients/WebEmbedded.js') + ]); const clientClasses = { Android, AndroidVR, @@ -241,6 +260,7 @@ export default class YouTubeSource { Music, WebRemix, TV, + TV_DOWN, TVCast, Web, WebEmbedded @@ -254,13 +274,14 @@ export default class YouTubeSource { logger('debug', 'YouTube', `Initialized clients: ${Object.keys(this.clients).join(', ')}`); await this._fetchVisitorData(); await this.cipherManager.getCachedPlayerScript(); - await this.cipherManager.checkCipherServerStatus(); if (this.visitorDataInterval) clearInterval(this.visitorDataInterval); this.visitorDataInterval = setInterval(() => this._fetchVisitorData(), VISITOR_DATA_INTERVAL); - if (typeof this.visitorDataInterval.unref === 'function') { - this.visitorDataInterval.unref(); - } + this.visitorDataInterval.unref?.(); + if (this.failingClientsInterval) + clearInterval(this.failingClientsInterval); + this.failingClientsInterval = setInterval(() => this.failingClientsByTrack.clear(), 1000 * 60 * 60 * 12); + this.failingClientsInterval.unref?.(); logger('info', 'YouTube', 'YouTube source setup complete.'); return true; } @@ -278,9 +299,14 @@ export default class YouTubeSource { clearInterval(this.visitorDataInterval); this.visitorDataInterval = null; } + if (this.failingClientsInterval) { + clearInterval(this.failingClientsInterval); + this.failingClientsInterval = null; + } if (this.oauth) this.oauth.cleanup?.(); this.cipherManager?.cleanup?.(); + this.failingClientsByTrack.clear(); } /** * Fetches visitor data and player script URL from YouTube embed pages. @@ -303,7 +329,7 @@ export default class YouTubeSource { const { body: data, error, statusCode } = await makeRequest('https://www.youtube.com/embed', { method: 'GET', headers: { - Cookie: 'YSC=cz5kYp3ZuIE; VISITOR_INFO1_LIVE=U-0T5oUyzf8;' + Cookie: 'YSC=LUAfwHpna4E; VISITOR_INFO1_LIVE=Zuih2uZbq3I;' } }); if (!error && statusCode === 200) { @@ -311,15 +337,16 @@ export default class YouTubeSource { const visitorMatch = bodyStr?.match(/"VISITOR_DATA":"([^"]+)"/); if (visitorMatch?.[1]) { this.ytContext.client.visitorData = visitorMatch[1]; - this.nodelink.credentialManager?.set('yt_visitor_data', visitorMatch[1], 60 * 60 * 1000); visitorFound = true; - logger('debug', 'YouTube', 'visitorData refreshed and cached.'); + logger('debug', 'YouTube', 'visitorData refreshed from embed.'); } - const playerScriptMatch = bodyStr?.match(/"jsUrl":"([^"]+)"/); - if (playerScriptMatch?.[1]) { - playerScriptUrl = playerScriptMatch[1].replace(/\/[a-z]{2}_[A-Z]{2}\//, '/en_US/'); - this.nodelink.credentialManager?.set('yt_player_script_url', playerScriptUrl, 12 * 60 * 60 * 1000); - logger('debug', 'YouTube', `Player script URL: ${playerScriptUrl}`); + if (!cachedPlayerScript) { + const playerScriptMatch = bodyStr?.match(/"jsUrl":"([^"]+)"/); + if (playerScriptMatch?.[1]) { + playerScriptUrl = playerScriptMatch[1].replace(/\/[a-z]{2}_[A-Z]{2}\//, '/en_US/'); + this.nodelink.credentialManager?.set('yt_player_script_url', playerScriptUrl, 12 * 60 * 60 * 1000); + logger('debug', 'YouTube', `Player script URL: ${playerScriptUrl}`); + } } } else { @@ -337,18 +364,16 @@ export default class YouTubeSource { guideBody?.responseContext?.visitorData) { this.ytContext.client.visitorData = guideBody.responseContext.visitorData; - this.nodelink.credentialManager?.set('yt_visitor_data', guideBody.responseContext.visitorData, 60 * 60 * 1000); visitorFound = true; - logger('debug', 'YouTube', 'visitorData refreshed via guide and cached.'); + logger('debug', 'YouTube', 'visitorData refreshed via guide.'); } else { - logger('warn', 'YouTube', 'Failed to refresh visitorData via guide; using cached fallback if present.'); + logger('warn', 'YouTube', 'Failed to refresh visitorData via guide.'); } } } catch (e) { logger('error', 'YouTube', `Error fetching visitor data: ${e.message}`); - logger('warn', 'YouTube', 'Using cached visitorData fallback (if present).'); } if (playerScriptUrl) this.cipherManager.setPlayerScriptUrl(playerScriptUrl); @@ -445,7 +470,7 @@ export default class YouTubeSource { logger('debug', 'YouTube', `Music client failed for recommendations: ${e.message}`); } } - if ((!automixRes || automixRes.loadType !== 'playlist') && + if (automixRes?.loadType !== 'playlist' && (this.clients.TV || this.clients.TVCast || this.clients.WebRemix)) { try { const tvClient = this.clients.TV ?? this.clients.TVCast; @@ -522,7 +547,7 @@ export default class YouTubeSource { return result; } if (result?.loadType === 'error' && - result.data?.cause === 'UpstreamPlayability') { + result.exception?.cause === 'UpstreamPlayability') { const listIdMatch = url.match(/[?&]list=([\w-]+)/); const videoIdMatch = url.match(/[?&]v=([\w-]+)/); const listId = listIdMatch ? listIdMatch[1] : null; @@ -565,7 +590,7 @@ export default class YouTubeSource { } } } - const errorMessage = result?.data?.message || + const errorMessage = result?.exception?.message || `${clientName} client returned empty or failed.`; clientErrors.push({ client: clientName, message: errorMessage }); logger('debug', 'YouTube', `${clientName} client returned empty or failed for Music URL.`); @@ -691,12 +716,11 @@ export default class YouTubeSource { const playerBody = playerResult?.body; if (!playerBody || playerBody.error) return vanillaTrack; - const { buildHoloTrack } = await import("./common.js"); - const holoTrack = await buildHoloTrack(info, null, info.sourceName === 'ytmusic' ? 'ytmusic' : 'youtube', - // biome-ignore lint/suspicious/noExplicitAny: buildHoloTrack is dynamically imported from JS with inferred null-typed param - playerBody, { + const { buildHoloTrack } = await import('./common.js'); + const holoTrack = await buildHoloTrack(info, null, info.sourceName === 'ytmusic' ? 'ytmusic' : 'youtube', playerBody, { fetchChannelInfo: options.fetchChannelInfo ?? false, - resolveExternalLinks: options.resolveExternalLinks ?? false + resolveExternalLinks: options.resolveExternalLinks ?? false, + search: {} }); if (holoTrack) holoTrack.userData = userData; @@ -739,7 +763,12 @@ export default class YouTubeSource { if (!clientList.length) clientList = ['Web']; const clientErrors = []; + const failingClients = this.failingClientsByTrack.get(decodedTrack.identifier); for (const clientName of clientList) { + if (failingClients?.has(clientName)) { + logger('debug', 'YouTube', `Skipping known failing client ${clientName} for track ${decodedTrack.identifier}`); + continue; + } const client = this.clients[clientName]; if (!client) continue; @@ -750,6 +779,16 @@ export default class YouTubeSource { const urlData = await client.getTrackUrl(decodedTrack, this.ytContext, this.cipherManager, itag, proxyToUse); const proxyLatency = Date.now() - proxyStartTime; if (urlData.exception) { + const isNoStream = urlData.exception.cause === 'UpstreamNoStream'; + const isNotFound = urlData.exception.status === 404; + if (isNoStream || isNotFound) { + if (!this.failingClientsByTrack.has(decodedTrack.identifier)) { + this.failingClientsByTrack.set(decodedTrack.identifier, new Set()); + } + this.failingClientsByTrack + .get(decodedTrack.identifier) + ?.add(clientName); + } this.reportProxyStatus(proxyToUse, false, urlData.exception.status || 500, proxyLatency); clientErrors.push({ client: clientName, @@ -796,7 +835,12 @@ export default class YouTubeSource { logger('debug', 'YouTube', `URL pre-flight check successful for client ${clientName}.`); const result = { ...urlData, - additionalData: { contentLength, proxy: proxyToUse } + additionalData: { + contentLength, + proxy: proxyToUse, + itag: urlData.itag, + formats: urlData.formats + } }; this.nodelink.trackCacheManager?.set('youtube', decodedTrack.identifier, result, 1000 * 60 * 60 * 5); return result; @@ -935,9 +979,10 @@ export default class YouTubeSource { ? this.config.fallbackSources : []; const opts = this.nodelink.options; - const defaultSources = Array.isArray(opts.defaultSearchSource) - ? opts.defaultSearchSource - : [opts.defaultSearchSource]; + const searchConfig = opts.search; + const defaultSources = Array.isArray(searchConfig?.defaultSource) + ? searchConfig.defaultSource + : [searchConfig?.defaultSource]; const fallbackOrder = [ ...configuredFallbackSources, ...defaultSources, @@ -978,8 +1023,7 @@ export default class YouTubeSource { for (const fallbackSource of fallbackOrder) { try { const search = await this.nodelink.sources?.search(fallbackSource, query); - if (!search || - search.loadType !== 'search' || + if (search?.loadType !== 'search' || !Array.isArray(search.data) || search.data.length === 0) { continue; @@ -1069,8 +1113,8 @@ export default class YouTubeSource { } } if (contentLength && contentLength > 0) { - logger('debug', 'YouTube', `Using range buffering for ${decodedTrack.title} (${Math.round(contentLength / 1024 / 1024)}MB)`); - return this._streamWithRangeRequests(url, contentLength, decodedTrack, cancelSignal, streamKey, additionalData); + logger('debug', 'YouTube', `Using Chunked HTTP buffering for ${decodedTrack.title} (${Math.round(contentLength / 1024 / 1024)}MB)`); + return this._streamChunkedHttp(url, contentLength, decodedTrack, cancelSignal, streamKey, additionalData); } return await this._loadDirectStream(url, decodedTrack, cancelSignal, streamKey, additionalData); } @@ -1111,6 +1155,7 @@ export default class YouTubeSource { formats: additionalData.formats, startTime: additionalData.startTime ?? 0, positionCallback: additionalData.positionCallback, + playbackPaused: additionalData.playbackPaused, previousSession: additionalData.previousSession }; const sabr = new SabrStream(sabrConfig); @@ -1123,17 +1168,19 @@ export default class YouTubeSource { readyReject = reject; }); let isRecovering = false; - let lastRecoverAt = 0; + sabr.once('mediaProgress', () => { + if (readyResolved) + return; + readyResolved = true; + readyResolve(); + }); sabr.on('data', (chunk) => { - if (!readyResolved) { - readyResolved = true; - readyResolve(); - } if (!stream.write(chunk)) { sabr.pause(); } }); - stream.on('drain', () => sabr.resume()); + const onSabrDrain = () => sabr.resume(); + stream.on('drain', onSabrDrain); sabr.on('end', () => { if (!readyResolved) { readyResolved = true; @@ -1142,24 +1189,26 @@ export default class YouTubeSource { stream.end(); }); sabr.on('finishBuffering', () => stream.emit('finishBuffering')); - sabr.on('stall', async () => { - if (isRecovering || stream.destroyed) - return; - const now = Date.now(); - if (now - lastRecoverAt < 2000) + sabr.on('stall', async (reason = 'starvation', recoveryGeneration) => { + if (isRecovering || stream.destroyed || sabr.destroyed) return; - lastRecoverAt = now; isRecovering = true; + const generation = recoveryGeneration ?? sabr.getMediaProgressGeneration(); try { - logger('warn', 'YouTube', `SABR stall detected for ${decodedTrack.title}. Refreshing session...`); + logger('warn', 'YouTube', `SABR ${reason} recovery requested for ${decodedTrack.title}. Refreshing session...`); const newUrlData = await this.getTrackUrl(decodedTrack, null, true); - if (!newUrlData || newUrlData.protocol !== 'sabr') { + if (newUrlData?.protocol !== 'sabr') { throw new Error('No SABR session available for recovery'); } + if (!sabr.canCommitRecovery(generation)) { + logger('debug', 'YouTube', `Discarding stale SABR replacement for ${decodedTrack.title}; media advanced during recovery.`); + sabr.cancelRecovery(); + return; + } const ad = (newUrlData.additionalData || {}); sabr.clearBuffers(); sabr.updateSession({ - serverAbrStreamingUrl: (ad.serverAbrStreamingUrl || newUrlData.url), + serverAbrStreamingUrl: ad.serverAbrStreamingUrl || newUrlData.url, videoPlaybackUstreamerConfig: ad.videoPlaybackUstreamerConfig, poToken: ad.poToken, visitorData: ad.visitorData, @@ -1171,8 +1220,15 @@ export default class YouTubeSource { } catch (err) { logger('warn', 'YouTube', `SABR recovery failed: ${err.message}`); - if (!stream.destroyed) + if (!readyResolved) { + readyResolved = true; + readyReject(err); + if (!stream.destroyed) + stream.destroy(); + } + else if (!stream.destroyed) { stream.destroy(err); + } } finally { isRecovering = false; @@ -1183,12 +1239,8 @@ export default class YouTubeSource { if (!readyResolved) { readyResolved = true; readyReject(err); - } - if ((err.message.includes('sabr.malformed_config') || - err.message.includes('sabr.media_serving_enforcement_id_error')) && - !isRecovering) { - logger('info', 'YouTube', `Known recoverable error detected (${err.message}), triggering stall recovery...`); - sabr.emit('stall'); + if (!stream.destroyed) + stream.destroy(); return; } if (!stream.destroyed) @@ -1200,6 +1252,7 @@ export default class YouTubeSource { if (isDestroying) return stream; isDestroying = true; + stream.removeListener('drain', onSabrDrain); sabr.destroy(err); this.activeStreams.delete(streamKey); originalDestroy(err); @@ -1209,14 +1262,19 @@ export default class YouTubeSource { if (isDestroying) return; isDestroying = true; + stream.removeListener('drain', onSabrDrain); sabr.destroy(); this.activeStreams.delete(streamKey); }); stream._sabrStream = sabr; - stream.getSessionState = () => { + stream.beginSeekHandoff = () => { if (isDestroying || stream.destroyed) - return null; - return sabr.getSessionState(); + return Promise.resolve(null); + return sabr.beginSeekHandoff(); + }; + stream.cancelSeekHandoff = () => { + if (!isDestroying && !stream.destroyed) + sabr.cancelSeekHandoff(); }; const bestAudio = (additionalData.formats ?? []) .filter((f) => f.mimeType?.includes('audio')) @@ -1311,11 +1369,16 @@ export default class YouTubeSource { stream.responseStream = responseStream; let cleanedUp = false; + const onDrain = () => { + if (!responseStream.destroyed) + responseStream.resume(); + }; const cleanup = () => { if (cleanedUp) return; cleanedUp = true; cancelSignal.aborted = true; + stream.removeListener('drain', onDrain); responseStream.removeAllListeners(); if (!responseStream.destroyed) responseStream.destroy(); @@ -1327,10 +1390,7 @@ export default class YouTubeSource { responseStream.pause(); } }); - stream.on('drain', () => { - if (!responseStream.destroyed) - responseStream.resume(); - }); + stream.on('drain', onDrain); responseStream.on('end', () => { cleanup(); if (!stream.writableEnded) { @@ -1388,6 +1448,10 @@ export default class YouTubeSource { let activeRequest = null; let recoverTimeout = null; let currentAdditionalData = additionalData; + let currentItag = currentAdditionalData?.itag; + let availableFormats = currentAdditionalData?.formats || []; + const failedItags = new Set(); + const _isRecovering = false; const cleanup = () => { if (destroyed) return; @@ -1469,7 +1533,11 @@ export default class YouTubeSource { (statusCode ?? 0) >= 500) { logger('warn', 'YouTube', `Got ${statusCode} at pos ${position} → forcing recovery`); fetching = false; - recover(); + recover({ + message: `HTTP ${statusCode}`, + statusCode, + name: 'Error' + }); return; } throw new Error(`Range request failed: ${statusCode}`); @@ -1513,8 +1581,7 @@ export default class YouTubeSource { } else { const timeout = setTimeout(fetchNext, Math.min(1000 * 2 ** (errors - 1), 5000)); - if (typeof timeout.unref === 'function') - timeout.unref(); + timeout.unref?.(); } } }; @@ -1541,8 +1608,7 @@ export default class YouTubeSource { } else { const timeout = setTimeout(fetchNext, Math.min(1000 * 2 ** (errors - 1), 5000)); - if (typeof timeout.unref === 'function') - timeout.unref(); + timeout.unref?.(); } } } @@ -1553,7 +1619,7 @@ export default class YouTubeSource { const isForbidden = causeError?.message?.includes('403') || causeError?.statusCode === 403; const isAborted = causeError?.message === 'aborted' || causeError?.code === 'ECONNRESET'; - if (!isForbidden && !isAborted && refreshes === 0) { + if (!isForbidden && refreshes === 0) { logger('debug', 'YouTube', `Retrying same URL for recovery first (cause: ${causeError?.message})...`); errors = 0; fetching = false; @@ -1572,44 +1638,74 @@ export default class YouTubeSource { cleanup(); return; } - if (isAborted && stream.writableNeedDrain) { - logger('debug', 'YouTube', `Stream is paused/backed up, skipping recovery (cause: ${causeError?.message}). Player will recover on resume.`); - return; - } if (isAborted && stream.writableNeedDrain) { logger('debug', 'YouTube', `Stream is paused/backed up, waiting for drain before recovery (cause: ${causeError?.message})`); await new Promise((resolve) => { - const onDrain = () => { - stream.off('drain', onDrain); + const onDrainOrEnd = () => { + cleanupListeners(); resolve(); }; - stream.once('drain', onDrain); - const timeout = setTimeout(() => { - stream.off('drain', onDrain); - resolve(); - }, 60000); - if (typeof timeout.unref === 'function') - timeout.unref(); + const cleanupListeners = () => { + stream.off('drain', onDrainOrEnd); + stream.off('close', onDrainOrEnd); + stream.off('error', onDrainOrEnd); + }; + stream.once('drain', onDrainOrEnd); + stream.once('close', onDrainOrEnd); + stream.once('error', onDrainOrEnd); }); if (destroyed || cancelSignal.aborted || stream.destroyed) return; - if (stream.writableNeedDrain) { - logger('debug', 'YouTube', 'Stream still backed up after drain wait, deferring recovery until resume'); - return; - } } try { - const newUrlData = await this.getTrackUrl(decodedTrack, null, true); + let itagToTry = null; + if (refreshes > 2 && currentItag) { + failedItags.add(currentItag); + logger('warn', 'YouTube', `Itag ${currentItag} failed consistently. Attempting quality fallback...`); + const currentMime = currentAdditionalData?.formats?.find((f) => f.itag === currentItag) + ?.mimeType || ''; + const isWebm = currentMime.includes('webm'); + const otherAudioFormats = availableFormats + .filter((f) => f.itag !== currentItag && + !failedItags.has(f.itag) && + f.mimeType?.includes('audio') && + (isWebm + ? f.mimeType.includes('webm') + : f.mimeType.includes('mp4'))) + .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0)); + const bestFallback = otherAudioFormats[0]; + if (bestFallback) { + itagToTry = bestFallback.itag; + logger('info', 'YouTube', `Switching to itag ${itagToTry} (available: ${otherAudioFormats.map((f) => f.itag).join(', ')})`); + } + } + const newUrlData = await this.getTrackUrl(decodedTrack, itagToTry, true); if (destroyed || cancelSignal.aborted) return; if (newUrlData.exception || !newUrlData.url) { throw new Error('No valid URL from getTrackUrl'); } + const oldContentLength = currentAdditionalData?.contentLength || + contentLength; + const newAdditionalData = newUrlData.additionalData; + const newContentLength = newAdditionalData?.contentLength; + if (oldContentLength && + newContentLength && + oldContentLength !== newContentLength) { + const ratio = newContentLength / oldContentLength; + const oldPos = position; + position = Math.floor(position * ratio); + contentLength = newContentLength; + logger('debug', 'YouTube', `Adjusted position for itag switch (${currentItag} -> ${newUrlData.itag || itagToTry}): ${oldPos} -> ${position} bytes (ratio: ${ratio.toFixed(4)})`); + } currentUrl = newUrlData.url; currentAdditionalData = newUrlData.additionalData; + currentItag = newUrlData.itag || itagToTry || currentItag; + if (newUrlData.formats) + availableFormats = newUrlData.formats; errors = 0; - logger('debug', 'YouTube', `URL recovered for ${decodedTrack.title} (resume at ${position} bytes, attempt ${refreshes}, cause: ${causeError?.message})`); + logger('debug', 'YouTube', `URL recovered for ${decodedTrack.title} (resume at ${position} bytes, attempt ${refreshes}, itag ${currentItag}, cause: ${causeError?.message})`); fetching = false; fetchNext(); } @@ -1617,9 +1713,7 @@ export default class YouTubeSource { logger('warn', 'YouTube', `Recovery failed (attempt ${refreshes}): ${error.message}`); if (!destroyed && !cancelSignal.aborted) { recoverTimeout = setTimeout(() => recover(causeError), 4000 + refreshes * 1000); - if (typeof recoverTimeout.unref === 'function') { - recoverTimeout.unref(); - } + recoverTimeout.unref?.(); } } }; @@ -1632,6 +1726,397 @@ export default class YouTubeSource { }); return { stream }; } + /** + * Streams audio using chunked range requests. This tries to "Replicate" on how the browser + * streams audio directly from youtube with code status 206. + * + * Uses dynamic chunk sizing (256 KB – 512 KB) based on per-stream bandwidth + * The limit is around ~570 KB per chunk. But setted to 512KB for better memory efficiency. + * Fast-reconnects on ECONNRESET without refreshing the URL until the third consecutive failure. + * Opens only 1 connection per stream, reusing it for multiple chunks. + * This is the same ideia used for _streamWithRangeRequests, but this tries to limit to 1 connection only. + * + * + * @param url - Initial playback URL. + * @param contentLength - Total content length in bytes. + * @param decodedTrack - Track metadata for URL recovery. + * @param cancelSignal - Shared cancel token for stream abort. + * @param streamKey - Unique key for tracking this stream. + * @param additionalData - Optional proxy and format info. + * @returns StreamResult with the PassThrough stream. + */ + async _streamChunkedHttp(url, contentLength, decodedTrack, cancelSignal, streamKey, additionalData) { + const stream = new PassThrough({ + highWaterMark: STREAM_BUFFER_SIZE + }); + let currentUrl = url; + let currentProxy = additionalData?.proxy; + if (!currentProxy) { + currentProxy = this.getProxy(); + } + let urlFetchTime = Date.now(); + let isDestroyed = false; + let isBackpressured = false; + let totalBytesReceived = 0; + let currentItag = additionalData?.itag; + let availableFormats = additionalData?.formats || []; + const failedItags = new Set(); + let refreshAttempts = 0; + let consecutiveResets = 0; + let activeResponseStream = null; + let bandwidthEstimate = this.bandwidthEstimate || 128_000; + const updateBandwidthEstimate = (bytes, durationMs) => { + if (bytes <= 0 || durationMs <= 0) + return; + const bits = bytes * 8; + const throughput = (bits / durationMs) * 1000; + const alpha = 0.25; + bandwidthEstimate = Math.max(128_000, alpha * throughput + (1 - alpha) * bandwidthEstimate); + // this will update the class-level bandwidth estimate for future streams, + // so that it can be used to seed the estimate for new streams and cause less errors hopefully. + this.bandwidthEstimate = bandwidthEstimate; + }; + const onDrain = () => { + isBackpressured = false; + if (activeResponseStream && !activeResponseStream.destroyed) { + activeResponseStream.resume(); + } + }; + let _wakeUp = null; + const cancelSleep = () => { + _wakeUp?.(); + _wakeUp = null; + }; + const sleep = (ms) => new Promise((r) => { + const t = setTimeout(() => { + _wakeUp = null; + r(); + }, ms); + t.unref?.(); + _wakeUp = () => { + clearTimeout(t); + r(); + }; + }); + const cleanup = (err) => { + if (isDestroyed) + return; + isDestroyed = true; + cancelSignal.aborted = true; + cancelSleep(); + stream.removeListener('drain', onDrain); + if (activeResponseStream && !activeResponseStream.destroyed) { + activeResponseStream.destroy(); + activeResponseStream = null; + } + if (!stream.destroyed) + stream.destroy(err); + this.activeStreams.delete(streamKey); + }; + // Waits for the PassThrough to drain after a backpressure-caused reset, + // without leaving a dangling listener for whichever event didn't fire. + const waitForDrainOrClose = () => new Promise((resolve) => { + const onReady = () => { + stream.removeListener('drain', onReady); + stream.removeListener('close', onReady); + resolve(); + }; + stream.once('drain', onReady); + stream.once('close', onReady); + }); + stream.once('close', () => cleanup()); + stream.once('error', (err) => cleanup(err)); + stream.on('drain', onDrain); + const refreshUrl = async (reason) => { + if (isDestroyed || cancelSignal.aborted) + return null; + if (++refreshAttempts > MAX_URL_REFRESH) { + logger('error', 'YouTube', `Max URL refresh (${MAX_URL_REFRESH}) reached for ${decodedTrack.title}`); + return null; + } + logger('debug', 'YouTube', `Refreshing URL for "${decodedTrack.title}" (reason: ${reason}, ${refreshAttempts}/${MAX_URL_REFRESH})`); + try { + let itagToTry = null; + if (currentItag && + failedItags.has(currentItag) && + availableFormats.length > 0) { + const currentMime = availableFormats.find((f) => f.itag === currentItag)?.mimeType || ''; + const isWebm = currentMime.includes('webm'); + const fallback = availableFormats + .filter((f) => f.itag !== currentItag && + !failedItags.has(f.itag) && + f.mimeType?.includes('audio') && + (isWebm + ? f.mimeType.includes('webm') + : f.mimeType.includes('mp4'))) + .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0))[0]; + if (fallback) { + itagToTry = fallback.itag; + logger('info', 'YouTube', `Switching to itag ${itagToTry} for "${decodedTrack.title}"`); + } + } + const newUrlData = await this.getTrackUrl(decodedTrack, itagToTry, true); + if (isDestroyed || cancelSignal.aborted) + return null; + if (newUrlData.exception || !newUrlData.url) + return null; + currentUrl = newUrlData.url; + const newAd = newUrlData.additionalData; + currentProxy = + newAd?.proxy || + currentProxy; + currentItag = newUrlData.itag || currentItag; + if (newUrlData.formats) + availableFormats = newUrlData.formats; + urlFetchTime = Date.now(); + consecutiveResets = 0; + logger('debug', 'YouTube', `URL refreshed for "${decodedTrack.title}" (itag ${currentItag})`); + return currentUrl; + } + catch (err) { + logger('error', 'YouTube', `URL refresh failed: ${err.message}`); + return null; + } + }; + const startStreaming = async () => { + const MIN_TARGET_SECONDS = 2; + const MAX_TARGET_SECONDS = 12; + const INITIAL_TARGET_SECONDS = 4; + let targetSeconds = INITIAL_TARGET_SECONDS; + const ABS_MIN_BYTES = 64 * 1024; + const ABS_MAX_BYTES = 512 * 1024; + const trackBytesPerSecond = contentLength > 0 && decodedTrack.length > 0 + ? contentLength / (decodedTrack.length / 1000) + : 16_000; + let chunkCount = 0; + while (!isDestroyed && + !cancelSignal.aborted && + totalBytesReceived < contentLength) { + const urlAge = Date.now() - urlFetchTime; + if (urlAge > URL_MAX_AGE_MS) { + const refreshed = await refreshUrl('URL age > 4.5h'); + if (!refreshed) { + cleanup(new Error('Failed to refresh expired URL')); + return; + } + } + const proxyToUse = currentProxy; + const fetchStartTime = Date.now(); + const bytesPerSecond = bandwidthEstimate / 8; + let dynamicChunkSize = Math.floor(bytesPerSecond * targetSeconds); + dynamicChunkSize = Math.max(ABS_MIN_BYTES, Math.min(dynamicChunkSize, ABS_MAX_BYTES)); + const start = totalBytesReceived; + const end = Math.min(start + dynamicChunkSize - 1, contentLength - 1); + const rangeHeader = `bytes=${start}-${end}`; + try { + const result = await http1makeRequest(currentUrl, { + method: 'GET', + streamOnly: true, + proxy: proxyToUse, + timeout: 30000, + headers: { + Range: rangeHeader, + 'Accept-Encoding': 'identity;q=1, *;q=0', + 'Sec-Fetch-Dest': 'video', + 'Sec-Fetch-Mode': 'no-cors', + 'Sec-Fetch-Site': 'same-origin', + Referer: currentUrl, + Accept: '*/*', + 'Accept-Language': 'en-US,en;q=0.9', + 'Cache-Control': 'no-cache', + Pragma: 'no-cache', + Priority: 'i' + } + }); + if (isDestroyed || cancelSignal.aborted) { + const s = result.stream; + if (s && !s.destroyed) { + s.destroy(); + } + return; + } + this.reportProxyStatus(proxyToUse, !result.error && result.statusCode === 206, result.statusCode || 0, Date.now() - fetchStartTime); + if (result.error || + (result.statusCode !== 200 && result.statusCode !== 206)) { + if (result.statusCode === 403 || result.statusCode === 404) { + logger('warn', 'YouTube', `HTTP ${result.statusCode} for "${decodedTrack.title}" -- refreshing...`); + if (currentItag) + failedItags.add(currentItag); + const refreshed = await refreshUrl(`HTTP ${result.statusCode}`); + if (refreshed) + continue; + cleanup(new Error(`HTTP ${result.statusCode}: max URL refresh reached`)); + return; + } + const retryDelay = Math.min(RECOVER_BASE_DELAY_MS * 2 ** Math.max(0, refreshAttempts - 1), MAX_RETRY_DELAY_MS); + logger('warn', 'YouTube', `HTTP ${result.statusCode}, retrying in ${retryDelay}ms...`); + await sleep(retryDelay); + continue; + } + const contentRangeHeader = result.headers?.['content-range']; + const contentRange = Array.isArray(contentRangeHeader) + ? contentRangeHeader[0] + : contentRangeHeader == null + ? null + : String(contentRangeHeader); + const rangeMatch = result.statusCode === 206 + ? /^bytes\s+(\d+)-(\d+)\/(\d+|\*)$/i.exec(contentRange ?? '') + : null; + const responseStart = rangeMatch ? Number(rangeMatch[1]) : -1; + const responseEnd = rangeMatch ? Number(rangeMatch[2]) : -1; + if (result.statusCode !== 206 || + responseStart !== start || + responseEnd < responseStart || + responseEnd > end) { + const responseStream = result.stream; + responseStream?.destroy?.(); + logger('warn', 'YouTube', `Invalid range response for ${rangeHeader}: HTTP ${result.statusCode}, Content-Range ${contentRange ?? 'missing'}. Refreshing URL...`); + const refreshed = await refreshUrl('invalid range response'); + if (refreshed) + continue; + cleanup(new Error('Invalid HTTP range response')); + return; + } + const responseStream = result.stream; + activeResponseStream = responseStream; + let bytesThisChunk = 0; + let dataStartTime = 0; + await new Promise((resolve, reject) => { + if (isDestroyed || cancelSignal.aborted) { + if (!responseStream.destroyed) + responseStream.destroy(); + return resolve(); + } + const onData = (chunk) => { + if (isDestroyed || cancelSignal.aborted) { + responseStream.destroy(); + return; + } + if (dataStartTime === 0) + dataStartTime = Date.now(); + bytesThisChunk += chunk.length; + totalBytesReceived += chunk.length; + if (!stream.write(chunk)) { + isBackpressured = true; + responseStream.pause(); + } + }; + const onEnd = () => { + responseStream.removeListener('data', onData); + responseStream.removeListener('error', onError); + activeResponseStream = null; + resolve(); + }; + const onError = (err) => { + responseStream.removeListener('data', onData); + responseStream.removeListener('end', onEnd); + activeResponseStream = null; + if (isDestroyed || cancelSignal.aborted) + resolve(); + else + reject(err); + }; + responseStream.once('end', onEnd); + responseStream.once('error', onError); + responseStream.on('data', onData); + }); + if (!responseStream.destroyed) { + responseStream.destroy(); + } + const transferDuration = dataStartTime + ? Date.now() - dataStartTime + : Date.now() - fetchStartTime; + updateBandwidthEstimate(bytesThisChunk, transferDuration); + chunkCount++; + if (chunkCount <= 2) { + targetSeconds = MIN_TARGET_SECONDS; + } + else if (chunkCount <= 5) { + targetSeconds = INITIAL_TARGET_SECONDS; + } + else { + const estimatedSecondsInChunk = bytesThisChunk / trackBytesPerSecond; + if (estimatedSecondsInChunk >= targetSeconds * 0.8) { + targetSeconds = Math.min(targetSeconds + 2, MAX_TARGET_SECONDS); + } + else { + targetSeconds = Math.max(targetSeconds - 2, MIN_TARGET_SECONDS); + } + } + /* + logger( + 'debug', + 'YouTube', + `Chunk #${chunkCount} complete: ${bytesThisChunk} bytes in ${Date.now() - fetchStartTime}ms (${totalBytesReceived}/${contentLength} total, target=${targetSeconds}s)` + ) */ + // i was using this for debugging, so i will keep this commented incase i need it later. + if (totalBytesReceived >= contentLength) { + if (!stream.writableEnded) { + stream.emit('finishBuffering'); + stream.end(); + } + return; + } + consecutiveResets = 0; + isBackpressured = false; + } + catch (err) { + if (isDestroyed || cancelSignal.aborted) + return; + const error = err; + if (error.code === 'ECONNRESET' || + error.code === 'ERR_STREAM_DESTROYED') { + bandwidthEstimate = Math.max(128_000, bandwidthEstimate * 0.7); + if (isBackpressured) { + consecutiveResets = 0; + isBackpressured = false; + logger('debug', 'YouTube', `Buffer-drain recovery at ${totalBytesReceived} bytes (consecutive resets cleared).`); + if (stream.writableLength > 0) { + await waitForDrainOrClose(); + } + continue; + } + logger('warn', 'YouTube', `Connection reset at ${totalBytesReceived} bytes.`); + // Try same URL first (it's probably still valid) since it takes ~6 hours for an URL to expire + const retryDelay = Math.min(250 * 2 ** consecutiveResets, 1000); + consecutiveResets++; + logger('warn', 'YouTube', `Retrying same URL in ${retryDelay}ms (consecutive reset ${consecutiveResets})...`); + await sleep(retryDelay); + if (consecutiveResets >= 3) { + logger('warn', 'YouTube', `Same URL failed ${consecutiveResets} times, refreshing...`); + consecutiveResets = 0; + const refreshed = await refreshUrl('multiple ECONNRESET on same URL'); + if (refreshed) + continue; + cleanup(new Error('ECONNRESET: max URL refresh reached')); + return; + } + else { + continue; + } + } + if (error.message?.includes('403') || + error.message?.includes('404')) { + if (currentItag) + failedItags.add(currentItag); + const refreshed = await refreshUrl('mid-stream 403/404'); + if (refreshed) + continue; + cleanup(new Error('mid-stream 403/404: max URL refresh reached')); + return; + } + const retryDelay = Math.min(RECOVER_BASE_DELAY_MS * 2 ** Math.max(0, refreshAttempts - 1), MAX_RETRY_DELAY_MS); + logger('warn', 'YouTube', `Stream error for "${decodedTrack.title}": ${error.message}. Retrying in ${retryDelay}ms...`); + await sleep(retryDelay); + } + } + }; + startStreaming().catch((err) => { + logger('error', 'YouTube', `Fatal streaming error: ${err.message}`); + cleanup(err); + }); + return { stream }; + } /** * Fetches chapter markers for a track using the Web client. * @param trackInfo - Track metadata containing the video identifier. diff --git a/dist/src/sources/youtube/clients/Android.js b/dist/src/sources/youtube/clients/Android.js index 01f09c05..ae293974 100644 --- a/dist/src/sources/youtube/clients/Android.js +++ b/dist/src/sources/youtube/clients/Android.js @@ -1,5 +1,5 @@ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube Android innertube client implementation. * @@ -138,7 +138,7 @@ export default class Android extends BaseClient { logger('debug', 'YouTube-Android', `No matches found on ${sourceName} for: ${query}`); return { loadType: 'empty', data: {} }; } - const maxResults = this.config.maxSearchResults || 10; + const maxResults = this.config.search.maxResults || 10; let count = 0; const filteredItems = items.filter((item) => { const isValid = item.videoRenderer || @@ -158,7 +158,7 @@ export default class Android extends BaseClient { return false; }); for (const itemData of filteredItems) { - const track = await buildTrack(itemData, sourceName, null, null, this.config.enableHoloTracks); + const track = await buildTrack(itemData, sourceName, null, null, this.config.experimental.enableHoloTracks); if (track) { tracks.push(track); } @@ -243,19 +243,22 @@ export default class Android extends BaseClient { const playlistId = playlistIdMatch[1]; const videoIdMatch = url.match(/[?&]v=([\w-]+)/); const currentVideoId = videoIdMatch?.[1] ?? null; + const isRadio = playlistId.startsWith('RD'); logger('debug', 'YouTube-Android', `User-Agent for playlist request: ${this.getClient(context).client.userAgent}`); - const requestBody = { - context: this.getClient(context), - playlistId, - contentCheckOk: true, - racyCheckOk: true - }; - if (playlistId.startsWith('RD') && currentVideoId) { + const requestBody = isRadio + ? { + context: this.getClient(context), + playlistId, + contentCheckOk: true, + racyCheckOk: true + } + : { context: this.getClient(context), browseId: `VL${playlistId}` }; + if (isRadio && currentVideoId) { requestBody.videoId = currentVideoId; } const playlistProxy = this.getProxy(); const playlistStart = Date.now(); - const { body: playlistResponseRaw, statusCode } = await makeRequest(`${apiEndpoint}/youtubei/v1/next`, { + const { body: playlistResponseRaw, statusCode } = await makeRequest(`${apiEndpoint}/youtubei/v1/${isRadio ? 'next' : 'browse'}`, { headers: { 'User-Agent': this.getClient(context).client.userAgent, ...(context.client.visitorData @@ -283,6 +286,9 @@ export default class Android extends BaseClient { }; } const playlistResponse = playlistResponseRaw; + if (!isRadio) { + return await this._handleBrowsePlaylistResponse(playlistId, playlistResponse, sourceName, context); + } return await this._handlePlaylistResponse(playlistId, currentVideoId, playlistResponse, sourceName); } default: diff --git a/dist/src/sources/youtube/clients/AndroidVR.js b/dist/src/sources/youtube/clients/AndroidVR.js index c986b440..6125ee9d 100644 --- a/dist/src/sources/youtube/clients/AndroidVR.js +++ b/dist/src/sources/youtube/clients/AndroidVR.js @@ -8,8 +8,8 @@ * @packageDocumentation * @module YouTubeAndroidVRClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube ANDROID_VR innertube client. * @@ -39,11 +39,11 @@ export default class AndroidVR extends BaseClient { client: { clientName: 'ANDROID_VR', clientVersion: '1.65.10', - userAgent: 'Mozilla/5.0 (X11; Linux x86_64; Quest 3) AppleWebKit/537.36 (KHTML, like Gecko) OculusBrowser/39.3.0.11.46.766180192 Chrome/136.0.7103.177 VR Safari/537.36,gzip(gfe);GoogleHypersonic', - deviceMake: 'Google', + userAgent: 'com.google.android.apps.youtube.vr.oculus/1.65.10 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip', + deviceMake: 'Meta', osName: 'Android', - osVersion: '15', - androidSdkVersion: '35', + osVersion: '12L', + androidSdkVersion: '32', hl: context.client.hl, gl: context.client.gl, visitorData: context.client.visitorData @@ -119,7 +119,7 @@ export default class AndroidVR extends BaseClient { logger('debug', 'YouTube-AndroidVR', `No matches found on ${sourceName} for: ${query}`); return { loadType: 'empty', data: {} }; } - const maxResults = this.config.maxSearchResults || 10; + const maxResults = this.config.search.maxResults || 10; if (videos.length > maxResults) { let count = 0; videos = videos.filter((video) => { @@ -132,7 +132,7 @@ export default class AndroidVR extends BaseClient { }); } for (const videoData of videos) { - const track = await buildTrack(videoData, sourceName, null, null, this.config.enableHoloTracks); + const track = await buildTrack(videoData, sourceName, null, null, this.config.experimental.enableHoloTracks); if (track) { tracks.push(track); } diff --git a/dist/src/sources/youtube/clients/IOS.js b/dist/src/sources/youtube/clients/IOS.js index 40b1649c..8ef843cc 100644 --- a/dist/src/sources/youtube/clients/IOS.js +++ b/dist/src/sources/youtube/clients/IOS.js @@ -8,8 +8,8 @@ * @packageDocumentation * @module YouTubeIOSClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube IOS innertube client. * diff --git a/dist/src/sources/youtube/clients/Music.js b/dist/src/sources/youtube/clients/Music.js index 35d7aa29..c94316aa 100644 --- a/dist/src/sources/youtube/clients/Music.js +++ b/dist/src/sources/youtube/clients/Music.js @@ -8,8 +8,8 @@ * @packageDocumentation * @module YouTubeMusicClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube ANDROID_MUSIC innertube client. * diff --git a/dist/src/sources/youtube/clients/TV.js b/dist/src/sources/youtube/clients/TV.js index 57012bd5..d17f1cd0 100644 --- a/dist/src/sources/youtube/clients/TV.js +++ b/dist/src/sources/youtube/clients/TV.js @@ -8,8 +8,8 @@ * @packageDocumentation * @module YouTubeTVClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube TVHTML5 innertube client. * @@ -38,8 +38,10 @@ export default class TV extends BaseClient { return { client: { clientName: 'TVHTML5', - clientVersion: '7.20260113.16.00', - userAgent: 'Mozilla/5.0 (Fuchsia) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 CrKey/1.56.500000', + clientVersion: '7.20260708.13.02', + browserVersion: '25.lts.40.1035033-gold', + browserName: 'Cobalt', + userAgent: 'Mozilla/5.0 (SMART-TV; Linux; Tizen 8.0) Cobalt/Version (unlike Gecko) v8/11.4.233.17-gold Starboard/16, Tizen;Samsung;KantM_2024;8.0/2300.0 (Samsung, QN90D_98, Wired', hl: context.client.hl, gl: context.client.gl }, @@ -47,6 +49,16 @@ export default class TV extends BaseClient { request: { useSsl: true } }; } + /** + * Returns player parameters for TV playback. + * + * @returns Base64-encoded player parameters string + */ + getPlayerParams() { + // around D8 03 01 w field 59? or 27? makes me confused. + // will appear betwenn 0AMB ... xxxxxxMIw (-5/6 letters that always updates) + return '2AMB'; + } /** * TV client requires a player script for signature deciphering. * diff --git a/dist/src/sources/youtube/clients/TVCast.js b/dist/src/sources/youtube/clients/TVCast.js index 69878fe0..1b64994c 100644 --- a/dist/src/sources/youtube/clients/TVCast.js +++ b/dist/src/sources/youtube/clients/TVCast.js @@ -8,8 +8,8 @@ * @packageDocumentation * @module YouTubeTVCastClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube TVHTML5_CAST innertube client. * diff --git a/dist/src/sources/youtube/clients/TVEmbedded.js b/dist/src/sources/youtube/clients/TVEmbedded.js index d1a44ce1..a46d23cc 100644 --- a/dist/src/sources/youtube/clients/TVEmbedded.js +++ b/dist/src/sources/youtube/clients/TVEmbedded.js @@ -8,8 +8,8 @@ * @packageDocumentation * @module YouTubeTVEmbeddedClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube TVHTML5_SIMPLY_EMBEDDED_PLAYER innertube client. * diff --git a/dist/src/sources/youtube/clients/TV_downgraded.js b/dist/src/sources/youtube/clients/TV_downgraded.js new file mode 100644 index 00000000..fbcc31b2 --- /dev/null +++ b/dist/src/sources/youtube/clients/TV_downgraded.js @@ -0,0 +1,207 @@ +/** + * YouTube TV Client + * + * Implements the YouTube TVHTML5 innertube client for smart TV and + * Chromecast emulation. Supports video/playlist resolution with + * OAuth-based authentication for TV devices. + * TV DOWNGRADED does not require POT to work (theorically no SABR too) + * + * + * @packageDocumentation + * @module YouTubeTVClient + */ +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; +/** + * YouTube TVHTML5 innertube client. + * + * Emulates a smart TV device for YouTube API requests. + * Requires a player script for signature deciphering. + * + * @public + */ +export default class TV_DOWN extends BaseClient { + /** + * Creates a new TV client instance. + * + * @param nodelink - NodeLink worker instance providing options and source access + * @param oauth - OAuth manager for authenticated requests, or null if unauthenticated + */ + constructor(nodelink, oauth) { + super(nodelink, 'TVHTML5', oauth); + } + /** + * Builds the YouTube client context for TVHTML5 innertube requests. + * + * @param context - General YouTube context with language, region, and visitor data + * @returns Client context object describing this TVHTML5 client configuration + */ + getClient(context) { + return { + client: { + clientName: 'TVHTML5', + clientVersion: '5.20260713', + browserVersion: '5.150.00-qa', + browserName: 'Cobalt', + userAgent: 'Mozilla/5.0 (Unknown) Cobalt/5.150.00-qa (unlike Gecko) Starboard/3, Unknown;Unknown;Unknown;0/Unknown (Chromium, Starboard, Wired)', + hl: context.client.hl, + gl: context.client.gl + }, + user: { lockedSafetyMode: false }, + request: { useSsl: true } + }; + } + /** + * Returns player parameters for TV playback. + * + * @returns Base64-encoded player parameters string + */ + getPlayerParams() { + // around D8 03 01 w field 59? or 27? makes me confused. + // will appear betwenn 0AMB ... xxxxxxMIw (-5/6 letters that always updates) + return '2AMB'; + } + /** + * TV client requires a player script for signature deciphering. + * + * @returns Always true for the TV client + */ + requirePlayerScript() { + return true; + } + /** + * Retrieves OAuth authorization headers for TV device authentication. + * + * @returns Promise resolving to authorization headers, or empty object if no OAuth + */ + async getAuthHeaders() { + if (this.oauth) { + const accessToken = await this.oauth.getAccessToken(); + if (accessToken) { + logger('debug', 'YouTube-TV_DOWN', 'Successfully acquired access token for authentication.'); + return { + Authorization: `Bearer ${accessToken}` + }; + } + } + logger('debug', 'YouTube-TV_DOWN', 'No access token available. Proceeding without authentication.'); + return {}; + } + /** + * Resolves a YouTube URL to track or playlist data. + * + * @param url - YouTube URL to resolve + * @param _type - URL type hint (unused) + * @param context - YouTube context with language and region settings + * @param cipherManager - Cipher manager for signature deciphering + * @returns Resolved track/playlist data or an exception + */ + async resolve(url, _type, context, cipherManager) { + const sourceName = 'youtube'; + const urlType = checkURLType(url, 'youtube'); + const apiEndpoint = this.getApiEndpoint(); + switch (urlType) { + case YOUTUBE_CONSTANTS.VIDEO: + case YOUTUBE_CONSTANTS.SHORTS: { + const idPattern = /(?:v=|\/shorts\/|youtu\.be\/)([^&?]+)/; + const videoIdMatch = url.match(idPattern); + if (!videoIdMatch?.[1]) { + logger('error', 'YouTube-TV_DOWN', `Could not parse video ID from URL: ${url}`); + return { + loadType: 'error', + exception: { + message: 'Invalid video URL.', + severity: 'common', + cause: 'Input' + } + }; + } + const videoId = videoIdMatch[1]; + const headers = await this.getAuthHeaders(); + const { body: playerResponse, statusCode } = await this._makePlayerRequest(videoId, context, headers, cipherManager); + if (statusCode !== 200) { + const message = `Failed to load video/short player data. Status: ${statusCode}`; + logger('error', 'YouTube-TV_DOWN_DOWN', message); + return { + loadType: 'error', + exception: { message, severity: 'common', cause: 'Upstream' } + }; + } + return await this._handlePlayerResponse(playerResponse, sourceName, videoId); + } + case YOUTUBE_CONSTANTS.PLAYLIST: { + const playlistIdMatch = url.match(/[?&]list=([\w-]+)/); + if (!playlistIdMatch?.[1]) { + logger('error', 'YouTube-TV_DOWN', `Could not parse playlist ID from URL: ${url}`); + return { + loadType: 'error', + exception: { + message: 'Invalid playlist URL.', + severity: 'common', + cause: 'Input' + } + }; + } + const playlistId = playlistIdMatch[1]; + const videoIdMatch = url.match(/[?&]v=([\w-]+)/); + const currentVideoId = videoIdMatch?.[1] ?? null; + const requestBody = { + context: this.getClient(context), + playlistId, + contentCheckOk: true, + racyCheckOk: true + }; + if (playlistId.startsWith('RD') && currentVideoId) { + requestBody.videoId = currentVideoId; + } + const { body: playlistResponse, statusCode } = await makeRequest(`${apiEndpoint}/youtubei/v1/next`, { + headers: { 'User-Agent': this.getClient(context).client.userAgent }, + body: requestBody, + method: 'POST', + disableBodyCompression: true, + proxy: this.getProxy() + }); + if (statusCode !== 200) { + const errMsg = `Failed to fetch playlist. Status: ${statusCode}`; + logger('error', 'YouTube-TV_DOWN', `Error loading playlist ${playlistId}: ${errMsg}`); + return { + loadType: 'error', + exception: { + message: errMsg, + severity: 'common', + cause: 'Upstream' + } + }; + } + return await this._handlePlaylistResponse(playlistId, currentVideoId, playlistResponse, sourceName, context); + } + default: + return { loadType: 'empty', data: {} }; + } + } + /** + * Retrieves a playable stream URL for a track. + * + * @param decodedTrack - Decoded track information with identifier + * @param context - YouTube context with language and region settings + * @param cipherManager - Cipher manager for signature deciphering + * @param itag - Optional specific format itag to request + * @param proxy - Optional proxy override for this request + * @returns Track URL data with protocol info, or an exception + */ + async getTrackUrl(decodedTrack, context, cipherManager, itag, proxy) { + const sourceName = decodedTrack.sourceName || 'youtube'; + logger('debug', 'YouTube-TV_DOWN', `Getting stream URL for: ${decodedTrack.title} (ID: ${decodedTrack.identifier}) on ${sourceName}`); + const headers = await this.getAuthHeaders(); + const { body: playerResponse, statusCode } = await this._makePlayerRequest(decodedTrack.identifier, context, headers, cipherManager, proxy); + if (statusCode !== 200) { + const message = `Failed to get player data for stream. Status: ${statusCode}`; + logger('error', 'YouTube-TV_DOWN_DOWN', message); + return { + loadType: 'error', + exception: { message, severity: 'common', cause: 'Upstream' } + }; + } + return await this._extractStreamData(playerResponse, decodedTrack, context, cipherManager, itag); + } +} diff --git a/dist/src/sources/youtube/clients/Web.js b/dist/src/sources/youtube/clients/Web.js index 92080284..1b831f7a 100644 --- a/dist/src/sources/youtube/clients/Web.js +++ b/dist/src/sources/youtube/clients/Web.js @@ -11,9 +11,9 @@ * @packageDocumentation * @module YouTubeWebClient */ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; -import { poTokenManager } from "../sabr/potoken.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; +import { poTokenManager } from '../sabr/potoken.js'; /** * YouTube WEB innertube client. * @@ -45,9 +45,9 @@ export default class Web extends BaseClient { return { client: { clientName: 'WEB', - clientVersion: '2.20260114.01.00', + clientVersion: '2.20260706.00.00', platform: 'DESKTOP', - userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36', + userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', hl: context.client.hl, gl: context.client.gl }, @@ -117,7 +117,7 @@ export default class Web extends BaseClient { logger('debug', 'YouTube-Web', `No matches found on ${sourceName} for: ${query}`); return { loadType: 'empty', data: {} }; } - const maxResults = this.config.maxSearchResults || 10; + const maxResults = this.config.search.maxResults || 10; if (videos.length > maxResults) { let count = 0; videos = videos.filter((video) => { @@ -130,7 +130,7 @@ export default class Web extends BaseClient { }); } for (const videoData of videos) { - const track = await buildTrack(videoData, sourceName, null, null, this.config.enableHoloTracks); + const track = await buildTrack(videoData, sourceName, null, null, this.config.experimental.enableHoloTracks); if (track) { tracks.push(track); } diff --git a/dist/src/sources/youtube/clients/WebEmbedded.js b/dist/src/sources/youtube/clients/WebEmbedded.js index 0453a3ee..0302fb54 100644 --- a/dist/src/sources/youtube/clients/WebEmbedded.js +++ b/dist/src/sources/youtube/clients/WebEmbedded.js @@ -1,5 +1,5 @@ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; export default class WebEmbedded extends BaseClient { /** * Creates a new WebEmbedded client instance. @@ -20,16 +20,21 @@ export default class WebEmbedded extends BaseClient { return { client: { clientName: 'WEB_EMBEDDED_PLAYER', - clientVersion: '1.20260128.01.00', + clientVersion: '2.20260630.09.00', platform: 'DESKTOP', - userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36,gzip(gfe)', + userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36,gzip(gfe)', hl: context.client.hl, gl: context.client.gl, visitorData: context.client.visitorData }, user: { lockedSafetyMode: false }, request: { useSsl: true }, - thirdParty: { embedUrl: 'https://www.google.com/' } + thirdParty: { + embedUrl: 'https://www.google.com/search?q=youtube', + embeddedPlayerContext: { + ancestorOrigins: ['https://www.google.com'] + } + } }; } /** @@ -102,7 +107,7 @@ export default class WebEmbedded extends BaseClient { logger('debug', 'YouTube-WebEmbedded', `No matches found on ${sourceName} for: ${query}`); return { loadType: 'empty', data: {} }; } - const maxResults = this.config.maxSearchResults || 10; + const maxResults = this.config.search.maxResults || 10; if (videos.length > maxResults) { let count = 0; videos = videos.filter((video) => { @@ -115,7 +120,7 @@ export default class WebEmbedded extends BaseClient { }); } for (const videoData of videos) { - const track = await buildTrack(videoData, sourceName, null, null, this.config.enableHoloTracks); + const track = await buildTrack(videoData, sourceName, null, null, this.config.experimental.enableHoloTracks); if (track) { tracks.push(track); } diff --git a/dist/src/sources/youtube/clients/WebParentTools.js b/dist/src/sources/youtube/clients/WebParentTools.js index 15fb2f42..c913974b 100644 --- a/dist/src/sources/youtube/clients/WebParentTools.js +++ b/dist/src/sources/youtube/clients/WebParentTools.js @@ -1,5 +1,5 @@ -import { makeRequest } from "../../../utils.js"; -import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { makeRequest } from '../../../utils.js'; +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; export default class WebParentTools extends BaseClient { /** * Creates a new WebParentTools client instance. diff --git a/dist/src/sources/youtube/clients/Web_Remix.js b/dist/src/sources/youtube/clients/Web_Remix.js index 268e12f3..09ad9b4f 100644 --- a/dist/src/sources/youtube/clients/Web_Remix.js +++ b/dist/src/sources/youtube/clients/Web_Remix.js @@ -1,5 +1,5 @@ -import { logger, makeRequest } from "../../../utils.js"; -import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from "../common.js"; +import { logger, makeRequest } from '../../../utils.js'; +import { BaseClient, buildTrack, checkURLType, YOUTUBE_CONSTANTS } from '../common.js'; /** * YouTube Music (WEB_REMIX) client implementation. * @@ -19,6 +19,8 @@ export default class WebRemix extends BaseClient { } /** * Returns the YouTube Music client context for innertube requests. + * + * This is only used for getting the videoDetails, no playback. * @param context - General YouTube context with language, region, and visitor data * @returns Client context configured for WEB_REMIX */ @@ -26,11 +28,11 @@ export default class WebRemix extends BaseClient { return { client: { clientName: 'WEB_REMIX', - clientVersion: '1.20260302.03.01', - userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36', + clientVersion: '1.20260721.00.00', + userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) YouTubeMusic/3.12.0 Chrome/148.0.7778.271 Electron/42.5.0 Safari/537.36', hl: context.client.hl, gl: context.client.gl, - visitorData: context.client.visitorData + applicationState: 'ACTIVE' }, user: { lockedSafetyMode: false }, request: { useSsl: true } @@ -52,13 +54,13 @@ export default class WebRemix extends BaseClient { */ async search(query, type, context) { const sourceName = 'ytmusic'; - let params = 'EgWKAQIIAWoSEAMQBRAEEAkQChAVEBAQDhAR'; // Default (Tracks) + let params = 'EgWKAQIIAWoQEAQQAxAJEAUQChAQEBUQEQ%3D%3D'; // Default (Tracks) if (type === 'playlist') - params = 'EgeKAQQoAEABahIQAxAFEAQQCRAKEBUQEBAOEBE%3D'; + params = 'EgeKAQQoAEABahAQBBADEAkQBRAKEBAQFRAR'; if (type === 'album') - params = 'EgWKAQIYAWoSEAMQBRAEEAkQChAVEBAQDhAR'; + params = 'EgWKAQIYAWoQEAQQAxAJEAUQChAQEBUQEQ%3D%3D'; if (type === 'artist') - params = 'EgWKAQIgAWoSEAMQBRAEEAkQChAVEBAQDhAR'; + params = 'EgWKAQIgAWoQEAQQAxAJEAUQChAQEBUQEQ%3D%3D'; const requestBody = { context: this.getClient(context), query: query, diff --git a/dist/src/sources/youtube/common.js b/dist/src/sources/youtube/common.js index f9a00504..9e8c2800 100644 --- a/dist/src/sources/youtube/common.js +++ b/dist/src/sources/youtube/common.js @@ -1,5 +1,5 @@ -import { YOUTUBE_CONSTANTS } from "../../typings/sources/youtube.types.js"; -import { encodeTrack, logger, makeRequest } from "../../utils.js"; +import { YOUTUBE_CONSTANTS } from '../../typings/sources/youtube.types.js'; +import { encodeTrack, logger, makeRequest } from '../../utils.js'; export { YOUTUBE_CONSTANTS }; /** * Fallback strings used when metadata cannot be retrieved from YouTube. @@ -905,6 +905,7 @@ function getRendererFromItemData(itemData, itemType) { { key: 'compactPlaylistRenderer', type: 'playlist' }, { key: 'channelRenderer', type: 'channel' }, { key: 'playlistPanelVideoRenderer', type: 'track' }, + { key: 'playlistVideoRenderer', type: 'track' }, { key: 'gridVideoRenderer', type: 'track' } ]; for (const r of rendererTypes) { @@ -940,7 +941,7 @@ function getRendererFromItemData(itemData, itemType) { * @returns Built track data or null * @public */ -export async function buildTrack(itemData, itemType, sourceNameOverride = null, fullApiResponse = null, enableHolo = false, config = {}, makeRequestFn = null) { +export async function buildTrack(itemData, itemType, sourceNameOverride = null, fullApiResponse = null, enableHolo = false, config = { search: {} }, makeRequestFn = null) { if (!itemData) { logger('warn', 'buildTrack', 'itemData is null or undefined'); return null; @@ -1202,7 +1203,7 @@ export async function buildTrack(itemData, itemType, sourceNameOverride = null, * @returns Built holo track data * @public */ -export async function buildHoloTrack(trackInfo, itemData, itemType, fullApiResponse = null, config = {}, makeRequestFn = null) { +export async function buildHoloTrack(trackInfo, itemData, itemType, fullApiResponse = null, config = { search: {} }, makeRequestFn = null) { const duration = formatDuration(trackInfo.length); const sourceName = trackInfo.sourceName; const sourceUrl = sourceName === 'ytmusic' @@ -1345,7 +1346,7 @@ export async function buildHoloTrack(trackInfo, itemData, itemType, fullApiRespo accessibilityLabel = accessibilityLabel || `${trackInfo.title} by ${channelData.name || trackInfo.author}`; - if (config.fetchChannelInfo && channelData.id && makeRequestFn) { + if (config.search.fetchChannelInfo && channelData.id && makeRequestFn) { try { const channelInfo = await fetchChannelInfo(channelData.id, makeRequestFn, fullApiResponse?.responseContext); if (channelInfo) { @@ -1369,7 +1370,7 @@ export async function buildHoloTrack(trackInfo, itemData, itemType, fullApiRespo thumbnails.medium = thumbnails.medium || trackInfo.artworkUrl || null; thumbnails.high = thumbnails.high || trackInfo.artworkUrl || null; let externalLinks = extractExternalLinks(description); - if (config.resolveExternalLinks && externalLinks && makeRequestFn) { + if (config.search.resolveExternalLinks && externalLinks && makeRequestFn) { try { externalLinks = await resolveExternalLinks(externalLinks, makeRequestFn); } @@ -1564,6 +1565,7 @@ export class BaseClient { context: this.getClient(context), videoId: videoId, contentCheckOk: true, + attestationRequest: { omitBotguardData: true }, racyCheckOk: true }; const playerParams = this.getPlayerParams(); @@ -1677,6 +1679,22 @@ export class BaseClient { }; } const videoDetails = playerResponse.videoDetails; + const playabilityStatus = playerResponse.playabilityStatus?.status; + if (playabilityStatus && + playabilityStatus !== 'OK' && + playerResponse.microformat?.microformatDataRenderer.appName !== + 'YouTube Music') { + const message = playerResponse.playabilityStatus?.reason || 'Video not playable.'; + logger('warn', `youtube-${this.name}`, `Video/short ${videoId} not playable: ${message}`); + return { + loadType: 'error', + exception: { + message, + severity: 'common', + cause: 'UpstreamPlayability' + } + }; + } if (!videoDetails?.videoId) { logger('error', `youtube-${this.name}`, `Missing videoDetails for ${videoId}`); return { @@ -1688,15 +1706,10 @@ export class BaseClient { } }; } - if (playerResponse.playabilityStatus?.status !== 'OK') { - const message = playerResponse.playabilityStatus?.reason || 'Video not playable.'; - if (this.name !== 'WEB_REMIX') { - logger('warn', `youtube-${this.name}`, `Video/short ${videoId} not playable: ${message}. Still returning metadata.`); - } - } - const track = await buildTrack(videoDetails, sourceName, null, playerResponse, !!this.config.enableHoloTracks, { - resolveExternalLinks: !!this.config.resolveExternalLinks, - fetchChannelInfo: !!this.config.fetchChannelInfo + const track = await buildTrack(videoDetails, sourceName, null, playerResponse, !!this.config.experimental.enableHoloTracks, { + resolveExternalLinks: !!this.config.search.resolveExternalLinks, + fetchChannelInfo: !!this.config.search.fetchChannelInfo, + search: {} }); if (!track) { logger('error', `youtube-${this.name}`, `Failed to build track for ${videoId}`); @@ -1761,13 +1774,51 @@ export class BaseClient { } const tracks = []; let selectedTrack = 0; - const maxLength = this.config.maxAlbumPlaylistLength || 100; + const maxLength = this.config.playback?.maxPlaylistLength || 100; + if (sourceName === 'ytmusic') { + playlistContent = playlistContent.filter((item) => getItemValue(item, ['playlistPanelVideoRenderer.videoId'])); + } + let continuation = getItemValue(playlistResponse, [ + 'contents.singleColumnMusicWatchNextResultsRenderer.tabbedRenderer.watchNextTabbedResultsRenderer.tabs.0.tabRenderer.content.musicQueueRenderer.content.playlistPanelRenderer.continuations.0.nextContinuationData.continuation' + ]); + const seenContinuations = new Set(); + while (sourceName === 'ytmusic' && + _context && + continuation && + !seenContinuations.has(continuation) && + playlistContent.length < maxLength) { + seenContinuations.add(continuation); + const client = this.getClient(_context); + const { body, statusCode } = await makeRequest('https://music.youtube.com/youtubei/v1/next', { + method: 'POST', + headers: { + 'User-Agent': client.client.userAgent, + 'X-Goog-Api-Format-Version': '2' + }, + body: { context: client, continuation }, + disableBodyCompression: true, + proxy: this.getProxy() + }); + if (statusCode !== 200 || !body) + break; + const page = getItemValue(body, [ + 'continuationContents.playlistPanelContinuation' + ]); + const items = page?.contents?.filter((item) => getItemValue(item, ['playlistPanelVideoRenderer.videoId'])); + if (!items?.length) + break; + playlistContent.push(...items.slice(0, maxLength - playlistContent.length)); + continuation = getItemValue(page, [ + 'continuations.0.nextContinuationData.continuation' + ]); + } for (let i = 0; i < Math.min(playlistContent.length, maxLength); i++) { const item = playlistContent[i]; try { - const track = await buildTrack(item, sourceName || 'youtube', null, null, !!this.config.enableHoloTracks, { + const track = await buildTrack(item, sourceName || 'youtube', null, null, !!this.config.experimental.enableHoloTracks, { fetchChannelInfo: false, - resolveExternalLinks: false + resolveExternalLinks: false, + search: {} }); if (track) { tracks.push(track); @@ -1836,21 +1887,59 @@ export class BaseClient { const tabContent = tabRenderer?.content; const sectionList = tabContent?.sectionListRenderer; const sectionContents = sectionList?.contents; - const shelf = sectionContents?.[0]?.musicPlaylistShelfRenderer; + const section = sectionContents?.[0]; + const shelf = section?.musicPlaylistShelfRenderer || + section?.playlistVideoListRenderer; const shelfContentsCheck = shelf?.contents; if (!shelf || !shelfContentsCheck || shelfContentsCheck.length === 0) { logger('info', `youtube-${this.name}`, `Browse playlist ${playlistId} is empty or inaccessible.`); return { loadType: 'empty', data: {} }; } + const maxLength = this.config.playback?.maxPlaylistLength || 100; + const shelfContents = shelfContentsCheck.filter((item) => !getItemValue(item, ['messageRenderer'])); + let continuation = getItemValue(shelf, [ + 'continuations.0.nextContinuationData.continuation' + ]); + const seenContinuations = new Set(); + while (this.name === 'ANDROID' && + _context && + continuation && + !seenContinuations.has(continuation) && + shelfContents.length < maxLength) { + seenContinuations.add(continuation); + const client = this.getClient(_context); + const { body, statusCode } = await makeRequest(`${this.getApiEndpoint()}/youtubei/v1/browse`, { + method: 'POST', + headers: { + 'User-Agent': client.client.userAgent, + 'X-YouTube-Client-Name': '3', + 'X-YouTube-Client-Version': client.client.clientVersion ?? '' + }, + body: { context: client, continuation }, + disableBodyCompression: true, + proxy: this.getProxy() + }); + if (statusCode !== 200 || !body) + break; + const page = getItemValue(body, [ + 'continuationContents.playlistVideoListContinuation' + ]); + const items = page?.contents; + if (!items?.length) + break; + shelfContents.push(...items.slice(0, maxLength - shelfContents.length)); + continuation = getItemValue(page, [ + 'continuations.0.nextContinuationData.continuation' + ]); + } const tracks = []; - const maxLength = this.config.maxAlbumPlaylistLength || 100; - const shelfContents = shelf.contents; for (let i = 0; i < Math.min(shelfContents.length, maxLength); i++) { const item = shelfContents[i]; try { - const track = await buildTrack(item, sourceName || 'ytmusic', sourceName, browseResponse, !!this.config.enableHoloTracks, { + const track = await buildTrack(item, sourceName || 'ytmusic', sourceName, browseResponse, !!this.config.experimental.enableHoloTracks, { fetchChannelInfo: false, - resolveExternalLinks: false + resolveExternalLinks: false, + search: {} }); if (track) { tracks.push(track); @@ -1866,9 +1955,13 @@ export class BaseClient { } let playlistTitle = 'Unknown Playlist'; const headerRoot = browseResponse.header; + const pageHeader = headerRoot?.pageHeaderRenderer; const musicDetail = headerRoot?.musicDetailHeaderRenderer; const musicTitle = musicDetail?.title; - if (musicTitle?.runs?.[0]?.text) { + if (typeof pageHeader?.pageTitle === 'string') { + playlistTitle = pageHeader.pageTitle; + } + else if (musicTitle?.runs?.[0]?.text) { playlistTitle = musicTitle.runs[0].text; } else { @@ -1919,7 +2012,7 @@ export class BaseClient { } else { const qualityPriority = this._getQualityPriority(); - const audioConfig = this.config.audio; + const audioConfig = this.config.playback?.audio; const audioQuality = audioConfig?.quality || 'high'; targetItags = qualityPriority[audioQuality] || []; @@ -2111,6 +2204,7 @@ export class BaseClient { url: directUrl, protocol: directUrl ? 'http' : null, format: resolveFormatStr(resolvedFormat?.mimeType), + itag: resolvedFormat?.itag, hlsUrl: streamingData.hlsManifestUrl || null, formats }; @@ -2245,4 +2339,43 @@ export class BaseClient { } return await this._extractStreamData(playerResult.body, decodedTrack, context, cipherManager, itag); } + /** + * Fetches the initial visitor data by making a GET request to YouTube. + * This is used to initialize the session context. + * + * @returns The extracted visitor data string, or null if it could not be found. + */ + async getVisitorData() { + try { + const response = await makeRequest('https://www.youtube.com', { + method: 'GET', + headers: { + 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' + }, + proxy: this.getProxy() + }); + if (response.statusCode !== 200 || !response.body) { + return null; + } + const body = response.body; + const match = body.match(/ytcfg\.set\((\{.*?\})\);/); + if (match?.[1]) { + try { + const ytcfg = JSON.parse(match[1]); + if (ytcfg.VISITOR_DATA) { + return ytcfg.VISITOR_DATA; + } + } + catch { + // Fallback to regex if JSON parse fails + } + } + const visitorDataMatch = body.match(/"visitorData":"([^"]+)"/); + return visitorDataMatch?.[1] || null; + } + catch (err) { + logger('debug', `youtube-${this.name}`, `Failed to fetch visitor data: ${err instanceof Error ? err.message : String(err)}`); + return null; + } + } } diff --git a/dist/src/sources/youtube/sabr/nativeDOM.js b/dist/src/sources/youtube/sabr/nativeDOM.js new file mode 100644 index 00000000..feebb2b2 --- /dev/null +++ b/dist/src/sources/youtube/sabr/nativeDOM.js @@ -0,0 +1,1164 @@ +import { Buffer } from 'node:buffer'; +let _ready = false; +// These are populated by _init() and referenced by NativeDOM constructor. +let EMPTY_ARRAY; +// biome-ignore lint/suspicious/noExplicitAny: constructor cache holds arbitrary constructor functions +let dynamicClassCache; +// biome-ignore lint/suspicious/noExplicitAny: event ctor protos hold arbitrary prototype shapes +let EVENT_CTOR_PROTOS; +let EVENT_TYPE_MAP; +let EVENT_TYPE_KEYS; +let ELEMENT_STRING_PROPS; +let ELEMENT_BOOL_PROPS; +let ELEMENT_ZERO_PROPS; +let SHADOW_ROOT_PROTO; +let ANIMATION_OBJ; +let CANVAS_2D_CTX; +let DEFERRED_REQUEST_OBJ; +// Class references — set by _init() +// biome-ignore lint/suspicious/noExplicitAny: DOM class stubs are untyped by design +let _classes = {}; +function _init() { + if (_ready) + return; + _ready = true; + EMPTY_ARRAY = Object.freeze([]); + dynamicClassCache = new Map(); + function getDummyConstructor(name) { + const cached = dynamicClassCache.get(name); + if (cached !== undefined) + return cached; + const dummy = () => { }; + Object.defineProperty(dummy, 'name', { value: name }); + Object.defineProperty(dummy, 'toString', { + value: () => `function ${name}() { [native code] }` + }); + const proto = Object.create(null); + Object.defineProperty(proto, 'constructor', { + value: dummy, + writable: true, + configurable: true + }); + Object.defineProperty(proto, Symbol.toStringTag, { + value: name, + configurable: true + }); + Object.defineProperty(dummy, 'prototype', { + value: proto, + writable: true, + configurable: true + }); + dynamicClassCache.set(name, dummy); + return dummy; + } + class EventTarget { + } + Object.assign(EventTarget.prototype, { + addEventListener() { }, + removeEventListener() { }, + dispatchEvent() { + return true; + } + }); + const NODE_CONSTANTS = Object.freeze({ + ELEMENT_NODE: 1, + ATTRIBUTE_NODE: 2, + TEXT_NODE: 3, + CDATA_SECTION_NODE: 4, + ENTITY_REFERENCE_NODE: 5, + ENTITY_NODE: 6, + PROCESSING_INSTRUCTION_NODE: 7, + COMMENT_NODE: 8, + DOCUMENT_NODE: 9, + DOCUMENT_TYPE_NODE: 10, + DOCUMENT_FRAGMENT_NODE: 11, + NOTATION_NODE: 12, + DOCUMENT_POSITION_DISCONNECTED: 1, + DOCUMENT_POSITION_PRECEDING: 2, + DOCUMENT_POSITION_FOLLOWING: 4, + DOCUMENT_POSITION_CONTAINS: 8, + DOCUMENT_POSITION_CONTAINED_BY: 16, + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32 + }); + class Node extends EventTarget { + } + Object.assign(Node, NODE_CONSTANTS); + Object.assign(Node.prototype, NODE_CONSTANTS); + class Element extends Node { + } + class HTMLElement extends Element { + get [Symbol.toStringTag]() { + return 'HTMLElement'; + } + } + class HTMLIFrameElement extends HTMLElement { + get [Symbol.toStringTag]() { + return 'HTMLIFrameElement'; + } + } + class HTMLCanvasElement extends HTMLElement { + get [Symbol.toStringTag]() { + return 'HTMLCanvasElement'; + } + } + class HTMLImageElement extends HTMLElement { + get [Symbol.toStringTag]() { + return 'HTMLImageElement'; + } + } + class HTMLDivElement extends HTMLElement { + get [Symbol.toStringTag]() { + return 'HTMLDivElement'; + } + } + class HTMLBodyElement extends HTMLElement { + get [Symbol.toStringTag]() { + return 'HTMLBodyElement'; + } + } + class HTMLHtmlElement extends HTMLElement { + get [Symbol.toStringTag]() { + return 'HTMLHtmlElement'; + } + } + class Window extends EventTarget { + get [Symbol.toStringTag]() { + return 'Window'; + } + } + class Document extends EventTarget { + get [Symbol.toStringTag]() { + return 'HTMLDocument'; + } + } + class HTMLDocument extends Document { + } + class Navigator { + get [Symbol.toStringTag]() { + return 'Navigator'; + } + } + class Location { + get [Symbol.toStringTag]() { + return 'Location'; + } + } + class Performance { + get [Symbol.toStringTag]() { + return 'Performance'; + } + } + class Screen { + get [Symbol.toStringTag]() { + return 'Screen'; + } + } + class CSSStyleDeclaration { + getPropertyValue() { + return ''; + } + setProperty() { } + removeProperty() { + return ''; + } + item() { + return ''; + } + get [Symbol.toStringTag]() { + return 'CSSStyleDeclaration'; + } + } + class PluginArray { + get length() { + return 0; + } + item() { + return null; + } + namedItem() { + return null; + } + get [Symbol.toStringTag]() { + return 'PluginArray'; + } + } + class MimeTypeArray { + get length() { + return 0; + } + item() { + return null; + } + namedItem() { + return null; + } + get [Symbol.toStringTag]() { + return 'MimeTypeArray'; + } + } + class Scheduler { + postTask( + // biome-ignore lint/suspicious/noExplicitAny: BotGuard passes arbitrary callbacks + callback, + // biome-ignore lint/suspicious/noExplicitAny: BotGuard options are untyped + options) { + const delay = options?.delay || 0; + return new Promise((resolve, reject) => { + const t = setTimeout(async () => { + try { + resolve(await callback()); + } + catch (err) { + reject(err); + } + }, delay); + if (options?.signal) { + options.signal.addEventListener('abort', () => { + clearTimeout(t); + // biome-ignore lint/suspicious/noExplicitAny: globalThis DOM extension + const g = globalThis; + const AbortError = g.DOMException + ? new g.DOMException('The user aborted a request.', 'AbortError') + : new Error('The user aborted a request.'); + reject(AbortError); + }); + } + }); + } + get [Symbol.toStringTag]() { + return 'Scheduler'; + } + } + SHADOW_ROOT_PROTO = (() => { + const ShadowRoot = getDummyConstructor('ShadowRoot'); + const p = Object.create(ShadowRoot.prototype); + Object.assign(p, { + nodeType: 11, + nodeName: '#document-fragment', + innerHTML: '', + querySelector() { + return null; + }, + querySelectorAll() { + return EMPTY_ARRAY; + }, + get childNodes() { + return EMPTY_ARRAY; + }, + hasChildNodes() { + return false; + }, + appendChild(child) { + return child; + }, + removeChild(child) { + return child; + } + }); + return p; + })(); + ANIMATION_OBJ = Object.freeze({ + cancel() { }, + finish() { }, + play() { }, + pause() { } + }); + CANVAS_2D_CTX = Object.freeze({ + fillRect() { }, + clearRect() { }, + getImageData() { + return { data: new Uint8ClampedArray(4) }; + }, + putImageData() { }, + measureText() { + return { width: 0 }; + }, + createLinearGradient() { + return { addColorStop() { } }; + } + }); + const DeferredRequest = getDummyConstructor('DeferredRequest'); + DEFERRED_REQUEST_OBJ = Object.freeze(Object.assign(Object.create(DeferredRequest.prototype), { activated: true })); + ELEMENT_STRING_PROPS = new Set([ + 'name', + 'id', + 'className', + 'title', + 'lang', + 'dir', + 'width', + 'height', + 'autocapitalize', + 'elementTiming', + 'border', + 'align', + 'virtualKeyboardPolicy', + 'longDesc', + 'srcset', + 'enterKeyHint', + 'accessKey', + 'innerHTML' + ]); + ELEMENT_BOOL_PROPS = new Set([ + 'disabled', + 'hidden', + 'checked', + 'isMap', + 'sharedStorageWritable', + 'inert' + ]); + ELEMENT_ZERO_PROPS = new Set([ + 'scrollTop', + 'scrollLeft', + 'scrollHeight', + 'scrollWidth', + 'clientTop', + 'clientLeft', + 'offsetWidth', + 'offsetHeight', + 'clientWidth', + 'clientHeight', + 'offsetTop', + 'offsetLeft', + 'hspace' + ]); + EVENT_CTOR_PROTOS = new Map(); + EVENT_TYPE_MAP = { + Mouse: 'MouseEvent', + Keyboard: 'KeyboardEvent', + Touch: 'TouchEvent', + UI: 'UIEvent', + Custom: 'CustomEvent', + Mutation: 'MutationEvent', + Message: 'MessageEvent' + }; + EVENT_TYPE_KEYS = Object.keys(EVENT_TYPE_MAP); + function getEventCtorProto(constructorName) { + const cached = EVENT_CTOR_PROTOS.get(constructorName); + if (cached !== undefined) + return cached; + const dummyCtor = getDummyConstructor(constructorName); + const proto = Object.create(dummyCtor.prototype); + proto.bubbles = false; + proto.cancelable = false; + proto.eventPhase = 0; + proto.defaultPrevented = false; + proto.composed = false; + proto.isTrusted = true; + proto.target = null; + proto.currentTarget = null; + proto.srcElement = null; + proto.returnValue = true; + proto.cancelBubble = false; + proto.screenX = 0; + proto.screenY = 0; + proto.clientX = 0; + proto.clientY = 0; + proto.ctrlKey = false; + proto.shiftKey = false; + proto.altKey = false; + proto.metaKey = false; + proto.button = 0; + proto.buttons = 0; + proto.which = 0; + proto.pageX = 0; + proto.pageY = 0; + proto.detail = 0; + proto.initEvent = function (type, bubbles, cancelable) { + this.type = type; + this.bubbles = bubbles; + this.cancelable = cancelable; + }; + proto.initMouseEvent = function (type, bubbles, cancelable, _view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, _relatedTarget) { + this.type = type; + this.bubbles = bubbles; + this.cancelable = cancelable; + this.detail = detail; + this.screenX = screenX; + this.screenY = screenY; + this.clientX = clientX; + this.clientY = clientY; + this.ctrlKey = ctrlKey; + this.altKey = altKey; + this.shiftKey = shiftKey; + this.metaKey = metaKey; + this.button = button; + }; + proto.initUIEvent = function (type, bubbles, cancelable, _view, detail) { + this.type = type; + this.bubbles = bubbles; + this.cancelable = cancelable; + this.detail = detail; + }; + proto.stopPropagation = () => { }; + proto.preventDefault = () => { }; + proto.stopImmediatePropagation = () => { }; + EVENT_CTOR_PROTOS.set(constructorName, proto); + return proto; + } + Object.defineProperties(Node.prototype, { + ownerDocument: { + get() { + // biome-ignore lint/suspicious/noExplicitAny: globalThis DOM extension + return globalThis.document; + }, + configurable: true, + enumerable: true + }, + childNodes: { + get() { + return EMPTY_ARRAY; + }, + configurable: true, + enumerable: true + }, + nodeValue: { value: null, writable: true, configurable: true }, + textContent: { value: '', writable: true, configurable: true }, + parentNode: { value: null, writable: true, configurable: true }, + hasChildNodes: { + value() { + return false; + }, + writable: true, + configurable: true + }, + compareDocumentPosition: { + value() { + return 0; + }, + writable: true, + configurable: true + }, + appendChild: { + value(child) { + return child; + }, + writable: true, + configurable: true + }, + removeChild: { + value(child) { + return child; + }, + writable: true, + configurable: true + }, + insertBefore: { + value(newChild) { + return newChild; + }, + writable: true, + configurable: true + }, + replaceChild: { + value(_newChild, oldChild) { + return oldChild; + }, + writable: true, + configurable: true + }, + cloneNode: { + value() { + const tag = (this.tagName || '').toLowerCase() || 'div'; + // biome-ignore lint/suspicious/noExplicitAny: globalThis DOM extension + return globalThis.document.createElement(tag); + }, + writable: true, + configurable: true + }, + addEventListener: { value() { }, writable: true, configurable: true }, + removeEventListener: { value() { }, writable: true, configurable: true }, + dispatchEvent: { + value() { + return true; + }, + writable: true, + configurable: true + }, + moveBefore: { + value(node) { + return node; + }, + writable: true, + configurable: true + }, + lookupPrefix: { + value() { + return null; + }, + writable: true, + configurable: true + }, + lookupNamespaceURI: { + value() { + return null; + }, + writable: true, + configurable: true + }, + isDefaultNamespace: { + value() { + return false; + }, + writable: true, + configurable: true + } + }); + Object.defineProperties(Element.prototype, { + nodeType: { value: 1, writable: true, configurable: true }, + localName: { + get() { + return (this.tagName || '').toLowerCase(); + }, + configurable: true, + enumerable: true + }, + namespaceURI: { + get() { + return 'http://www.w3.org/1999/xhtml'; + }, + configurable: true, + enumerable: true + }, + prefix: { value: null, writable: true, configurable: true }, + hasAttribute: { + value() { + return false; + }, + writable: true, + configurable: true + }, + getAttribute: { + value() { + return null; + }, + writable: true, + configurable: true + }, + setAttribute: { value() { }, writable: true, configurable: true }, + removeAttribute: { value() { }, writable: true, configurable: true }, + hasAttributeNS: { + value() { + return false; + }, + writable: true, + configurable: true + }, + getAttributeNS: { + value() { + return null; + }, + writable: true, + configurable: true + }, + setAttributeNS: { value() { }, writable: true, configurable: true }, + removeAttributeNS: { value() { }, writable: true, configurable: true }, + releasePointerCapture: { value() { }, writable: true, configurable: true }, + setPointerCapture: { value() { }, writable: true, configurable: true }, + hasPointerCapture: { + value() { + return false; + }, + writable: true, + configurable: true + }, + getAttributeNode: { + value() { + return null; + }, + writable: true, + configurable: true + }, + getAttributeNodeNS: { + value() { + return null; + }, + writable: true, + configurable: true + }, + getElementsByTagName: { + value() { + return EMPTY_ARRAY; + }, + writable: true, + configurable: true + }, + getElementsByTagNameNS: { + value() { + return EMPTY_ARRAY; + }, + writable: true, + configurable: true + }, + querySelector: { + value() { + return null; + }, + writable: true, + configurable: true + }, + querySelectorAll: { + value() { + return EMPTY_ARRAY; + }, + writable: true, + configurable: true + }, + scrollTop: { value: 0, writable: true, configurable: true }, + scrollLeft: { value: 0, writable: true, configurable: true }, + scrollHeight: { value: 0, writable: true, configurable: true }, + scrollWidth: { value: 0, writable: true, configurable: true }, + clientTop: { value: 0, writable: true, configurable: true }, + clientLeft: { value: 0, writable: true, configurable: true }, + firstElementChild: { value: null, writable: true, configurable: true }, + lastElementChild: { value: null, writable: true, configurable: true }, + nextElementSibling: { value: null, writable: true, configurable: true }, + previousElementSibling: { value: null, writable: true, configurable: true }, + children: { + get() { + return EMPTY_ARRAY; + }, + configurable: true, + enumerable: true + }, + prepend: { value() { }, writable: true, configurable: true }, + append: { value() { }, writable: true, configurable: true }, + replaceWith: { value() { }, writable: true, configurable: true }, + hasAttributes: { + value() { + return false; + }, + writable: true, + configurable: true + }, + scrollIntoViewIfNeeded: { value() { }, writable: true, configurable: true }, + removeAttributeNode: { value() { }, writable: true, configurable: true }, + setAttributeNode: { value() { }, writable: true, configurable: true }, + normalize: { value() { }, writable: true, configurable: true }, + dispatchEvent: { + value() { + return true; + }, + writable: true, + configurable: true + }, + animate: { + value() { + return ANIMATION_OBJ; + }, + writable: true, + configurable: true + }, + browsingTopics: { + async value() { + return EMPTY_ARRAY; + }, + writable: true, + configurable: true + }, + ariaNotify: { value() { }, writable: true, configurable: true }, + checkVisibility: { + value() { + return true; + }, + writable: true, + configurable: true + }, + webkitMatchesSelector: { + value() { + return false; + }, + writable: true, + configurable: true + }, + attachShadow: { + value(init) { + const shadowRoot = Object.create(SHADOW_ROOT_PROTO); + shadowRoot.mode = init?.mode || 'open'; + shadowRoot.host = this; + return shadowRoot; + }, + writable: true, + configurable: true + } + }); + Object.defineProperties(HTMLElement.prototype, { + dir: { value: '', writable: true, configurable: true }, + id: { value: '', writable: true, configurable: true }, + className: { value: '', writable: true, configurable: true }, + title: { value: '', writable: true, configurable: true }, + lang: { value: '', writable: true, configurable: true }, + offsetHeight: { value: 0, writable: true, configurable: true }, + offsetWidth: { value: 0, writable: true, configurable: true }, + clientHeight: { value: 0, writable: true, configurable: true }, + clientWidth: { value: 0, writable: true, configurable: true }, + click: { value() { }, writable: true, configurable: true }, + blur: { value() { }, writable: true, configurable: true }, + focus: { value() { }, writable: true, configurable: true } + }); + // ts was so annonying to test and make holy. its not perfect, but it works :p + Object.defineProperties(Document.prototype, { + defaultCharset: { value: 'UTF-8', writable: true, configurable: true }, + readyState: { value: 'complete', writable: true, configurable: true }, + hidden: { value: false, writable: true, configurable: true }, + hasFocus: { + value() { + return true; + }, + writable: true, + configurable: true + }, + getElementsByTagNameNS: { + value() { + return EMPTY_ARRAY; + }, + writable: true, + configurable: true + }, + getElementById: { + value() { + return null; + }, + writable: true, + configurable: true + }, + querySelector: { + value() { + return null; + }, + writable: true, + configurable: true + }, + querySelectorAll: { + value() { + return EMPTY_ARRAY; + }, + writable: true, + configurable: true + }, + createTextNode: { + value(text) { + return { nodeValue: text, textContent: text }; + }, + writable: true, + configurable: true + }, + createDocumentFragment: { + value() { + const frag = Object.create(Node.prototype); + frag.nodeType = 11; + return frag; + }, + writable: true, + configurable: true + } + }); + Object.assign(HTMLIFrameElement.prototype, { + width: '', + height: '', + contentDocument: null, + contentWindow: null + }); + Object.assign(HTMLCanvasElement.prototype, { width: 300, height: 150 }); + Object.assign(HTMLImageElement.prototype, { + width: 0, + height: 0, + src: '', + alt: '', + useMap: '', + complete: true, + hspace: 0, + vspace: 0 + }); + _classes = { + EventTarget, + Node, + Element, + HTMLElement, + HTMLIFrameElement, + HTMLCanvasElement, + HTMLImageElement, + HTMLDivElement, + HTMLBodyElement, + HTMLHtmlElement, + Window, + Document, + HTMLDocument, + Navigator, + Location, + Performance, + Screen, + CSSStyleDeclaration, + PluginArray, + MimeTypeArray, + Scheduler, + getDummyConstructor, + getEventCtorProto + }; +} +function isConstructorName(prop) { + const c0 = prop.charCodeAt(0); + if (c0 >= 65 && c0 <= 90) + return true; + if (c0 === 119 && + prop.length > 6 && + prop.charCodeAt(1) === 101 && + prop.charCodeAt(2) === 98 && + prop.charCodeAt(3) === 107 && + prop.charCodeAt(4) === 105 && + prop.charCodeAt(5) === 116) { + const c6 = prop.charCodeAt(6); + return c6 >= 65 && c6 <= 90; + } + if (c0 === 109 && + prop.length > 3 && + prop.charCodeAt(1) === 111 && + prop.charCodeAt(2) === 122) { + const c3 = prop.charCodeAt(3); + return c3 >= 65 && c3 <= 90; + } + if (c0 === 109 && prop.length > 2 && prop.charCodeAt(1) === 115) { + const c2 = prop.charCodeAt(2); + return c2 >= 65 && c2 <= 90; + } + return false; +} +export class NativeDOM { + // biome-ignore lint/suspicious/noExplicitAny: window shape is arbitrary BotGuard-facing object + window; + constructor(options) { + _init(); + const { EventTarget, Node, Element, HTMLElement, HTMLIFrameElement, HTMLCanvasElement, HTMLImageElement, HTMLDivElement, HTMLBodyElement, HTMLHtmlElement, Window, Document, HTMLDocument, Navigator, Location, Performance, Screen, CSSStyleDeclaration, PluginArray, MimeTypeArray, Scheduler, getDummyConstructor, getEventCtorProto } = _classes; + const urlObj = new URL(options.url); + const performanceMock = Object.create(Performance.prototype); + performanceMock.now = () => performance.now(); + performanceMock.timeOrigin = performance.timeOrigin; + const locationMock = Object.create(Location.prototype); + locationMock.href = options.url; + locationMock.origin = urlObj.origin; + locationMock.protocol = urlObj.protocol; + locationMock.host = urlObj.host; + locationMock.hostname = urlObj.hostname; + locationMock.pathname = urlObj.pathname; + locationMock.search = urlObj.search; + locationMock.hash = urlObj.hash; + locationMock.ancestorOrigins = EMPTY_ARRAY; + locationMock.toString = () => options.url; + locationMock.valueOf = () => locationMock; + const navigatorMock = Object.create(Navigator.prototype); + navigatorMock.userAgent = options.userAgent; + navigatorMock.languages = ['en-US', 'en']; + navigatorMock.platform = 'Win32'; + navigatorMock.appName = 'Netscape'; + navigatorMock.appCodeName = 'Mozilla'; + navigatorMock.plugins = Object.create(PluginArray.prototype); + navigatorMock.mimeTypes = Object.create(MimeTypeArray.prototype); + navigatorMock.cookieEnabled = true; + navigatorMock.onLine = true; + navigatorMock.hardwareConcurrency = 8; + navigatorMock.deviceMemory = 8; + navigatorMock.maxTouchPoints = 0; + navigatorMock.javaEnabled = () => false; + const TAG_PROTO_MAP = { + iframe: HTMLIFrameElement.prototype, + canvas: HTMLCanvasElement.prototype, + img: HTMLImageElement.prototype, + div: HTMLDivElement.prototype, + body: HTMLBodyElement.prototype, + html: HTMLHtmlElement.prototype + }; + const cssProxyHandler = { + get(target, prop, receiver) { + if (typeof prop === 'symbol') + return Reflect.get(target, prop, receiver); + if (prop === 'toString') + return () => '[object CSSStyleDeclaration]'; + if (Reflect.has(target, prop) || Reflect.has(Object.prototype, prop)) { + return Reflect.get(target, prop, receiver); + } + return ''; + }, + set() { + return true; + } + }; + const elementProxyHandler = { + get(target, prop, receiver) { + if (typeof prop !== 'string') + return Reflect.get(target, prop, receiver); + if (Reflect.has(target, prop)) + return Reflect.get(target, prop, receiver); + if (ELEMENT_STRING_PROPS.has(prop)) { + const tag = target.tagName?.toLowerCase(); + if (prop === 'width' || prop === 'height') { + if (tag === 'canvas') + return prop === 'width' ? 300 : 150; + if (tag === 'img') + return 0; + return ''; + } + return ''; + } + if (ELEMENT_BOOL_PROPS.has(prop)) + return false; + if (ELEMENT_ZERO_PROPS.has(prop)) + return 0; + if (prop === 'tabIndex') + return -1; + return Reflect.get(target, prop, receiver); + } + }; + const createElement = (tagName) => { + const tag = tagName.toLowerCase(); + const proto = TAG_PROTO_MAP[tag] ?? HTMLElement.prototype; + const styleMock = new Proxy(Object.create(CSSStyleDeclaration.prototype), cssProxyHandler); + const element = Object.create(proto); + element.tagName = tag.toUpperCase(); + element.nodeName = element.tagName; + element.style = styleMock; + element.attributes = EMPTY_ARRAY; + if (tag === 'iframe') { + let _contentWindow = null; + const buildIframe = () => { + if (_contentWindow) + return; + const subDocument = Object.create(HTMLDocument.prototype); + subDocument.URL = 'about:blank'; + subDocument.referrer = options.url; + subDocument.readyState = 'complete'; + subDocument.defaultCharset = 'UTF-8'; + subDocument.hidden = false; + subDocument.createElement = createElement; + subDocument.createEvent = (type) => documentMock.createEvent(type); + subDocument.body = createElement('body'); + subDocument.documentElement = createElement('html'); + subDocument.getElementsByTagName = () => EMPTY_ARRAY; + subDocument.addEventListener = () => { }; + subDocument.removeEventListener = () => { }; + subDocument.hasFocus = () => true; + const subWindow = Object.create(Window.prototype); + subWindow.document = subDocument; + subWindow.location = locationMock; + subWindow.origin = urlObj.origin; + subWindow.navigator = navigatorMock; + subWindow.performance = performanceMock; + subWindow.length = 0; + subWindow.TEMPORARY = 0; + subWindow.PERSISTENT = 1; + subWindow.scrollY = 0; + subWindow.scrollX = 0; + subWindow.btoa = windowMock.btoa; + subWindow.atob = windowMock.atob; + subWindow.close = () => { }; + Object.setPrototypeOf(subWindow, globalThis); + subWindow.window = subWindow; + subWindow.self = subWindow; + subWindow.top = windowProxy; + subWindow.parent = windowProxy; + subWindow.frames = subWindow; + subDocument.defaultView = subWindow; + _contentWindow = makeWindowProxy(subWindow); + }; + Object.defineProperty(element, 'contentWindow', { + get() { + buildIframe(); + return _contentWindow; + }, + configurable: true, + enumerable: true + }); + Object.defineProperty(element, 'contentDocument', { + get() { + buildIframe(); + return _contentWindow?.document ?? null; + }, + configurable: true, + enumerable: true + }); + } + else if (tag === 'canvas') { + element.getContext = (type) => type === '2d' ? CANVAS_2D_CTX : null; + } + return new Proxy(element, elementProxyHandler); + }; + const createEvent = (type) => { + let constructorName = 'Event'; + for (let i = 0; i < EVENT_TYPE_KEYS.length; i++) { + const key = EVENT_TYPE_KEYS[i]; + if (key !== undefined && type.includes(key)) { + constructorName = EVENT_TYPE_MAP[key] ?? 'Event'; + break; + } + } + const event = Object.create(getEventCtorProto(constructorName)); + event.type = type; + event.timeStamp = performance.now(); + return event; + }; + const documentMock = Object.create(HTMLDocument.prototype); + documentMock.URL = options.url; + documentMock.referrer = options.referrer; + documentMock.readyState = 'complete'; + documentMock.defaultCharset = 'UTF-8'; + documentMock.hidden = false; + documentMock.location = locationMock; + documentMock.body = createElement('body'); + documentMock.documentElement = createElement('html'); + documentMock.createElement = createElement; + documentMock.createEvent = createEvent; + documentMock.getElementsByTagName = (name) => { + const tag = name.toLowerCase(); + if (tag === 'head' || tag === 'body' || tag === 'html') + return [createElement(tag)]; + return EMPTY_ARRAY; + }; + documentMock.getElementsByTagNameNS = (_ns, name) => documentMock.getElementsByTagName(name); + documentMock.addEventListener = () => { }; + documentMock.removeEventListener = () => { }; + documentMock.hasFocus = () => true; + const windowMock = Object.create(Window.prototype); + windowMock.document = documentMock; + windowMock.location = locationMock; + windowMock.origin = urlObj.origin; + windowMock.navigator = navigatorMock; + windowMock.performance = performanceMock; + windowMock.name = ''; + windowMock.innerHeight = 1080; + windowMock.innerWidth = 1920; + windowMock.outerHeight = 1080; + windowMock.outerWidth = 1920; + windowMock.screenX = 0; + windowMock.screenY = 0; + windowMock.screenLeft = 0; + windowMock.screenTop = 0; + windowMock.devicePixelRatio = 1; + windowMock.screen = Object.assign(Object.create(Screen.prototype), { + width: 1920, + height: 1080, + availWidth: 1920, + availHeight: 1080, + colorDepth: 24, + pixelDepth: 24 + }); + windowMock.length = 0; + windowMock.TEMPORARY = 0; + windowMock.PERSISTENT = 1; + windowMock.scrollY = 0; + windowMock.scrollX = 0; + windowMock.btoa = (str) => Buffer.from(str, 'binary').toString('base64'); + windowMock.atob = (str) => Buffer.from(str, 'base64').toString('binary'); + windowMock.close = () => { }; + windowMock.getComputedStyle = (el) => el.style || {}; + windowMock.cancelIdleCallback = () => { }; + windowMock.requestIdleCallback = (cb) => setTimeout(cb, 1); + windowMock.credentialless = false; + windowMock.offscreenBuffering = true; + windowMock.isSecureContext = true; + windowMock.reportError = (err) => { + console.error(err); + }; + windowMock.history = { + length: 1, + scrollRestoration: 'auto', + state: null, + back() { }, + forward() { }, + go() { }, + pushState() { }, + replaceState() { } + }; + windowMock.sharedStorage = {}; + windowMock.scheduler = new Scheduler(); + windowMock.fetchLater = () => DEFERRED_REQUEST_OBJ; + Object.assign(windowMock, { + EventTarget, + Window, + Document, + HTMLDocument, + Navigator, + Location, + Performance, + PluginArray, + MimeTypeArray, + CSSStyleDeclaration, + Screen, + Node, + Element, + HTMLElement, + HTMLIFrameElement, + HTMLCanvasElement, + HTMLImageElement, + HTMLDivElement, + HTMLBodyElement, + HTMLHtmlElement, + Scheduler + }); + const makeWindowProxy = (winTarget) => new Proxy(winTarget, { + has(target, prop) { + if (typeof prop !== 'string') + return Reflect.has(target, prop); + if (Reflect.has(target, prop) || Reflect.has(globalThis, prop)) + return true; + if (isConstructorName(prop)) + return true; + return (prop.length > 2 && + prop.charCodeAt(0) === 111 && + prop.charCodeAt(1) === 110); + }, + getOwnPropertyDescriptor(target, prop) { + if (typeof prop !== 'string') + return Reflect.getOwnPropertyDescriptor(target, prop); + if (Reflect.has(target, prop)) + return Reflect.getOwnPropertyDescriptor(target, prop); + if (isConstructorName(prop)) { + return { + value: getDummyConstructor(prop), + writable: true, + enumerable: true, + configurable: true + }; + } + if (prop.length > 2 && + prop.charCodeAt(0) === 111 && + prop.charCodeAt(1) === 110) { + return { + value: null, + writable: true, + enumerable: true, + configurable: true + }; + } + if (Reflect.has(globalThis, prop)) + return Reflect.getOwnPropertyDescriptor(globalThis, prop); + return Reflect.getOwnPropertyDescriptor(target, prop); + }, + get(target, prop, receiver) { + if (typeof prop !== 'string') + return Reflect.get(target, prop, receiver); + if (prop === 'window' || + prop === 'self' || + prop === 'top' || + prop === 'parent' || + prop === 'frames') { + return receiver; + } + if (Reflect.has(target, prop)) + return Reflect.get(target, prop, receiver); + if (isConstructorName(prop)) + return getDummyConstructor(prop); + if (prop.length > 2 && + prop.charCodeAt(0) === 111 && + prop.charCodeAt(1) === 110) + return null; + if (Reflect.has(globalThis, prop)) + return Reflect.get(globalThis, prop); + return Reflect.get(target, prop, receiver); + } + }); + // windowProxy must exist before iframe sub-windows reference it. + let windowProxy; + windowProxy = makeWindowProxy(windowMock); + documentMock.defaultView = windowProxy; + this.window = windowProxy; + } +} diff --git a/dist/src/sources/youtube/sabr/potoken.js b/dist/src/sources/youtube/sabr/potoken.js index 7268ccbc..04ea5fb4 100644 --- a/dist/src/sources/youtube/sabr/potoken.js +++ b/dist/src/sources/youtube/sabr/potoken.js @@ -1,8 +1,8 @@ import { Buffer } from 'node:buffer'; import { appendFile } from 'node:fs/promises'; import path from 'node:path'; -import { logger } from "../../../utils.js"; -import { base64ToU8 } from "./protor.js"; +import { logger } from '../../../utils.js'; +import { base64ToU8 } from './protor.js'; /** * Path to the log file for PO tokens. * @internal @@ -14,7 +14,7 @@ const TOKENS_LOG_PATH = path.join(process.cwd(), 'po_tokens.jsonl'); */ const PO_CONFIG = { apiKey: 'AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw', - userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36', + userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', ytBaseUrl: 'https://www.youtube.com', googBaseUrl: 'https://jnn-pa.googleapis.com' }; @@ -169,22 +169,22 @@ export class PoTokenManager { _prevGlobals = null; _idleTimer = null; /** - * Refreshes the idle timeout for JSDOM resources. + * Refreshes the idle timeout for NativeDOM resources. * @internal */ _refreshIdleTimer() { if (this._idleTimer) clearTimeout(this._idleTimer); this._idleTimer = setTimeout(() => { - logger('debug', 'PoToken', 'Idle timeout reached. Cleaning up JSDOM resources.'); + logger('debug', 'PoToken', 'Idle timeout reached. Cleaning up NativeDOM resources.'); this.reset(); }, 10 * 60 * 1000); if (this._idleTimer.unref) this._idleTimer.unref(); } /** - * Applies JSDOM environment to globalThis. - * @param dom - JSDOM instance. + * Applies NativeDOM environment to globalThis. + * @param dom - NativeDOM instance. * @internal */ _applyDomGlobals(dom) { @@ -212,7 +212,7 @@ export class PoTokenManager { } } /** - * Cleans up JSDOM and restores previous globals. + * Cleans up NativeDOM and restores previous globals. * @internal */ _cleanupDom() { @@ -275,13 +275,13 @@ export class PoTokenManager { 'user-agent': PO_CONFIG.userAgent, 'x-goog-api-key': PO_CONFIG.apiKey, 'x-youtube-client-name': '1', - 'x-youtube-client-version': '2.20260114.01.00' + 'x-youtube-client-version': '2.20260706.00.00' }, body: JSON.stringify({ context: { client: { clientName: 'WEB', - clientVersion: '2.20260114.01.00', + clientVersion: '2.20260706.00.00', visitorData } }, @@ -331,9 +331,17 @@ export class PoTokenManager { this.visitorData = await this.fetchVisitorData(); } logger('debug', 'PoToken', `VisitorData: ${this.visitorData?.slice(0, 20)}...`); + await this._initializeWithDom(); + logger('debug', 'PoToken', 'BotGuard initialization with NativeDOM complete'); + } + /** + * Internal helper to perform BotGuard initialization with NativeDOM. + * @internal + */ + async _initializeWithDom() { this._cleanupDom(); - const { JSDOM } = await import('jsdom'); - this._dom = new JSDOM('', { + const { NativeDOM } = await import('./nativeDOM.js'); + this._dom = new NativeDOM({ url: 'https://www.youtube.com/', referrer: 'https://www.youtube.com/', userAgent: PO_CONFIG.userAgent @@ -372,9 +380,16 @@ export class PoTokenManager { body: JSON.stringify([requestKey, botguardResponse]) }); const response = (await integrityTokenResponse.json()); - if (typeof response[0] !== 'string') + let token = ''; + if (response && typeof response[0] === 'string') { + token = response[0]; + } + else if (response && typeof response[3] === 'string') { + token = response[3]; + } + if (!token) throw new Error('Could not get integrity token'); - this.integrityToken = response[0]; + this.integrityToken = token; logger('debug', 'PoToken', `IntegrityToken retrieved. Length: ${this.integrityToken.length}`); this.minter = await WebPoMinter.create(this.integrityToken, webPoSignalOutput); logger('debug', 'PoToken', 'Initialization complete'); diff --git a/dist/src/sources/youtube/sabr/sabr.js b/dist/src/sources/youtube/sabr/sabr.js index 291016d5..9ca849ea 100644 --- a/dist/src/sources/youtube/sabr/sabr.js +++ b/dist/src/sources/youtube/sabr/sabr.js @@ -13,9 +13,9 @@ import { createHash } from 'node:crypto'; import { appendFile } from 'node:fs/promises'; import path from 'node:path'; import { PassThrough } from 'node:stream'; -import { logger } from "../../../utils.js"; -import { poTokenManager } from "./potoken.js"; -import { base64ToU8, concatenateChunks, FormatInitializationMetadata, MediaHeader, NextRequestPolicy, PlaybackStartPolicy, ProtoReader, ReloadPlaybackContext, RequestCancellationPolicy, RequestIdentifier, SabrContextSendingPolicy, SabrContextUpdate, SabrError, SabrRedirect, StreamProtectionStatus, UMPPartId, VideoPlaybackAbrRequest } from "./protor.js"; +import { logger } from '../../../utils.js'; +import { poTokenManager } from './potoken.js'; +import { base64ToU8, concatenateChunks, FormatInitializationMetadata, MediaHeader, NextRequestPolicy, PlaybackStartPolicy, ProtoReader, ReloadPlaybackContext, RequestCancellationPolicy, RequestIdentifier, SabrContextSendingPolicy, SabrContextUpdate, SabrError, SabrRedirect, StreamProtectionStatus, UMPPartId, VideoPlaybackAbrRequest } from './protor.js'; /** * Default User-Agent header for SABR HTTP requests. * @internal @@ -446,8 +446,6 @@ export class SabrStream extends PassThrough { activeSabrContextTypes; /** Current request sequence number. */ requestNumber; - /** Whether media headers have been processed. */ - mediaHeadersProcessed; /** Flag indicating the stream has been aborted. */ _aborted; /** Last sequence number per itag. */ @@ -474,14 +472,30 @@ export class SabrStream extends PassThrough { startTime; /** Position callback for reporting playback progress. */ positionCallback; + /** Callback used to stop the SABR playhead while playback is paused. */ + playbackPaused; /** User-Agent header for HTTP requests. */ userAgent; /** Whether a recovery operation is pending. */ recoveryPending; + /** Whether the current session is paused for transfer to a seek stream. */ + seekHandoffPending; + /** Whether this stream started by continuing a transferred seek session. */ + usingTransferredSession; + /** Currently active UMP request, awaited before exporting seek state. */ + activeRequest; /** Flag to prevent duplicate PO token generation. */ poTokenGenerated; - /** Flag to prevent repeated stall emissions. */ - stallEmitted; + /** Monotonic counter advanced whenever a media segment completes. */ + mediaProgressGeneration; + /** Status-2 observations made without intervening media progress. */ + limitedPlaybackCount; + /** Media generation associated with the current status-2 streak. */ + limitedPlaybackGeneration; + /** Recovery requested while the current UMP response is still being read. */ + pendingRecoveryReason; + /** SABR error deferred until the complete UMP response has been processed. */ + pendingResponseError; /** Total downloaded duration in milliseconds. */ totalDownloadedMs; /** Virtual player time for ABR state tracking. */ @@ -576,7 +590,6 @@ export class SabrStream extends PassThrough { this.sabrContexts = new Map(); this.activeSabrContextTypes = new Set(); this.requestNumber = 0; - this.mediaHeadersProcessed = false; this._aborted = false; this.formatSequenceCounters = new Map(); this.downloadedSegmentsByItag = new Map(); @@ -597,17 +610,25 @@ export class SabrStream extends PassThrough { this.formatIds = config.formats ?? []; this.startTime = config.startTime ?? 0; this.positionCallback = config.positionCallback; + this.playbackPaused = config.playbackPaused; this.userAgent = config.userAgent ?? USER_AGENT; this.recoveryPending = false; + this.seekHandoffPending = false; + this.usingTransferredSession = config.previousSession != null; + this.activeRequest = null; this.poTokenGenerated = false; - this.stallEmitted = false; + this.mediaProgressGeneration = 0; + this.limitedPlaybackCount = 0; + this.limitedPlaybackGeneration = 0; + this.pendingRecoveryReason = null; + this.pendingResponseError = null; this.totalDownloadedMs = 0; this.virtualPlayerTimeMs = 0; this.lastVirtualAdvanceAt = 0; this.pendingRangesHeaders = new Map(); this.cachedBufferedRanges = null; this.lastReportedRanges = new Set(); - this.enableTrafficLog = true; + this.enableTrafficLog = false; this.trafficLogPath = path.join(process.cwd(), 'sabr_traffic.jsonl'); this.enableTrafficDump = true; this.trafficDumpMaxBytes = 64 * 1024; @@ -628,11 +649,20 @@ export class SabrStream extends PassThrough { else if (config.poToken instanceof Uint8Array) { this.poToken = config.poToken; } + this.poTokenGenerated = (this.poToken?.length ?? 0) > 0; if (config.previousSession) { const ps = config.previousSession; this.requestNumber = ps.requestNumber ?? 0; this.bandwidthEstimate = ps.bandwidthEstimate ?? 5_000_000; this.nextRequestPolicy = ps.nextRequestPolicy; + this.sabrContexts = new Map((ps.sabrContexts ?? []).map((context) => [ + context.type, + { + ...context, + value: context.value.slice() + } + ])); + this.activeSabrContextTypes = new Set(ps.activeSabrContextTypes ?? []); logger('info', 'SABR', `Session state transferred: rn=${this.requestNumber}, bw=${(this.bandwidthEstimate / 1_000_000).toFixed(2)}Mbps, hasCookie=${!!this.nextRequestPolicy?.playbackCookie}`); } this.lastRequestAt = 0; @@ -656,8 +686,46 @@ export class SabrStream extends PassThrough { requestNumber: this.requestNumber, bandwidthEstimate: this.bandwidthEstimate, nextRequestPolicy: this.nextRequestPolicy + ? { + ...this.nextRequestPolicy, + playbackCookie: this.nextRequestPolicy.playbackCookie?.slice() + } + : undefined, + sabrContexts: Array.from(this.sabrContexts.values(), (context) => ({ + ...context, + value: context.value.slice() + })), + activeSabrContextTypes: Array.from(this.activeSabrContextTypes) }; } + /** Pauses new requests and exports continuity state for a seek replacement. */ + async beginSeekHandoff() { + if (this._aborted || + this.destroyed || + this.recoveryPending || + this.seekHandoffPending) + return null; + this.seekHandoffPending = true; + const request = this.activeRequest; + if (request) { + try { + await request; + } + catch { + this.seekHandoffPending = false; + return null; + } + } + if (this._aborted || this.destroyed || this.recoveryPending) { + this.seekHandoffPending = false; + return null; + } + return this.getSessionState(); + } + /** Resumes the current session when a prepared seek stream could not commit. */ + cancelSeekHandoff() { + this.seekHandoffPending = false; + } /** * Writes a traffic log entry to the log file. * @param entry - Log entry to write. @@ -697,6 +765,56 @@ export class SabrStream extends PassThrough { } this.loop(audioFormat); } + /** Returns the current media-progress generation for recovery validation. */ + getMediaProgressGeneration() { + return this.mediaProgressGeneration; + } + /** Returns whether a prepared replacement still matches the stalled state. */ + canCommitRecovery(generation) { + return (this.recoveryPending && + !this._aborted && + !this.destroyed && + this.mediaProgressGeneration === generation); + } + /** Resumes the existing session when recovery became stale while resolving. */ + cancelRecovery() { + this.recoveryPending = false; + } + /** Emits one recovery request and records the media generation it protects. */ + signalRecovery(reason) { + if (this.recoveryPending || this._aborted || this.destroyed) + return; + this.recoveryPending = true; + this.emit('stall', reason, this.mediaProgressGeneration); + } + /** Defers recovery until all parts in the current UMP response are handled. */ + queueRecovery(reason) { + if (this.pendingRecoveryReason === 'reload') + return; + if (reason === 'reload' || !this.pendingRecoveryReason) { + this.pendingRecoveryReason = reason; + } + } + /** Records completed media and invalidates protection-only recovery evidence. */ + recordMediaProgress() { + if (this.mediaProgressGeneration === 0) { + this.lastVirtualAdvanceAt = Date.now(); + } + this.mediaProgressGeneration++; + this.emit('mediaProgress', this.mediaProgressGeneration); + this.limitedPlaybackCount = 0; + this.limitedPlaybackGeneration = this.mediaProgressGeneration; + if (this.pendingRecoveryReason === 'protection') { + this.pendingRecoveryReason = null; + } + } + /** Emits any recovery collected while parsing the response. */ + flushPendingRecovery() { + const reason = this.pendingRecoveryReason; + this.pendingRecoveryReason = null; + if (reason) + this.signalRecovery(reason); + } /** * Main streaming loop that fetches and processes segments. * @param audioFormat - Audio format configuration. @@ -704,10 +822,8 @@ export class SabrStream extends PassThrough { async loop(audioFormat) { const signal = this.abortController.signal; try { - if (this.lastVirtualAdvanceAt === 0) - this.lastVirtualAdvanceAt = Date.now(); while (!this._aborted && !this.destroyed && !this.streamFinished) { - if (this.recoveryPending) { + if (this.recoveryPending || this.seekHandoffPending) { await wait(500, signal); continue; } @@ -732,77 +848,69 @@ export class SabrStream extends PassThrough { } const now = Date.now(); const prevPlayerTime = this.virtualPlayerTimeMs; - if (this.totalDownloadedMs > this.virtualPlayerTimeMs) { - if (this.lastVirtualAdvanceAt > 0) { - this.virtualPlayerTimeMs += now - this.lastVirtualAdvanceAt; - } - this.lastVirtualAdvanceAt = now; - } - else { - if (this.totalDownloadedMs > 0) { - if (this.lastVirtualAdvanceAt > 0) { - const advance = now - this.lastVirtualAdvanceAt; - this.virtualPlayerTimeMs = Math.min(this.virtualPlayerTimeMs + advance, this.totalDownloadedMs); - } - this.lastVirtualAdvanceAt = now; - } + const paused = this.playbackPaused?.() ?? false; + if (!paused && + this.mediaProgressGeneration > 0 && + this.lastVirtualAdvanceAt > 0 && + this.totalDownloadedMs > this.virtualPlayerTimeMs) { + this.virtualPlayerTimeMs = Math.min(this.virtualPlayerTimeMs + (now - this.lastVirtualAdvanceAt), this.totalDownloadedMs); } + this.lastVirtualAdvanceAt = now; if (Math.floor(this.virtualPlayerTimeMs / 1000) !== Math.floor(prevPlayerTime / 1000)) { logger('debug', 'SABR', `Tracking: downloaded=${Math.floor(this.totalDownloadedMs)}ms virtualPlayerTime=${Math.floor(prevPlayerTime)}ms -> ${Math.floor(this.virtualPlayerTimeMs)}ms`); } const baseTimeMs = this.startTime ?? 0; const reportedPlayerTime = Math.floor(this.virtualPlayerTimeMs + baseTimeMs); + const requestCursorMs = Math.floor(this.totalDownloadedMs + baseTimeMs); if (this.readableLength > MAX_BUFFER_BYTES) { await wait(250, signal); continue; } - if (this.mediaHeadersProcessed && this.positionCallback) { + if (this.mediaProgressGeneration > 0 && this.positionCallback) { this.positionCallback(reportedPlayerTime); } + if (paused && this.mediaProgressGeneration > 0) { + await wait(250, signal); + continue; + } if (this.lastRequestAt) { const since = now - this.lastRequestAt; if (since < MIN_REQUEST_INTERVAL_MS) await wait(MIN_REQUEST_INTERVAL_MS - since, signal); } this.lastRequestAt = Date.now(); + const request = this.fetchAndProcessSegments({ + playerTimeMs: requestCursorMs, + bandwidthEstimate: Math.max(Math.floor(this.bandwidthEstimate), 500_000), + enabledTrackTypesBitfield: 1, + audioTrackId: audioFormat.audioTrackId ?? '', + playerState: 1n, + visibility: 1, + playbackRate: 1.0, + stickyResolution: 1080, + lastManualSelectedResolution: 1080, + clientViewportIsFlexible: false + }, audioFormat); + this.activeRequest = request; try { - await this.fetchAndProcessSegments({ - playerTimeMs: Math.floor(this.totalDownloadedMs + baseTimeMs), - bandwidthEstimate: Math.max(Math.floor(this.bandwidthEstimate), 500_000), - enabledTrackTypesBitfield: 1, - audioTrackId: audioFormat.audioTrackId ?? '', - playerState: 1n, - visibility: 1, - playbackRate: 1.0, - stickyResolution: 1080, - lastManualSelectedResolution: 1080, - clientViewportIsFlexible: false - }, audioFormat); + await request; } catch (e) { if (this._aborted || this.destroyed) break; const message = e instanceof Error ? e.message : String(e); - if (message.includes('sabr.malformed_config') || - message.includes('sabr.media_serving_enforcement_id_error')) { - logger('warn', 'SABR', `Recoverable error detected: ${message}. Triggering recovery signal...`); - if (message.includes('media_serving_enforcement_id_error')) { - logger('warn', 'SABR', 'Enforcement ID error detected. Clearing SABR contexts to force fresh state.'); - this.sabrContexts.clear(); - this.activeSabrContextTypes.clear(); - } - this.emit('stall'); - const currentRn = this.requestNumber; - while (this.requestNumber === currentRn && - !this._aborted && - !this.destroyed) { - await wait(500, signal); - } + if (message.startsWith('HTTP ')) { + logger('warn', 'SABR', `HTTP failure detected: ${message}. Triggering session recovery...`); + this.signalRecovery('http'); continue; } throw e; } + finally { + if (this.activeRequest === request) + this.activeRequest = null; + } if (!this.nextRequestPolicy?.backoffTimeMs && this.initializedFormatsMap.size === 0) { await wait(250, signal); @@ -823,6 +931,22 @@ export class SabrStream extends PassThrough { return this; this._aborted = true; this.abortController.abort(); + this.initializedFormatsMap.clear(); + this.partialSegmentQueue.clear(); + this.sabrContexts.clear(); + this.activeSabrContextTypes.clear(); + this.formatSequenceCounters.clear(); + this.downloadedSegmentsByItag.clear(); + this.endSegmentNumbers.clear(); + this.pendingRangesHeaders.clear(); + this.cachedBufferedRanges = null; + this.lastReportedRanges.clear(); + this.nextRequestPolicy = undefined; + this.formatIds = []; + this.poToken = null; + this.videoPlaybackUstreamerConfig = undefined; + this.clientInfo = undefined; + this.config = {}; super.destroy(err); return this; } @@ -845,7 +969,7 @@ export class SabrStream extends PassThrough { if (config.videoPlaybackUstreamerConfig) { this.videoPlaybackUstreamerConfig = config.videoPlaybackUstreamerConfig; } - if (config.poToken) { + if (config.poToken != null) { try { this.poToken = typeof config.poToken === 'string' @@ -855,6 +979,7 @@ export class SabrStream extends PassThrough { catch (e) { const message = e instanceof Error ? e.message : String(e); logger('error', 'SABR', `Failed to decode PO token (session update): ${message}`); + this.poToken = null; } } if (config.visitorData) { @@ -884,8 +1009,13 @@ export class SabrStream extends PassThrough { this.noMediaStreak = 0; this.pendingRangesHeaders.clear(); this.recoveryPending = false; - this.poTokenGenerated = false; - this.stallEmitted = false; + this.poTokenGenerated = + config.poToken != null && (this.poToken?.length ?? 0) > 0; + this.pendingRecoveryReason = null; + this.pendingResponseError = null; + this.limitedPlaybackCount = 0; + this.limitedPlaybackGeneration = this.mediaProgressGeneration; + this.usingTransferredSession = false; logger('info', 'SABR', `Session updated. Continuing with RN=${this.requestNumber}, URL=${this.serverAbrStreamingUrl?.slice(0, 50)}...`); } /** @@ -895,10 +1025,7 @@ export class SabrStream extends PassThrough { */ clearBuffers() { this.initializedFormatsMap.clear(); - this.downloadedSegmentsByItag.clear(); - this.formatSequenceCounters.clear(); this.partialSegmentQueue.clear(); - this.mediaHeadersProcessed = false; this.pendingRangesHeaders.clear(); this.cachedBufferedRanges = null; this.lastReportedRanges.clear(); @@ -906,39 +1033,6 @@ export class SabrStream extends PassThrough { this.activeSabrContextTypes.clear(); logger('info', 'SABR', `Buffers cleared for recovery. Preserving timeline position: ${this.cumulativeDownloadedMs}ms, totalDownloaded: ${this.totalDownloadedMs}ms`); } - /** - * Seeks to a specific position in the stream. - * - * Clears segment buffers and resets tracking state while preserving - * session state (request number, bandwidth estimate, playback cookie). - * - * @param positionMs - Target position in milliseconds. - * @returns True if the seek was initiated successfully. - */ - seekTo(positionMs) { - if (this._aborted || this.destroyed) { - logger('warn', 'SABR', 'Cannot seek: stream is destroyed or aborted'); - return false; - } - logger('info', 'SABR', `Seeking to ${positionMs}ms (from startTime=${this.startTime}ms)`); - this.startTime = positionMs; - this.downloadedSegmentsByItag.clear(); - this.formatSequenceCounters.clear(); - this.partialSegmentQueue.clear(); - this.initializedFormatsMap.clear(); - this.totalDownloadedMs = 0; - this.virtualPlayerTimeMs = 0; - this.cumulativeDownloadedMs = positionMs; - this.lastVirtualAdvanceAt = Date.now(); - this.pendingRangesHeaders.clear(); - this.cachedBufferedRanges = null; - this.lastReportedRanges.clear(); - this.mediaHeadersProcessed = false; - this.streamFinished = false; - this.noMediaStreak = 0; - logger('debug', 'SABR', `Seek to ${positionMs}ms complete. Session preserved (rn=${this.requestNumber})`); - return true; - } /** * Decodes a UMP part using a protobuf decoder. * @param part - UMP part to decode. @@ -1026,7 +1120,7 @@ export class SabrStream extends PassThrough { error.type = err.type; if (this._aborted || this.destroyed) return; - throw error; + this.pendingResponseError ??= error; } } /** @@ -1053,6 +1147,27 @@ export class SabrStream extends PassThrough { !this.lastStreamProtectionLogAt || now - this.lastStreamProtectionLogAt > 5000; this.lastStreamProtectionStatus = status.status; + // extra for me: mostly of this time this is cause by poToken, + // related to the DOM generation ^^ + // but it can also be other reasons (PMD:undefined for example, which is also from DOM generation) + if (status.status === 2) { + if (this.limitedPlaybackGeneration !== this.mediaProgressGeneration) { + this.limitedPlaybackGeneration = this.mediaProgressGeneration; + this.limitedPlaybackCount = 0; + } + this.limitedPlaybackCount++; + if (shouldLog) { + this.lastStreamProtectionLogAt = now; + logger('warn', 'SABR', `Stream Protection Status: ${status.status} (Limited Playback), observation ${this.limitedPlaybackCount} without media progress.`); + } + if (this.limitedPlaybackCount >= 2) { + poTokenManager.reset(); + this.queueRecovery('protection'); + } + return; + } + this.limitedPlaybackCount = 0; + this.limitedPlaybackGeneration = this.mediaProgressGeneration; if (!shouldLog) return; this.lastStreamProtectionLogAt = now; @@ -1060,16 +1175,6 @@ export class SabrStream extends PassThrough { logger('debug', 'SABR', `Stream Protection Status: ${status.status} (Attestation pending/required)`); return; } - if (status.status === 2) { - if (this.stallEmitted) - return; - this.stallEmitted = true; - logger('warn', 'SABR', `Stream Protection Status: ${status.status} (Limited Playback). Triggering token refresh...`); - poTokenManager.reset(); - this.recoveryPending = true; - this.emit('stall'); - return; - } logger('warn', 'SABR', `Stream Protection Status: ${status.status}`); } /** @@ -1092,6 +1197,8 @@ export class SabrStream extends PassThrough { } const bytes = dataToPush.getLength(); s.loadedBytes = (s.loadedBytes ?? 0) + bytes; + if (s.discard) + return; for (const c of dataToPush.chunks) this.push(c); } @@ -1107,9 +1214,11 @@ export class SabrStream extends PassThrough { const d = part.data.split(1).remainingBuffer; const bytes = d.getLength(); s.loadedBytes = (s.loadedBytes ?? 0) + bytes; - for (const c of d.chunks) - this.push(c); - if (bytes > 0) { + if (!s.discard) { + for (const c of d.chunks) + this.push(c); + } + if (bytes > 0 && !s.discard) { logger('debug', 'SABR', `Media data: id=${headerId} bytes=${bytes} total=${s.loadedBytes}/${s.mediaHeader?.contentLength ?? '?'}`); } } @@ -1146,17 +1255,23 @@ export class SabrStream extends PassThrough { } const mediaHeader = h; const formatIdKey = key; - if (!this.pendingRangesHeaders.has(formatIdKey)) { - this.pendingRangesHeaders.set(formatIdKey, []); + const itag = h.itag ?? h.formatId?.itag; + const discard = itag !== undefined && + this.downloadedSegmentsByItag.get(itag)?.has(segmentNumber) === true; + if (!discard) { + if (!this.pendingRangesHeaders.has(formatIdKey)) { + this.pendingRangesHeaders.set(formatIdKey, []); + } + this.pendingRangesHeaders.get(formatIdKey)?.push(mediaHeader); } - this.pendingRangesHeaders.get(formatIdKey)?.push(mediaHeader); - logger('debug', 'SABR', `MediaHeader: id=${headerId} itag=${h.itag} seq=${segmentNumber} dur=${h.durationMs}ms`); + logger(discard ? 'trace' : 'debug', 'SABR', `${discard ? 'Duplicate media header' : 'MediaHeader'}: id=${headerId} itag=${h.itag} seq=${segmentNumber} dur=${h.durationMs}ms`); this.partialSegmentQueue.set(headerId, { formatIdKey: key, segmentNumber, mediaHeader: h, durationMs: h.durationMs, - loadedBytes: 0 + loadedBytes: 0, + discard }); } else { @@ -1173,6 +1288,11 @@ export class SabrStream extends PassThrough { if (s) { logger('debug', 'SABR', `MediaEnd: id=${id} seq=${s.segmentNumber} totalBytes=${s.loadedBytes}`); const itag = s.mediaHeader?.itag ?? s.mediaHeader?.formatId?.itag; + if (s.discard) { + logger('debug', 'SABR', `Discarded duplicate segment ${s.segmentNumber} for itag ${itag ?? 'unknown'} (${s.loadedBytes} bytes)`); + this.partialSegmentQueue.delete(id); + return; + } let segmentDuration = 0; if (s.durationMs) { segmentDuration = Number(s.durationMs); @@ -1185,7 +1305,8 @@ export class SabrStream extends PassThrough { } if (segmentDuration > 0) { this.totalDownloadedMs += segmentDuration; - this.mediaHeadersProcessed = true; + if ((s.loadedBytes ?? 0) > 0) + this.recordMediaProgress(); logger('debug', 'SABR', `Segment received: itag=${itag} seq=${s.segmentNumber} dur=${segmentDuration}ms totalDownloaded=${Math.floor(this.totalDownloadedMs)}ms`); } if (itag) { @@ -1325,7 +1446,7 @@ export class SabrStream extends PassThrough { if (reloadContext) { const reason = reloadContext.reason; logger('warn', 'SABR', `Reload requested by server. Reason: ${reason ?? 'unknown'}`); - this.emit('stall'); + this.queueRecovery('reload'); } } /** @@ -1340,17 +1461,12 @@ export class SabrStream extends PassThrough { this.lastDetailedLogAt = now; const cookieLen = this.nextRequestPolicy?.playbackCookie?.length ?? 0; const initKeys = Array.from(this.initializedFormatsMap.keys()).slice(0, 5); - const segMap = audioFormat - ? this.downloadedSegmentsByItag.get(audioFormat.itag) - : undefined; - const segs = segMap ? Array.from(segMap.values()) : []; - const downloadedMs = segs.reduce((sum, s) => sum + parseInt(s.durationMs?.toString() ?? '0', 10), 0); - const aheadMs = abrState?.playerTimeMs !== undefined - ? downloadedMs - abrState.playerTimeMs - : undefined; + const playbackTimeMs = Math.floor(this.virtualPlayerTimeMs + (this.startTime ?? 0)); + const bufferedAheadMs = Math.max(0, Math.floor(this.totalDownloadedMs - this.virtualPlayerTimeMs)); const fmt = (f) => f ? `${f.itag}:${f.xtags ?? ''}` : 'none'; - logger('debug', 'SABR', `State rn=${this.requestNumber} playerTimeMs=${abrState?.playerTimeMs} startTime=${this.startTime} readable=${this.readableLength}/${MAX_BUFFER_BYTES} initKeys=[${initKeys.join(',')}] downloadedMs=${downloadedMs} aheadMs=${aheadMs}`); - logger('debug', 'SABR', `Req formats audio=${fmt(audioFormat)} video=${fmt(videoFormat)} selected=[${(selectedFormatIds ?? []).map(String).join(',')}] preferredA=[${(preferredAudioFormatIds ?? []).map(String).join(',')}] bufferedRanges=${bufferedRanges?.length ?? 0} ctx=${contexts?.length ?? 0} unsentCtx=${unsent?.length ?? 0} backoff=${this.nextRequestPolicy?.backoffTimeMs ?? 0} cookieLen=${cookieLen}`); + const fmtId = (f) => `${f.itag ?? ''}:${f.xtags ?? ''}`; + logger('debug', 'SABR', `State rn=${this.requestNumber} requestCursorMs=${abrState?.playerTimeMs} playbackTimeMs=${playbackTimeMs} startTime=${this.startTime} readable=${this.readableLength}/${MAX_BUFFER_BYTES} initKeys=[${initKeys.join(',')}] downloadedMs=${Math.floor(this.totalDownloadedMs)} bufferedAheadMs=${bufferedAheadMs}`); + logger('debug', 'SABR', `Req formats audio=${fmt(audioFormat)} video=${fmt(videoFormat)} selected=[${(selectedFormatIds ?? []).map(fmtId).join(',')}] preferredA=[${(preferredAudioFormatIds ?? []).map(fmtId).join(',')}] bufferedRanges=${bufferedRanges?.length ?? 0} ctx=${contexts?.length ?? 0} unsentCtx=${unsent?.length ?? 0} backoff=${this.nextRequestPolicy?.backoffTimeMs ?? 0} cookieLen=${cookieLen}`); if (bufferedRanges?.length) { const br = bufferedRanges[0]; if (br) { @@ -1535,12 +1651,23 @@ export class SabrStream extends PassThrough { headers.Authorization = `Bearer ${this.config.accessToken}`; } const t0 = Date.now(); - const res = await fetch(url.toString(), { - method: 'POST', - headers, - body: Buffer.from(requestBody), - signal: this.abortController.signal - }); + let res; + try { + res = await fetch(url.toString(), { + method: 'POST', + headers, + body: Buffer.from(requestBody), + signal: this.abortController.signal + }); + } + catch (error) { + if (this._aborted || + this.destroyed || + this.abortController.signal.aborted) + throw error; + const message = error instanceof Error ? error.message : String(error); + throw new Error(`HTTP request failed: ${message}`, { cause: error }); + } if (!res.ok) { let errorText = ''; try { @@ -1592,7 +1719,8 @@ export class SabrStream extends PassThrough { sabrContextUpdate: false, streamProtectionStatus: false }; - this.mediaHeadersProcessed = false; + this.pendingResponseError = null; + const responseStartGeneration = this.mediaProgressGeneration; let activePartial = null; try { while (!this._aborted && !this.destroyed) { @@ -1788,8 +1916,8 @@ export class SabrStream extends PassThrough { }; this.logTraffic(trafficRes); logger('debug', 'SABR', `Traffic <- rn=${rn} status=${res.status} bytes=${responseBytes} parts=${Object.keys(partCounts).length} hasMedia=${saw.media} backoff=${trafficRes.policy?.backoffTimeMs} cookieLen=${trafficRes.policy?.cookieLen}`); - if (saw.media) { - this.mediaHeadersProcessed = true; + const mediaAdvanced = this.mediaProgressGeneration > responseStartGeneration; + if (mediaAdvanced) { this.cachedBufferedRanges = null; this.noMediaStreak = 0; } @@ -1798,9 +1926,21 @@ export class SabrStream extends PassThrough { this.cachedBufferedRanges = null; if (this.noMediaStreak >= 12) { logger('warn', 'SABR', `Stall detected (noMediaStreak=${this.noMediaStreak}). Signaling for re-resolution.`); - this.emit('stall'); + this.queueRecovery('starvation'); this.noMediaStreak = 0; } } + const responseError = this.pendingResponseError; + this.pendingResponseError = null; + const responseErrorType = responseError?.type; + if (responseError && + this.usingTransferredSession && + responseErrorType === 'sabr.media_serving_enforcement_id_error') { + logger('warn', 'SABR', 'Transferred session was rejected by media enforcement. Requesting a fresh session.'); + this.queueRecovery('session'); + } + this.flushPendingRecovery(); + if (responseError && !this.recoveryPending) + throw responseError; } } diff --git a/dist/src/typings/index.types.js b/dist/src/typings/index.types.js index c30d3027..cb0ff5c3 100644 --- a/dist/src/typings/index.types.js +++ b/dist/src/typings/index.types.js @@ -1,14 +1 @@ -/** - * BunSocketWrapper class declaration for type exports - * @public - */ -export class BunSocketWrapper { - ws; - remoteAddress; - send; - ping; - close; - terminate; - _handleMessage; - _handleClose; -} +export {}; diff --git a/dist/src/typings/playback/ducking.types.js b/dist/src/typings/playback/ducking.types.js new file mode 100644 index 00000000..cb0ff5c3 --- /dev/null +++ b/dist/src/typings/playback/ducking.types.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/src/typings/playback/group.types.js b/dist/src/typings/playback/group.types.js new file mode 100644 index 00000000..cb0ff5c3 --- /dev/null +++ b/dist/src/typings/playback/group.types.js @@ -0,0 +1 @@ +export {}; diff --git a/dist/src/typings/sources/bandcamp.types.js b/dist/src/typings/sources/bandcamp.types.js new file mode 100644 index 00000000..c7af0269 --- /dev/null +++ b/dist/src/typings/sources/bandcamp.types.js @@ -0,0 +1,5 @@ +/** + * Type definitions for Bandcamp source payloads. + * @module typings/sources/bandcamp.types + */ +export {}; diff --git a/dist/src/typings/sources/sabr.types.js b/dist/src/typings/sources/sabr.types.js index 81009df8..de5fa07e 100644 --- a/dist/src/typings/sources/sabr.types.js +++ b/dist/src/typings/sources/sabr.types.js @@ -10,4 +10,4 @@ * @packageDocumentation * @module SabrTypes */ -export { base64ToU8, concatenateChunks, FormatId, FormatInitializationMetadata, MediaHeader, NextRequestPolicy, PlaybackStartPolicy, ProtoReader, ProtoWriter, ReloadPlaybackContext, RequestCancellationPolicy, RequestIdentifier, SabrContextSendingPolicy, SabrContextUpdate, SabrError, SabrRedirect, StreamProtectionStatus, UMPPartId, UMPWriter, VideoPlaybackAbrRequest } from "../../sources/youtube/sabr/protor.js"; +export { base64ToU8, concatenateChunks, FormatId, FormatInitializationMetadata, MediaHeader, NextRequestPolicy, PlaybackStartPolicy, ProtoReader, ProtoWriter, ReloadPlaybackContext, RequestCancellationPolicy, RequestIdentifier, SabrContextSendingPolicy, SabrContextUpdate, SabrError, SabrRedirect, StreamProtectionStatus, UMPPartId, UMPWriter, VideoPlaybackAbrRequest } from '../../sources/youtube/sabr/protor.js'; diff --git a/dist/src/utils.js b/dist/src/utils.js index c0f2333a..32a278dc 100644 --- a/dist/src/utils.js +++ b/dist/src/utils.js @@ -10,8 +10,7 @@ import { URL } from 'node:url'; import util from 'node:util'; import zlib from 'node:zlib'; import packageJson from '../package.json' with { type: 'json' }; -import { DEFAULT_MAX_REDIRECTS, DISCORD_ID_REGEX, REDIRECT_STATUS_CODES, SEMVER_PATTERN } from "./constants.js"; -const isBun = typeof process !== "undefined" && process.versions?.bun; +import { DEFAULT_MAX_REDIRECTS, DISCORD_ID_REGEX, REDIRECT_STATUS_CODES, SEMVER_PATTERN } from './constants.js'; /** * Reference to the runtime NodeLink instance stored on the global object. * @@ -124,7 +123,7 @@ function getLogFileName() { * Failures are reported to stderr but do not crash the process. * @internal */ -function cleanOldLogs() { +async function cleanOldLogs() { if (!loggingConfig.file?.enabled) return; const logDir = loggingConfig.file.path || 'logs'; @@ -132,18 +131,23 @@ function cleanOldLogs() { const ttlMs = ttlDays * 24 * 60 * 60 * 1000; const now = Date.now(); try { - if (!fs.existsSync(logDir)) + const fsPromises = await import('node:fs/promises'); + try { + await fsPromises.access(logDir); + } + catch { return; - const files = fs.readdirSync(logDir); + } + const files = await fsPromises.readdir(logDir); let cleanedCount = 0; for (const file of files) { if (!file.startsWith('nodelink-') || !file.endsWith('.log')) continue; const filePath = path.join(logDir, file); - const stats = fs.statSync(filePath); + const stats = await fsPromises.stat(filePath); const fileAge = now - stats.mtimeMs; if (fileAge > ttlMs) { - fs.unlinkSync(filePath); + await fsPromises.unlink(filePath); cleanedCount++; } } @@ -174,9 +178,7 @@ function rotateLogFile() { logStream.end(); logStream = null; } - if (!fs.existsSync(logDir)) { - fs.mkdirSync(logDir, { recursive: true }); - } + fs.mkdirSync(logDir, { recursive: true }); currentLogFile = newLogFilePath; logStream = fs.createWriteStream(currentLogFile, { flags: 'a' }); const gitInfo = getGitInfo(); @@ -498,13 +500,26 @@ function getGitInfo() { if (gitInfoCache) return gitInfoCache; try { - const branch = execSync('git rev-parse --abbrev-ref HEAD', { + const output = execSync('git log -1 --format=%D%n%h%n%ct', { encoding: 'utf8' }).trim(); - const commit = execSync('git rev-parse --short HEAD', { - encoding: 'utf8' - }).trim(); - const commitTime = Number.parseInt(execSync('git log -1 --format=%ct', { encoding: 'utf8' }).trim(), 10) * 1000; + const lines = output.split('\n'); + const refsLine = lines[0] || ''; + const commit = (lines[1] || 'unknown').trim(); + const commitTime = Number.parseInt((lines[2] || '0').trim(), 10) * 1000; + let branch = 'unknown'; + const headMatch = refsLine.match(/HEAD -> ([^,]+)/); + if (headMatch) { + branch = headMatch[1].trim(); + } + else { + try { + branch = execSync('git rev-parse --abbrev-ref HEAD', { + encoding: 'utf8' + }).trim(); + } + catch { } + } gitInfoCache = { branch, commit, @@ -1183,9 +1198,18 @@ async function _internalHttp1Request(urlString, options = {}) { else if (encoding === 'deflate') { finalStream = res.pipe(zlib.createInflate()); } - res.on('error', (err) => reject(new Error(`Response error for ${urlString}: ${err.message}`))); + let cleanupBody; + res.on('error', (err) => { + cleanupBody?.(); + cleanupReq(); + reject(new Error(`Response error for ${urlString}: ${err.message}`)); + }); if (finalStream !== res) { - finalStream.on('error', (err) => reject(new Error(`Decompression error for ${urlString}: ${err.message}`))); + finalStream.on('error', (err) => { + cleanupBody?.(); + cleanupReq(); + reject(new Error(`Decompression error for ${urlString}: ${err.message}`)); + }); } if (streamOnly) { resolve({ @@ -1198,7 +1222,7 @@ async function _internalHttp1Request(urlString, options = {}) { } const chunks = []; let bufferedBytes = 0; - finalStream.on('data', (chunk) => { + const onData = (chunk) => { bufferedBytes += chunk.length; if (bufferedBytes > maxResponseBodyBytes) { ; @@ -1206,10 +1230,11 @@ async function _internalHttp1Request(urlString, options = {}) { return; } chunks.push(chunk); - }); - finalStream.on('end', () => { + }; + const onEnd = () => { try { const responseBuffer = Buffer.concat(chunks); + cleanupBody?.(); if (options.responseType === 'buffer') { resolve({ statusCode, @@ -1238,12 +1263,33 @@ async function _internalHttp1Request(urlString, options = {}) { catch (err) { reject(new Error(`Error processing response body for ${urlString}: ${err instanceof Error ? err.message : String(err)}`)); } - }); + finally { + cleanupBody?.(); + cleanupReq(); + } + }; + cleanupBody = () => { + finalStream.removeListener('data', onData); + finalStream.removeListener('end', onEnd); + chunks.length = 0; + cleanupBody = undefined; + }; + finalStream.on('data', onData); + finalStream.once('end', onEnd); }); - req.on('error', (err) => reject(err)); - req.on('timeout', () => { + const reqErrorHandler = (err) => { + cleanupReq(); + reject(err); + }; + const reqTimeoutHandler = () => { req.destroy(new Error(`Request timed out after ${timeout}ms for ${urlString}`)); - }); + }; + const cleanupReq = () => { + req.removeListener('error', reqErrorHandler); + req.removeListener('timeout', reqTimeoutHandler); + }; + req.on('error', reqErrorHandler); + req.on('timeout', reqTimeoutHandler); if (payloadBuffer) { req.end(payloadBuffer); } @@ -1361,14 +1407,7 @@ async function makeRequest(urlString, options, nodelink) { if (_redirectsFollowed >= maxRedirects) { return Promise.reject(new Error(`Too many redirects (${maxRedirects}) for ${urlString}`)); } - // fall back to HTTP/1 for Bun requests - // Note: bun v1.3.12, crashes with "authority" argument must be a type of string, object or URL. received type Number (825110816) - // Crashes the source worker ^^, could be related to monochrome's request or anything else that uses http/2 - // UPDATE: Bun v1.3.13 has fixed this crash, since it was released today as this commit, i will be checking the version but can be removed later. - if (isBun && process.versions.bun.localeCompare('1.3.13', undefined, { numeric: true }) < 0) { - return http1makeRequest(urlString, options); - } - if (options.proxy) { + if (options.network?.proxy) { return http1makeRequest(urlString, options); } const localAddress = finalNodeLink?.routePlanner?.getIP?.() ?? undefined; @@ -1599,6 +1638,164 @@ async function makeRequest(urlString, options, nodelink) { } }); } +/** + * Checks for updates of core dependencies against the NPM registry. + * + * Logs a warning if an update is available for critical packages. + * @public + */ +/** + * Checks for updates of core dependencies against the NPM registry and GitHub. + * + * Logs a warning if an update is available for critical packages. + * @param credentialManager - Persistence manager to rate-limit checks. + * @public + */ +async function checkDependencyUpdates(credentialManager) { + const coreDeps = [ + '@performanc/voice', + '@performanc/pwsl-server', + '@toddynnn/symphonia-decoder', + '@toddynnn/voice-opus', + '@ecliptia/faad2-wasm', + '@alexanderolsen/libsamplerate-js', + '@ecliptia/seekable-stream', + 'mp4box' + ]; + const localVersions = []; + for (const dep of coreDeps) { + try { + const depPath = path.join(process.cwd(), 'node_modules', dep, 'package.json'); + const version = JSON.parse(fs.readFileSync(depPath, 'utf8')).version; + localVersions.push({ name: dep, version }); + } + catch { + // Ignore if package not found + } + } + if (localVersions.length > 0) { + logger('info', 'Server', `Installed core packages: ${localVersions.map((v) => `${v.name}@${v.version}`).join(', ')}`); + } + const CHECK_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes + const now = Date.now(); + let latestVersions = {}; + let isCacheValid = false; + if (credentialManager) { + const cache = credentialManager.get('runtime.dependencies.latest'); + if (cache && now - cache.ts < CHECK_INTERVAL_MS) { + latestVersions = cache.versions; + isCacheValid = true; + } + } + if (!isCacheValid) { + const controller = new AbortController(); + const timeout = setTimeout(() => controller.abort(), 5000); + try { + const deps = packageJson + .dependencies || {}; + await Promise.all(coreDeps.map(async (dep) => { + try { + const declaredVersion = deps[dep] || ''; + let latestVersionStr = ''; + let source = 'NPM'; + if (declaredVersion.startsWith('github:') || + (declaredVersion.includes('/') && !declaredVersion.includes(':'))) { + source = 'GitHub'; + const repo = declaredVersion.replace('github:', '').split('#')[0]; + const branch = declaredVersion.split('#')[1] || 'main'; + const response = await fetch(`https://raw.githubusercontent.com/${repo}/${branch}/package.json`, { signal: controller.signal }); + if (response.ok) { + const data = (await response.json()); + latestVersionStr = data.version; + } + } + else if (!declaredVersion.includes(':') && + !declaredVersion.includes('/')) { + const response = await fetch(`https://registry.npmjs.org/${dep}/latest`, { + signal: controller.signal + }); + if (response.ok) { + const data = (await response.json()); + latestVersionStr = data.version; + } + } + if (latestVersionStr) { + latestVersions[dep] = { version: latestVersionStr, source }; + } + } + catch { + // Ignore individual failures + } + })); + if (credentialManager && Object.keys(latestVersions).length > 0) { + credentialManager.set('runtime.dependencies.latest', { ts: now, versions: latestVersions }, 24 * 60 * 60 * 1000); + } + } + catch (error) { + logger('debug', 'Server', `Failed to check dependency updates: ${error instanceof Error ? error.message : String(error)}`); + } + finally { + clearTimeout(timeout); + } + } + const updates = []; + for (const local of localVersions) { + const latest = latestVersions[local.name]; + if (!latest || local.version === latest.version) + continue; + const currentSemver = parseSemver(local.version); + const latestSemver = parseSemver(latest.version); + if (currentSemver && latestSemver) { + const isNewer = latestSemver.major > currentSemver.major || + (latestSemver.major === currentSemver.major && + latestSemver.minor > currentSemver.minor) || + (latestSemver.major === currentSemver.major && + latestSemver.minor === currentSemver.minor && + latestSemver.patch > currentSemver.patch); + if (isNewer) { + updates.push({ + name: local.name, + current: local.version, + latest: latest.version, + source: latest.source + }); + } + } + } + if (updates.length > 0) { + logger('warn', 'Server', 'The following core dependencies have updates available and will be automatically updated:'); + for (const update of updates) { + logger('warn', 'Server', ` - ${update.name}: ${update.current} -> \x1b[1m\x1b[32m${update.latest}\x1b[0m (${update.source})`); + } + try { + logger('info', 'Server', `Running automatic update for core packages...`); + // pnpm and bun can be on the same path, so we check both + // (referring to myself, im lazy to delete the pnpm lock file) + const isBun = process.versions.bun && + fs.existsSync(path.resolve(process.cwd(), 'bun.lock')); + const isPnpm = fs.existsSync(path.resolve(process.cwd(), 'pnpm-lock.yaml')) && !isBun; + const cmd = isPnpm ? 'pnpm update' : isBun ? 'bun update' : 'npm update'; + execSync(cmd, { stdio: 'inherit' }); + logger('info', 'Server', 'Dependencies updated successfully. Restarting process to apply changes...'); + const { spawn } = await import('node:child_process'); + const child = spawn(process.argv[0], process.argv.slice(1), { + stdio: 'inherit', + env: process.env + }); + child.on('exit', (code) => { + process.exit(code ?? 0); + }); + // Halt execution of the parent process forever while the child runs + await new Promise(() => { }); + } + catch (error) { + logger('error', 'Server', `Failed to auto-update dependencies: ${error instanceof Error ? error.message : String(error)}`); + } + } + else if (Object.keys(latestVersions).length > 0) { + logger('info', 'Server', 'All core packages are up to date.'); + } +} /** * Checks for git updates against the upstream branch. * @@ -1608,16 +1805,23 @@ async function makeRequest(urlString, options, nodelink) { async function checkForUpdates() { logger('info', 'Git', 'Checking for updates...'); try { - execSync('git fetch', { stdio: 'ignore' }); - const local = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim(); - const remote = execSync('git rev-parse @{u}', { encoding: 'utf8' }).trim(); - if (local !== remote) { - const behind = execSync('git rev-list --right-only --count HEAD...@{u}', { + const { exec } = await import('node:child_process'); + const util = await import('node:util'); + const execAsync = util.promisify(exec); + await execAsync('git fetch', { stdio: 'ignore' }); + const { stdout: local } = await execAsync('git rev-parse HEAD', { + encoding: 'utf8' + }); + const { stdout: remote } = await execAsync('git rev-parse @{u}', { + encoding: 'utf8' + }); + if (local.trim() !== remote.trim()) { + const { stdout: behind } = await execAsync('git rev-list --right-only --count HEAD...@{u}', { encoding: 'utf8' - }).trim(); - const remoteCommit = execSync('git log -1 --pretty=format:"%h - %s (%cr)" @{u}', { encoding: 'utf8' }).trim(); - logger('warn', 'Git', `Your version is ${behind} commits behind the remote.`); - logger('warn', 'Git', `Latest commit: ${remoteCommit}`); + }); + const { stdout: remoteCommit } = await execAsync('git log -1 --pretty=format:"%h - %s (%cr)" @{u}', { encoding: 'utf8' }); + logger('warn', 'Git', `Your version is ${behind.trim()} commits behind the remote.`); + logger('warn', 'Git', `Latest commit: ${remoteCommit.trim()}`); logger('warn', 'Git', 'Please run "git pull" to update.'); } else { @@ -1744,7 +1948,7 @@ function applyEnvOverrides(config, prefix = 'NODELINK') { * @returns Best matching candidate or null. * @public */ -function getBestMatch(list, original, options = {}) { +export function getBestMatch(list, original, options = {}) { const { durationTolerance = 0.15, allowExplicit = true } = options; const normalize = (str) => { if (!str) @@ -1904,13 +2108,13 @@ async function fetchSponsorBlockSegments(videoId, categories, actionTypes, apiBa } logger('debug', 'SponsorBlock', `Successfully loaded ${videoMatch.segments.length} segments for video ${videoId} in ${duration}ms`); return videoMatch.segments.map((s) => ({ - uuid: s.UUID, - start: Math.round(s.segment[0] * 1000), - end: Math.round(s.segment[1] * 1000), + uuid: s.uuid, + start: Math.round(s.start * 1000), + end: Math.round(s.end * 1000), category: s.category, actionType: s.actionType, votes: s.votes, - locked: s.locked === 1, + locked: s.locked, videoDuration: Math.round(s.videoDuration * 1000), description: s.description || '' })); @@ -1920,4 +2124,4 @@ async function fetchSponsorBlockSegments(videoId, categories, actionTypes, apiBa return []; } } -export { applyEnvOverrides, checkForUpdates, cleanupHttpAgents, cleanupLogger, decodeTrack, encodeTrack, fetchSponsorBlockSegments, generateRandomLetters, getBestMatch, getGitInfo, getStats, getVersion, http1makeRequest, initLogger, logger, makeRequest, parseClient, parseSemver, sendErrorResponse, sendResponse, validateProperty, verifyDiscordID, verifyMethod }; +export { applyEnvOverrides, checkDependencyUpdates, checkForUpdates, cleanupHttpAgents, cleanupLogger, decodeTrack, encodeTrack, fetchSponsorBlockSegments, generateRandomLetters, getGitInfo, getStats, getVersion, http1makeRequest, initLogger, logger, makeRequest, parseClient, parseSemver, sendErrorResponse, sendResponse, validateProperty, verifyDiscordID, verifyMethod }; diff --git a/dist/src/voice/voiceRelay.js b/dist/src/voice/voiceRelay.js index 86cb6203..dbd19646 100644 --- a/dist/src/voice/voiceRelay.js +++ b/dist/src/voice/voiceRelay.js @@ -1,12 +1,12 @@ import { Buffer } from 'node:buffer'; -import { buildVoiceFrame, resolveVoiceFormat, VOICE_FORMATS, VOICE_FRAME_OPS } from "./voiceFrames.js"; +import { buildVoiceFrame, resolveVoiceFormat, VOICE_FORMATS, VOICE_FRAME_OPS } from './voiceFrames.js'; const EMPTY_BUFFER = Buffer.alloc(0); let voiceRuntimePromise = null; const getVoiceRuntime = async () => { if (!voiceRuntimePromise) { voiceRuntimePromise = Promise.all([ import('@performanc/voice'), - import("../playback/opus/Opus.js") + import('../playback/opus/Opus.js') ]).then(([discordVoiceModule, opusModule]) => ({ discordVoice: discordVoiceModule.default, OpusDecoder: opusModule.Decoder @@ -133,16 +133,32 @@ export function createVoiceRelay({ enabled, format, sendFrame, logger }) { if (!conn || conn._voiceRelayAttached) return; conn._voiceRelayAttached = true; - conn.on('speakStart', (userId, ssrc) => { + const speakStartHandler = (userId, ssrc) => { void handleSpeakStart(guildId, userId, ssrc).catch((err) => { if (logger) { logger('warn', 'Voice', `Failed to initialize voice relay stream: ${err.message}`); } }); - }); - conn.on('speakEnd', (userId, ssrc) => { + }; + const speakEndHandler = (userId, ssrc) => { handleSpeakStop(guildId, userId, ssrc); - }); + }; + conn._voiceRelaySpeakStart = speakStartHandler; + conn._voiceRelaySpeakEnd = speakEndHandler; + conn.on('speakStart', speakStartHandler); + conn.on('speakEnd', speakEndHandler); + }; + const detach = (connection) => { + const conn = connection; + if (!conn._voiceRelayAttached) + return; + if (conn._voiceRelaySpeakStart) { + conn.removeListener('speakStart', conn._voiceRelaySpeakStart); + } + if (conn._voiceRelaySpeakEnd) { + conn.removeListener('speakEnd', conn._voiceRelaySpeakEnd); + } + conn._voiceRelayAttached = false; }; - return { attach }; + return { attach, detach }; } diff --git a/dist/src/workers/main.js b/dist/src/workers/main.js index 77e0d616..646ff6ca 100644 --- a/dist/src/workers/main.js +++ b/dist/src/workers/main.js @@ -15,30 +15,31 @@ import { resolve as resolvePath } from 'node:path'; import { monitorEventLoopDelay } from 'node:perf_hooks'; import { pathToFileURL } from 'node:url'; import v8 from 'node:v8'; -import { GatewayEvents } from "../constants.js"; -import ConnectionManager from "../managers/connectionManager.js"; -import CredentialManager from "../managers/credentialManager.js"; -import PluginManager from "../managers/pluginManager.js"; -import RoutePlannerManager from "../managers/routePlannerManager.js"; -import SourceManager from "../managers/sourceManager.js"; -import StatsManager from "../managers/statsManager.js"; -import TrackCacheManager from "../managers/trackCacheManager.js"; -import { getWebmOpusProfilerStats } from "../playback/demuxers/WebmOpus.js"; -import { bufferPool } from "../playback/structs/BufferPool.js"; -import { applyEnvOverrides, cleanupHttpAgents, initLogger, logger } from "../utils.js"; -import { createVoiceRelay } from "../voice/voiceRelay.js"; -import { createHeadQueue, dequeueHeadQueue, enqueueHeadQueue, getHeadQueueLength } from "./headQueue.js"; +import { GatewayEvents } from '../constants.js'; +import ConnectionManager from '../managers/connectionManager.js'; +import CredentialManager from '../managers/credentialManager.js'; +import PluginManager from '../managers/pluginManager.js'; +import RoutePlannerManager from '../managers/routePlannerManager.js'; +import SourceManager from '../managers/sourceManager.js'; +import StatsManager from '../managers/statsManager.js'; +import TrackCacheManager from '../managers/trackCacheManager.js'; +import { migrateConfig } from '../modules/config/configMigration.js'; +import { getWebmOpusProfilerStats } from '../playback/demuxers/WebmOpus.js'; +import { bufferPool } from '../playback/structs/BufferPool.js'; +import { applyEnvOverrides, cleanupHttpAgents, initLogger, logger } from '../utils.js'; +import { createVoiceRelay } from '../voice/voiceRelay.js'; +import { createHeadQueue, dequeueHeadQueue, enqueueHeadQueue, getHeadQueueLength } from './headQueue.js'; let playerClassPromise = null; let createPCMStreamPromise = null; const getPlayerClass = async () => { if (!playerClassPromise) { - playerClassPromise = import("../playback/player.js").then((module) => module.Player); + playerClassPromise = import('../playback/player.js').then((module) => module.Player); } return playerClassPromise; }; const getCreatePCMStream = async () => { if (!createPCMStreamPromise) { - createPCMStreamPromise = import("../playback/processing/streamProcessor.js").then((module) => module.createPCMStream); + createPCMStreamPromise = import('../playback/processing/streamProcessor.js').then((module) => module.createPCMStream); } return createPCMStreamPromise; }; @@ -57,14 +58,42 @@ try { catch (_e) { } let config; const resolveRootConfigUrl = (fileName) => pathToFileURL(resolvePath(process.cwd(), fileName)).href; -try { - config = (await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.js')))) - .default; -} -catch { - config = (await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.default.js')))) - .default; -} +const resolveConfigExport = (importedModule, fileName) => { + const candidate = importedModule.default ?? + importedModule.config; + if (candidate && + typeof candidate === 'object' && + Object.keys(candidate).length > 0) { + return candidate; + } + throw new Error(`[ERROR] Config: ${fileName} must export a non-empty configuration object (default export or named "config").`); +}; +const loadConfig = async () => { + const candidates = [ + 'config.ts', + 'config.js', + 'config.default.ts', + 'config.default.js' + ]; + for (const fileName of candidates) { + try { + const module = await import(__rewriteRelativeImportExtension(resolveRootConfigUrl(fileName))); + const raw = resolveConfigExport(module, fileName); + return migrateConfig(raw); + } + catch (error) { + const err = error; + const isNotFound = err.code === 'ERR_MODULE_NOT_FOUND' || + err.code === 'ENOENT' || + err.message?.includes('Cannot find module'); + if (isNotFound) + continue; + throw error; + } + } + throw new Error('[ERROR] Config: Failed to load configuration (config.ts/config.js/config.default.ts/config.default.js).'); +}; +config = await loadConfig(); applyEnvOverrides(config); const HIBERNATION_ENABLED = config.cluster?.hibernation?.enabled !== false; const HIBERNATION_TIMEOUT = config.cluster?.hibernation?.timeoutMs || 20 * 60 * 1000; @@ -745,7 +774,8 @@ const sendProcessMessage = (payload, onError) => { return false; } }; -const { EVENT_SOCKET_PATH, COMMAND_SOCKET_PATH, NODE_UNIQUE_ID } = process.env; +const { EVENT_SOCKET_PATH, COMMAND_SOCKET_PATH, WORKER_CLUSTER_ID } = process.env; +let WORKER_CLUSTER_ID_OVERRIDE = ''; let eventSocket = null; let eventSocketPath = EVENT_SOCKET_PATH; let eventReconnectTimer = null; @@ -809,12 +839,32 @@ const handleSocketDisconnect = (socketType, socket) => { notifySocketDisconnected(socketType); scheduleReconnect(socketType); }; +const sendEventHello = () => { + if (!eventSocket || eventSocket.destroyed) + return false; + const payload = v8.serialize({ pid: process.pid }); + const header = Buffer.alloc(6); + header.writeUInt8(0, 0); + header.writeUInt8(0, 1); + header.writeUInt32BE(payload.length, 2); + try { + eventSocket.cork(); + const okHeader = eventSocket.write(header); + const okPayload = eventSocket.write(payload); + eventSocket.uncork(); + return okHeader && okPayload; + } + catch { + return false; + } +}; const connectEventSocket = () => { if (!eventSocketPath) return; const socket = net.createConnection(eventSocketPath, () => { eventSocket = socket; clearReconnectTimer('event'); + sendEventHello(); logger('info', 'Worker', 'Connected to Master event socket'); }); socket.on('error', () => { @@ -1045,7 +1095,7 @@ let lyricsManagerPromise = null; let meaningManagerPromise = null; const getLyricsManager = async () => { if (!lyricsManagerPromise) { - lyricsManagerPromise = import("../managers/lyricsManager.js").then(async (module) => { + lyricsManagerPromise = import('../managers/lyricsManager.js').then(async (module) => { const manager = new module.default(nodelink); await manager.loadFolder(); nodelink.lyrics = manager; @@ -1056,7 +1106,7 @@ const getLyricsManager = async () => { }; const getMeaningManager = async () => { if (!meaningManagerPromise) { - meaningManagerPromise = import("../managers/meaningManager.js").then(async (module) => { + meaningManagerPromise = import('../managers/meaningManager.js').then(async (module) => { const manager = new module.default(nodelink); await manager.loadFolder(); nodelink.meanings = manager; @@ -1110,8 +1160,8 @@ const nodelink = { getMeaningManager }; const createdVoiceRelay = createVoiceRelay({ - enabled: config.voiceReceive?.enabled, - format: config.voiceReceive?.format, + enabled: config.playback.voiceReceive?.enabled, + format: config.playback.voiceReceive?.format, sendFrame: (frame) => sendEventBinaryFrame(8, frame), logger }); @@ -1147,13 +1197,13 @@ function startTimers(hibernating = false) { clearInterval(statsUpdateTimer); const updateInterval = hibernating ? 60000 - : (config?.playerUpdateInterval ?? 5000); + : (config?.playback.playerUpdateInterval ?? 5000); const statsInterval = hibernating ? 120000 - : config?.metrics?.enabled + : config?.api.metrics?.enabled ? 5000 - : (config?.statsUpdateInterval ?? 30000); - const zombieThreshold = config?.zombieThresholdMs ?? 60000; + : (config?.playback.statsUpdateInterval ?? 30000); + const zombieThreshold = config?.playback.zombieThresholdMs ?? 60000; playerUpdateTimer = setInterval(() => { if (!process.connected) return; @@ -1244,7 +1294,7 @@ function startTimers(hibernating = false) { lastCpuUsage = process.cpuUsage(); const nodelinkLoad = elapsedMs > 0 ? (cpuUsage.user + cpuUsage.system) / 1000 / elapsedMs : 0; const mem = process.memoryUsage(); - const workerIdEnv = NODE_UNIQUE_ID; + const resolvedClusterId = WORKER_CLUSTER_ID_OVERRIDE || WORKER_CLUSTER_ID; const eluP50 = hndl.percentile(50) / 1e6; const eluP95 = hndl.percentile(95) / 1e6; const eluP99 = hndl.percentile(99) / 1e6; @@ -1258,7 +1308,7 @@ function startTimers(hibernating = false) { } } const stats = { - workerId: parseInt(workerIdEnv ?? '0', 10) + 1, + workerId: resolvedClusterId ? parseInt(resolvedClusterId, 10) : 0, isHibernating, players: localPlayers, playingPlayers: localPlayingPlayers, @@ -1772,6 +1822,10 @@ process.on('message', (msg) => { if (message.type) { ipcMessageTracker.trackReceived(message.type, message); } + if (message.type === 'clusterId') { + WORKER_CLUSTER_ID_OVERRIDE = String(message.clusterId ?? ''); + return; + } if (message.type === 'ping') { if (process.connected) { try { diff --git a/dist/src/workers/source.js b/dist/src/workers/source.js index eb695cbe..35fe7289 100644 --- a/dist/src/workers/source.js +++ b/dist/src/workers/source.js @@ -15,8 +15,9 @@ import { resolve as resolvePath } from 'node:path'; import { fileURLToPath, pathToFileURL } from 'node:url'; import v8 from 'node:v8'; import { isMainThread, parentPort, workerData as rawWorkerData, Worker } from 'node:worker_threads'; -import * as utils from "../utils.js"; -import { createHeadQueue, dequeueHeadQueue, enqueueHeadQueue, getHeadQueueLength } from "./headQueue.js"; +import { migrateConfig } from '../modules/config/configMigration.js'; +import * as utils from '../utils.js'; +import { createHeadQueue, dequeueHeadQueue, enqueueHeadQueue, getHeadQueueLength } from './headQueue.js'; const __filename = fileURLToPath(import.meta.url); const getActiveResourcesBreakdown = () => { const list = typeof process.getActiveResourcesInfo === 'function' @@ -59,12 +60,39 @@ if (isMainThread) { * @internal */ async function loadConfig() { - try { - return (await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.js')))).default; - } - catch { - return (await import(__rewriteRelativeImportExtension(resolveRootConfigUrl('config.default.js')))).default; + const resolveConfigExport = (importedModule, fileName) => { + const candidate = importedModule.default ?? + importedModule.config; + if (candidate && + typeof candidate === 'object' && + Object.keys(candidate).length > 0) { + return candidate; + } + throw new Error(`[ERROR] Config: ${fileName} must export a non-empty configuration object (default export or named "config").`); + }; + const candidates = [ + 'config.ts', + 'config.js', + 'config.default.ts', + 'config.default.js' + ]; + for (const fileName of candidates) { + try { + const module = await import(__rewriteRelativeImportExtension(resolveRootConfigUrl(fileName))); + const raw = resolveConfigExport(module, fileName); + return migrateConfig(raw); + } + catch (error) { + const err = error; + const isNotFound = err.code === 'ERR_MODULE_NOT_FOUND' || + err.code === 'ENOENT' || + err.message?.includes('Cannot find module'); + if (isNotFound) + continue; + throw error; + } } + throw new Error('[ERROR] Config: Failed to load configuration (config.ts/config.js/config.default.ts/config.default.js).'); } const config = await loadConfig(); utils.applyEnvOverrides(config); @@ -79,7 +107,7 @@ if (isMainThread) { logger: utils.logger, pluginManager: null }; - const { default: PluginManagerClass } = await import("../managers/pluginManager.js"); + const { default: PluginManagerClass } = await import('../managers/pluginManager.js'); nodelink.pluginManager = new PluginManagerClass(nodelink); await nodelink.pluginManager.load('source-worker'); const maxThreadCount = Math.max(1, specConfig.microWorkers ?? Math.min(2, os.cpus().length)); @@ -439,7 +467,7 @@ else { logger: utils.logger, pluginManager: null }; - const { default: PluginManagerClass } = await import("../managers/pluginManager.js"); + const { default: PluginManagerClass } = await import('../managers/pluginManager.js'); nodelink.pluginManager = new PluginManagerClass(nodelink); await nodelink.pluginManager.load('micro-worker'); /** @@ -447,12 +475,12 @@ else { * @internal */ const [{ createPCMStream, createSeekeableAudioResource }, { default: SourceManager }, { default: CredentialManager }, { default: TrackCacheManager }, { default: RoutePlannerManager }, { default: StatsManager }] = await Promise.all([ - import("../playback/processing/streamProcessor.js"), - import("../managers/sourceManager.js"), - import("../managers/credentialManager.js"), - import("../managers/trackCacheManager.js"), - import("../managers/routePlannerManager.js"), - import("../managers/statsManager.js") + import('../playback/processing/streamProcessor.js'), + import('../managers/sourceManager.js'), + import('../managers/credentialManager.js'), + import('../managers/trackCacheManager.js'), + import('../managers/routePlannerManager.js'), + import('../managers/statsManager.js') ]); nodelink.statsManager = new StatsManager(nodelink); nodelink.credentialManager = new CredentialManager(nodelink); @@ -466,7 +494,7 @@ else { let meaningManagerPromise = null; const getLyricsManager = async () => { if (!lyricsManagerPromise) { - lyricsManagerPromise = import("../managers/lyricsManager.js").then(async (module) => { + lyricsManagerPromise = import('../managers/lyricsManager.js').then(async (module) => { const manager = new module.default(nodelink); await manager.loadFolder(); nodelink.lyrics = manager; @@ -477,7 +505,7 @@ else { }; const getMeaningManager = async () => { if (!meaningManagerPromise) { - meaningManagerPromise = import("../managers/meaningManager.js").then(async (module) => { + meaningManagerPromise = import('../managers/meaningManager.js').then(async (module) => { const manager = new module.default(nodelink); await manager.loadFolder(); nodelink.meanings = manager; diff --git a/package.json b/package.json index 62f78aa3..f7193799 100644 --- a/package.json +++ b/package.json @@ -1,10 +1,10 @@ { "name": "nodelink", - "version": "3.8.0-dev.20260422.1", + "version": "3.8.1-dev.20260801.1", "scripts": { "build": "tsc --incremental false", - "start": "node --dns-result-order=ipv4first --import tsx src/index.ts", - "start:experimental": "node --experimental-transform-types --dns-result-order=ipv4first src/index.ts", + "start": "node -e \"const v=process.versions.node.split('.').map(Number); const t=(v[0]===22&&v[1]>=6)||v[0]>=23; require('child_process').spawnSync('node', ['--dns-result-order=ipv4first', ...(t?['--experimental-strip-types','src/index.ts']:['dist/src/index.js']), ...process.argv.slice(1)], {stdio:'inherit'})\" --", + "start:experimental": "node --dns-result-order=ipv4first src/index.ts", "start:dist": "node --dns-result-order=ipv4first dist/src/index.js", "start:bun": "bun run --dns-result-order=ipv4first src/index.ts", "type-check": "tsc --noEmit", @@ -21,24 +21,21 @@ "@ecliptia/seekable-stream": "github:1Lucas1apk/seekable-stream", "@performanc/pwsl-server": "github:performanc/internals#PWSL-server", "@performanc/voice": "github:PerformanC/voice", - "@toddynnn/symphonia-decoder": "1.0.6", + "@toddynnn/symphonia-decoder": "1.1.0", "@toddynnn/voice-opus": "^1.0.1", "fastest-validator": "^1.19.1", - "jsdom": "^29.0.2", - "mp4box": "^2.3.0", + "mp4box": "^2.4.1", "prom-client": "^15.1.3", - "proxy-agent": "^8.0.1" + "proxy-agent": "^8.0.2" }, "devDependencies": { - "@biomejs/biome": "^2.4.12", - "@commitlint/cli": "20.5.0", - "@commitlint/config-conventional": "20.5.0", - "@types/bun": "^1.3.12", - "@types/jsdom": "^28.0.1", - "@types/node": "^25.6.0", + "@biomejs/biome": "^2.5.0", + "@commitlint/cli": "21.0.2", + "@commitlint/config-conventional": "21.0.2", + "@types/bun": "^1.3.14", + "@types/node": "^26.0.0", "dotenv": "^17.4.2", "husky": "9.1.7", - "tsx": "^4.21.0", - "typescript": "^6.0.3" + "typescript": "^7.0.2" } } diff --git a/src/api/index.ts b/src/api/index.ts index ccd8b4a8..7545f3a7 100644 --- a/src/api/index.ts +++ b/src/api/index.ts @@ -111,10 +111,10 @@ async function loadRoutes(): Promise { } else if (routeName.includes('.')) { const parts = routeName.split('.') const basePattern = parts - .map((part) => (part === 'id' ? '(?:id|[A-Za-z0-9]+)' : part)) + .map((part) => (part === 'id' ? '(?:id|[A-Za-z0-9_-]+)' : part)) .join('/') pathname = new RegExp( - `^/${PATH_VERSION}/${basePattern}(?:/[A-Za-z0-9]+)?/?$` + `^/${PATH_VERSION}/${basePattern}(?:/[A-Za-z0-9_-]+)?/?$` ) } else { pathname = `/${PATH_VERSION}/${routeName}` @@ -224,7 +224,7 @@ async function requestHandler( parsedUrl.pathname === `/${PATH_VERSION}/profiler/ui` || parsedUrl.pathname === `/${PATH_VERSION}/profiler/file` if (isMetricsEndpoint) { - const metricsConfig = nodelink.options.metrics || {} + const metricsConfig = nodelink.options.api.metrics || {} if (!metricsConfig.enabled) { logger( 'warn', diff --git a/src/api/info.ts b/src/api/info.ts index dd8d05e4..33875710 100644 --- a/src/api/info.ts +++ b/src/api/info.ts @@ -388,7 +388,7 @@ async function buildInfoResponse( }, isNodelink: true, sourceManagers: await getSourceManagers(nodelink), - filters: getEnabledFilterNames(nodelink.options.filters?.enabled), + filters: getEnabledFilterNames(nodelink.options.playback.filters?.enabled), plugins: getPlugins(nodelink.pluginManager) } } diff --git a/src/api/loadChapters.ts b/src/api/loadChapters.ts index c781d861..9fb2d1c8 100644 --- a/src/api/loadChapters.ts +++ b/src/api/loadChapters.ts @@ -147,7 +147,7 @@ function getLoadChaptersRuntime( if ( runtime.sourceWorkerManager === undefined || runtime.workerManager === undefined || - !runtime.sources + runtime.sources === undefined ) { return null } diff --git a/src/api/loadStream.ts b/src/api/loadStream.ts index a17ed92b..28920fb5 100644 --- a/src/api/loadStream.ts +++ b/src/api/loadStream.ts @@ -434,7 +434,7 @@ function getStreamProcessorModule(): Promise { if (!streamProcessorModulePromise) { streamProcessorModulePromise = import( '../playback/processing/streamProcessor.ts' - ) as Promise + ) as unknown as Promise } return streamProcessorModulePromise @@ -706,7 +706,7 @@ async function handler( return } - if (!runtime.options.enableLoadStreamEndpoint) { + if (!runtime.options.api.enableLoadStreamEndpoint) { sendErrorResponse( req, res, @@ -832,7 +832,7 @@ async function handler( input.filters, { streamInfo: urlResult, - loudnessNormalizer: runtime.options.audio?.loudnessNormalizer + loudnessNormalizer: runtime.options.playback.audio?.loudnessNormalizer }, input.volume / 100, null, @@ -895,7 +895,7 @@ async function handler( input.volume / 100, null, true, - runtime.options.audio?.loudnessNormalizer + runtime.options.playback.audio?.loudnessNormalizer ) as StreamingAudioResource pcmStream = resource.stream diff --git a/src/api/loadTracks.ts b/src/api/loadTracks.ts index 3c485836..a738c730 100644 --- a/src/api/loadTracks.ts +++ b/src/api/loadTracks.ts @@ -99,6 +99,13 @@ function parseIdentifier( if (groups.source === 'search') { return { kind: 'unifiedSearch', query: groups.query } } + if (groups.source.toLowerCase() === 'isrc') { + return { + kind: 'search', + source: normalizeDefaultSearchSource(defaultSearchSource), + query: groups.query + } + } return { kind: 'search', source: groups.source, query: groups.query } } @@ -190,7 +197,7 @@ async function handler( const target = parseIdentifier( identifier, - nodelink.options.defaultSearchSource + nodelink.options.search.defaultSource ) const workerRequest = buildWorkerRequest(target) const runtime = nodelink as LoadTracksRuntime diff --git a/src/api/profiler.ts b/src/api/profiler.ts index ba9688d7..a21b3f31 100644 --- a/src/api/profiler.ts +++ b/src/api/profiler.ts @@ -1704,8 +1704,8 @@ async function runWorkerProfilerCommand( ): Promise { const timeoutMs = getTimeoutForAction(action) const commandPayload = { - action, - ...(payload ?? {}) + ...(payload ?? {}), + action } const settled = await Promise.allSettled( @@ -1818,7 +1818,7 @@ async function collectActionSnapshot( } else { output.sourceWorkers = await sourceManager.executeAll( 'profilerCommand', - { action, ...safePayload }, + { ...safePayload, action }, { timeoutMs: getTimeoutForAction(action), parseJson: true } ) } diff --git a/src/api/profiler.ui.ts b/src/api/profiler.ui.ts index 61e7f9fb..d7ccdf3c 100644 --- a/src/api/profiler.ui.ts +++ b/src/api/profiler.ui.ts @@ -131,6 +131,7 @@ function buildPage(code: string): string {
    Trace Buffer
    0
    network + events
    Players Active
    0
    across workers
    Heap Pressure
    0.0%
    heapUsed/heapTotal
    +
    V8 Internal
    0 MB
    v8 gap
    @@ -648,7 +649,18 @@ function buildPage(code: string): string { const safeRss = Math.max(rss, 1) const heapReservedFree = Math.max(0, allocated - used) - const trackedNative = Math.max(0, Math.max(external, arrayBuffers)) + const trackedNative = Math.max(0, external + arrayBuffers) + + // V8 heap spaces sum + let v8HeapTotal = 0 + for (const p of procs) { + const spaces = p?.heapSpaces || p?.runtime?.heapSpaces || [] + for (const s of spaces) { + v8HeapTotal += Number(s?.spaceSize || 0) + } + } + const v8Internal = Math.max(0, allocated - v8HeapTotal) + const unattributed = Math.max(0, rss - used - heapReservedFree - trackedNative) const usedPct = Math.max(0, Math.min(100, (used / safeRss) * 100)) @@ -693,6 +705,9 @@ function buildPage(code: string): string { if (memHeroMachineOtherMetric) memHeroMachineOtherMetric.textContent = fmtBytes(machineOtherAbs) + ' · ' + machineOtherPct.toFixed(1) + '%' if (memHeroMachineFreeMetric) memHeroMachineFreeMetric.textContent = fmtBytes(machineFree) + ' · ' + machineFreePct.toFixed(1) + '%' + const v8InternalEl = document.getElementById('v8Internal') + if (v8InternalEl) v8InternalEl.textContent = fmtBytes(v8Internal) + ' · ' + ((v8Internal / Math.max(rss, 1)) * 100).toFixed(1) + '%' + const masterRss = Number(snapshot?.master?.memory?.rss || 0) let workersRss = 0 for (const w of (snapshot?.workers || [])) workersRss += Number(w?.response?.memory?.rss || 0) diff --git a/src/api/sessions.id.groups.ts b/src/api/sessions.id.groups.ts new file mode 100644 index 00000000..e0f381b9 --- /dev/null +++ b/src/api/sessions.id.groups.ts @@ -0,0 +1,854 @@ +import type { + ApiNodelinkServer, + ApiRequest, + ApiResponse, + ApiRouteModule, + ApiSendResponse +} from '../typings/api/api.types.ts' +import type { Session } from '../typings/index.types.ts' +import type { + FadingConfig, + FiltersState, + PlayerStateJSON, + PlayerTrack, + PlayerVoiceState, + PlayPayload, + TrackInfoExtended +} from '../typings/playback/player.types.ts' +import type { GroupStateJSON } from '../typings/playback/group.types.ts' +import type { EncodedTrackPayload } from '../typings/utils.types.ts' +import type GroupManager from '../managers/groupManager.ts' +import { decodeTrack, logger, sendErrorResponse } from '../utils.ts' + + + + + +/** + * Track payload accepted by the group update route. + */ +interface PlayerTrackUpdateInput { + encoded?: string | null + identifier?: string + userData?: PlayerTrack['userData'] + audioTrackId?: string | null + language?: string | null +} + +/** + * Body payload for POST /sessions/:id/groups (create). + */ +interface GroupCreatePayload { + id: string + guildIds?: string[] +} + +/** + * Body payload for PATCH /sessions/:id/groups/:groupId. + */ +interface GroupPatchPayload { + /** Add or remove guild IDs from the group. */ + players?: { + add?: string[] + remove?: string[] + } + + /** Track to play on all group members. */ + track?: PlayerTrackUpdateInput + + /** Seek position in ms. */ + position?: number + + /** End time in ms. */ + endTime?: number | null + + /** Volume (0–1000). */ + volume?: number + + /** Pause toggle. */ + paused?: boolean + + /** Filters payload. */ + filters?: FiltersState + + /** Fading configuration. */ + fading?: ApiRequest['body'] + + /** Loudness normalizer toggle. */ + loudnessNormalizer?: boolean + + /** Auto-ducking toggle. */ + ducking?: boolean +} + +/** + * Response for group operations that may partially fail. + */ +interface GroupPatchResponse extends GroupStateJSON { + errors?: Array<{ guildId: string; error: string }> + players?: PlayerStateJSON[] +} + + + + + +interface SessionPlayerEntry { + guildId: string +} + +interface GroupsRoutePlayerManager { + players: Map + create: ( + guildId: string, + voice?: Partial + ) => Promise + destroy: (guildId: string) => Promise + play: ( + guildId: string, + trackPayload: PlayPayload + ) => Promise + stop: (guildId: string) => Promise + pause: (guildId: string, shouldPause: boolean) => Promise + seek: ( + guildId: string, + position?: number, + endTime?: number + ) => Promise + volume: (guildId: string, level: number) => Promise + setFilters: ( + guildId: string, + filtersPayload: FiltersState + ) => Promise + setFading: ( + guildId: string, + fadingConfig?: FadingConfig + ) => Promise + setLoudnessNormalizer: ( + guildId: string, + enabled: boolean + ) => Promise + setDucking: ( + guildId: string, + enabled: boolean + ) => Promise + toJSON: (guildId: string) => Promise +} + +type GroupsRouteSession = Omit & { + players: GroupsRoutePlayerManager + groups: GroupManager +} + +interface LoadedTrackResult { + loadType: 'track' | 'empty' | string + data: { + encoded: string + info: TrackInfoExtended + } +} + +interface GroupsRouteRuntime extends ApiNodelinkServer { + sessions: { + get: (id: string) => GroupsRouteSession | undefined + } + loadTrack?: (identifier: string) => Promise +} + +interface GroupsRoutePathParams { + sessionId: string + groupId?: string +} + + + + + +interface FadingSectionInput { + duration?: number + curve?: string + type?: string +} + +interface FadingConfigInput { + enabled?: boolean + trackStart?: FadingSectionInput + trackEnd?: FadingSectionInput + trackStop?: FadingSectionInput + seek?: FadingSectionInput + pause?: FadingSectionInput + resume?: FadingSectionInput + ducking?: { + enabled?: boolean + duration?: number + targetVolume?: number + curve?: string + } +} + + + + + +function isObjectRecord( + value: ApiRequest['body'] +): value is Record< + string, + object | string | number | boolean | null | undefined +> { + return Boolean(value) && typeof value === 'object' && !Array.isArray(value) +} + +function getGroupsRouteRuntime( + nodelink: ApiNodelinkServer +): GroupsRouteRuntime | null { + const runtime = nodelink as ApiNodelinkServer & Partial + + if ( + !runtime.sessions || + typeof runtime.sessions.get !== 'function' + ) { + return null + } + + return runtime as GroupsRouteRuntime +} + +function getPathParams(parsedUrl: URL): GroupsRoutePathParams | null { + const parts = parsedUrl.pathname.split('/') + const sessionId = parts[3] + const groupId = parts[5] + + if (!sessionId) { + return null + } + + return groupId && groupId !== '' + ? { sessionId, groupId } + : { sessionId } +} + +function normalizeTrackInfo( + decodedTrack: EncodedTrackPayload +): TrackInfoExtended { + return { + ...decodedTrack.info, + uri: decodedTrack.info.uri ?? '', + artworkUrl: decodedTrack.info.artworkUrl ?? null, + isrc: decodedTrack.info.isrc ?? null + } +} + +function getAudioTrackId( + trackPayload: PlayerTrackUpdateInput +): string | undefined { + return trackPayload.language ?? trackPayload.audioTrackId ?? undefined +} + +async function resolvePlayPayload( + nodelink: GroupsRouteRuntime, + trackPayload: PlayerTrackUpdateInput | undefined +): Promise { + if (!trackPayload) { + return undefined + } + + if (trackPayload.encoded !== undefined) { + if (trackPayload.encoded === null) { + return null + } + + const decodedTrack = decodeTrack(trackPayload.encoded.replace(/ /g, '+')) + return { + encoded: decodedTrack.encoded, + info: normalizeTrackInfo(decodedTrack), + audioTrackId: getAudioTrackId(trackPayload) + } + } + + if (trackPayload.identifier) { + if (!nodelink.loadTrack) { + throw new Error('Track identifier loading is not supported.') + } + + const loadResult = await nodelink.loadTrack(trackPayload.identifier) + if (loadResult.loadType !== 'track') { + if (loadResult.loadType === 'empty') { + throw new Error('Track identifier resolved to no tracks.') + } + + throw new Error( + `Track identifier resolved to ${loadResult.loadType}, expected 'track'.` + ) + } + + return { + encoded: loadResult.data.encoded, + info: loadResult.data.info, + audioTrackId: getAudioTrackId(trackPayload) + } + } + + return undefined +} + +function sanitizeFadingConfig(raw: ApiRequest['body']): FadingConfig { + const safe: FadingConfig = { + enabled: false, + trackStart: { duration: 0, curve: 'linear', type: 'volume' }, + trackEnd: { duration: 0, curve: 'linear', type: 'volume' }, + trackStop: { duration: 0, curve: 'linear', type: 'volume' }, + seek: { duration: 0, curve: 'linear', type: 'volume' }, + pause: { duration: 0, curve: 'linear', type: 'volume' }, + resume: { duration: 0, curve: 'linear', type: 'volume' } + } + + if (!isObjectRecord(raw)) { + return safe + } + + const payload = raw as FadingConfigInput + safe.enabled = payload.enabled === true + + const updateSection = ( + key: keyof Pick< + NonNullable, + 'trackStart' | 'trackEnd' | 'trackStop' | 'seek' | 'pause' | 'resume' + > + ): void => { + const section = payload[key] + const target = safe[key] + if (!isObjectRecord(section) || !target) { + return + } + + const typedSection = section as FadingSectionInput + const { duration, curve, type } = typedSection + if (typeof duration === 'number' && Number.isFinite(duration)) { + target.duration = Math.max(0, duration) + } + + if (typeof curve === 'string') { + target.curve = curve + } + + if ( + type === 'volume' || + type === 'tape' || + type === 'scratch' || + type === 'both' + ) { + target.type = type + } + } + + updateSection('trackStart') + updateSection('trackEnd') + updateSection('trackStop') + updateSection('seek') + updateSection('pause') + updateSection('resume') + + if (isObjectRecord(payload.ducking)) { + const duckingInput = payload.ducking as NonNullable + safe.ducking = { + enabled: duckingInput.enabled === true, + duration: + typeof duckingInput.duration === 'number' && Number.isFinite(duckingInput.duration) + ? Math.max(0, duckingInput.duration) + : 500, + targetVolume: + typeof duckingInput.targetVolume === 'number' && Number.isFinite(duckingInput.targetVolume) + ? Math.max(0, Math.min(1, duckingInput.targetVolume)) + : 0.3, + curve: typeof duckingInput.curve === 'string' ? duckingInput.curve : 'linear' + } + } + + return safe +} + + + + + +function getGroupCreatePayload( + body: ApiRequest['body'] +): GroupCreatePayload | null { + if (!isObjectRecord(body)) return null + + const payload = body as Record + const id = payload.id + if (typeof id !== 'string' || id.length === 0) return null + + const guildIds = payload.guildIds + if (guildIds !== undefined) { + if (!Array.isArray(guildIds)) return null + for (const gid of guildIds) { + if (typeof gid !== 'string' || !/^\d{17,20}$/.test(gid)) return null + } + } + + return { + id: id as string, + guildIds: (guildIds as string[] | undefined) ?? [] + } +} + +function getGroupPatchPayload( + body: ApiRequest['body'] +): GroupPatchPayload | null { + if (!isObjectRecord(body)) return null + + const payload = body as Record + const result: GroupPatchPayload = {} + + + if (payload.players !== undefined) { + if (!isObjectRecord(payload.players)) return null + const p = payload.players as Record + const players: GroupPatchPayload['players'] = {} + + if (p.add !== undefined) { + if (!Array.isArray(p.add)) return null + for (const gid of p.add) { + if (typeof gid !== 'string' || !/^\d{17,20}$/.test(gid)) return null + } + players.add = p.add as string[] + } + + if (p.remove !== undefined) { + if (!Array.isArray(p.remove)) return null + for (const gid of p.remove) { + if (typeof gid !== 'string') return null + } + players.remove = p.remove as string[] + } + + result.players = players + } + + + if (payload.track !== undefined) { + if (payload.track !== null && !isObjectRecord(payload.track)) return null + result.track = payload.track as PlayerTrackUpdateInput + } + + + if (payload.position !== undefined) { + if ( + typeof payload.position !== 'number' || + !Number.isFinite(payload.position) || + payload.position < 0 + ) + return null + result.position = payload.position + } + + + if (payload.endTime !== undefined) { + if ( + payload.endTime !== null && + (typeof payload.endTime !== 'number' || + !Number.isFinite(payload.endTime) || + payload.endTime < 0) + ) + return null + result.endTime = payload.endTime as number | null + } + + + if (payload.volume !== undefined) { + if ( + typeof payload.volume !== 'number' || + !Number.isFinite(payload.volume) || + payload.volume < 0 || + payload.volume > 1000 + ) + return null + result.volume = payload.volume + } + + + if (payload.paused !== undefined) { + if (typeof payload.paused !== 'boolean') return null + result.paused = payload.paused + } + + + if (payload.filters !== undefined) { + if ( + !payload.filters || + typeof payload.filters !== 'object' || + Array.isArray(payload.filters) + ) + return null + result.filters = payload.filters as FiltersState + } + + + if (payload.fading !== undefined) { + if ( + !payload.fading || + typeof payload.fading !== 'object' || + Array.isArray(payload.fading) + ) + return null + result.fading = payload.fading + } + + + if (payload.loudnessNormalizer !== undefined) { + if (typeof payload.loudnessNormalizer !== 'boolean') return null + result.loudnessNormalizer = payload.loudnessNormalizer + } + + + if (payload.ducking !== undefined) { + if (typeof payload.ducking !== 'boolean') return null + result.ducking = payload.ducking + } + + return result +} + + + + + +async function applyGroupPatch( + runtime: GroupsRouteRuntime, + session: GroupsRouteSession, + groupId: string, + payload: GroupPatchPayload +): Promise { + const groups = session.groups + + if (!groups.has(groupId)) { + throw new Error(`Group '${groupId}' not found`) + } + + if (payload.players?.add) { + for (const guildId of payload.players.add) { + groups.addPlayer(groupId, guildId) + } + } + if (payload.players?.remove) { + for (const guildId of payload.players.remove) { + groups.removePlayer(groupId, guildId) + } + } + + const guildIds = groups.getGuildIds(groupId) + + let trackToPlay: PlayPayload | null | undefined = undefined + if (payload.track !== undefined) { + trackToPlay = await resolvePlayPayload(runtime, payload.track) + } + + const errors: Array<{ guildId: string; error: string }> = [] + const playerStates: PlayerStateJSON[] = [] + + for (const guildId of guildIds) { + try { + await session.players.create(guildId) + + if (trackToPlay === null) { + await session.players.stop(guildId) + } else if (trackToPlay) { + await session.players.play(guildId, { + ...trackToPlay, + userData: payload.track?.userData, + startTime: payload.position, + endTime: payload.endTime ?? undefined + }) + } + + if (payload.volume !== undefined) { + await session.players.volume(guildId, payload.volume) + } + + if (payload.paused !== undefined) { + await session.players.pause(guildId, payload.paused) + } + + if (payload.position !== undefined && trackToPlay === undefined) { + await session.players.seek(guildId, payload.position) + } + + if (payload.endTime !== undefined && trackToPlay === undefined) { + const playerState = await session.players.toJSON(guildId) + await session.players.seek( + guildId, + playerState.state.position, + payload.endTime ?? undefined + ) + } + + if (payload.filters !== undefined) { + await session.players.setFilters(guildId, payload.filters) + } + + if (payload.fading !== undefined) { + await session.players.setFading( + guildId, + sanitizeFadingConfig(payload.fading) + ) + } + + if (payload.loudnessNormalizer !== undefined) { + await session.players.setLoudnessNormalizer( + guildId, + payload.loudnessNormalizer + ) + } + + if (payload.ducking !== undefined) { + await session.players.setDucking(guildId, payload.ducking) + } + + const state = await session.players.toJSON(guildId) + playerStates.push(state) + + await new Promise(resolve => setTimeout(resolve, 35)) + } catch (err) { + const message = err instanceof Error ? err.message : String(err) + logger( + 'error', + 'GroupUpdate', + `Failed to apply patch to guild ${guildId} in group '${groupId}': ${message}` + ) + errors.push({ guildId, error: message }) + } + } + + const groupJson = groups.toJSON(groupId)! + + return { + ...groupJson, + players: playerStates, + ...(errors.length > 0 ? { errors } : {}) + } +} + + + + + +/** + * Handles requests for the groups route. + * + * Supports: + * - `GET /sessions/:id/groups` — list all groups + * - `GET /sessions/:id/groups/:groupId` — get specific group + * - `POST /sessions/:id/groups` — create a new group + * - `PATCH /sessions/:id/groups/:groupId` — update group (membership + orchestration) + * - `DELETE /sessions/:id/groups/:groupId` — delete group (does not destroy players) + */ +async function handler( + nodelink: ApiNodelinkServer, + req: ApiRequest, + res: ApiResponse, + sendResponse: ApiSendResponse, + parsedUrl: URL +): Promise { + const runtime = getGroupsRouteRuntime(nodelink) + if (!runtime) { + sendErrorResponse( + req, + res, + 500, + 'Internal Server Error', + 'Groups runtime contract is incomplete.', + parsedUrl.pathname, + true + ) + return + } + + const pathParams = getPathParams(parsedUrl) + if (!pathParams) { + sendErrorResponse( + req, + res, + 400, + 'Bad Request', + 'Invalid path parameters', + parsedUrl.pathname + ) + return + } + + const session = runtime.sessions.get(pathParams.sessionId) + if (!session) { + sendErrorResponse( + req, + res, + 404, + 'Not Found', + "The provided sessionId doesn't exist.", + parsedUrl.pathname + ) + return + } + + try { + + if (!pathParams.groupId) { + if (req.method === 'GET') { + sendResponse(req, res, session.groups.list(), 200) + return + } + + if (req.method === 'POST') { + const payload = getGroupCreatePayload(req.body) + if (!payload) { + sendErrorResponse( + req, + res, + 400, + 'Bad Request', + 'Invalid group creation payload. Required: { id: string, guildIds?: string[] }', + parsedUrl.pathname + ) + return + } + + session.groups.create(payload.id, payload.guildIds) + sendResponse(req, res, session.groups.toJSON(payload.id), 201) + return + } + + sendErrorResponse( + req, + res, + 405, + 'Method Not Allowed', + 'Method Not Allowed', + parsedUrl.pathname + ) + return + } + + + if (req.method === 'GET') { + const group = session.groups.toJSON(pathParams.groupId) + if (!group) { + sendErrorResponse( + req, + res, + 404, + 'Not Found', + `Group '${pathParams.groupId}' not found.`, + parsedUrl.pathname + ) + return + } + sendResponse(req, res, group, 200) + return + } + + if (req.method === 'DELETE') { + if (!session.groups.has(pathParams.groupId)) { + sendErrorResponse( + req, + res, + 404, + 'Not Found', + `Group '${pathParams.groupId}' not found.`, + parsedUrl.pathname + ) + return + } + session.groups.delete(pathParams.groupId) + sendResponse(req, res, null, 204) + return + } + + if (req.method === 'PATCH') { + if (!session.groups.has(pathParams.groupId)) { + sendErrorResponse( + req, + res, + 404, + 'Not Found', + `Group '${pathParams.groupId}' not found.`, + parsedUrl.pathname + ) + return + } + + const payload = getGroupPatchPayload(req.body) + if (!payload) { + sendErrorResponse( + req, + res, + 400, + 'Bad Request', + 'Invalid group patch payload.', + parsedUrl.pathname + ) + return + } + + const result = await applyGroupPatch( + runtime, + session, + pathParams.groupId, + payload + ) + sendResponse(req, res, result, 200) + return + } + } catch (error) { + const errorMessage = + error instanceof Error ? error.message : 'Unhandled group error' + + if ( + errorMessage.includes('not found') || + errorMessage.includes('already exists') + ) { + const status = errorMessage.includes('already exists') ? 409 : 404 + sendErrorResponse( + req, + res, + status, + status === 409 ? 'Conflict' : 'Not Found', + errorMessage, + parsedUrl.pathname + ) + return + } + + logger('error', 'GroupUpdate', `Unhandled error: ${errorMessage}`, error) + sendErrorResponse( + req, + res, + 500, + 'Internal Server Error', + errorMessage, + parsedUrl.pathname, + true + ) + return + } + + sendErrorResponse( + req, + res, + 405, + 'Method Not Allowed', + 'Method Not Allowed', + parsedUrl.pathname + ) +} + +/** + * Route module definition for the groups route. + */ +const groupsRoute: ApiRouteModule = { + handler, + methods: ['GET', 'POST', 'PATCH', 'DELETE'] +} + +export default groupsRoute diff --git a/src/api/sessions.id.players.id.mix.ts b/src/api/sessions.id.players.id.mix.ts index 5dc8dad8..bd7b572d 100644 --- a/src/api/sessions.id.players.id.mix.ts +++ b/src/api/sessions.id.players.id.mix.ts @@ -395,7 +395,7 @@ async function handleCreateMix( return } - const mixConfig = runtime.options.mix ?? { + const mixConfig = runtime.options.playback.mix ?? { enabled: true, defaultVolume: 0.8, maxLayersMix: 5, diff --git a/src/api/sessions.id.players.id.sponsorblock.ts b/src/api/sessions.id.players.id.sponsorblock.ts index 90ce6947..0f37c20c 100644 --- a/src/api/sessions.id.players.id.sponsorblock.ts +++ b/src/api/sessions.id.players.id.sponsorblock.ts @@ -1,3 +1,4 @@ +import type { PlayerCommandResponse } from '../managers/playerManager.ts' import type { ApiNodelinkServer, ApiRequest, @@ -10,7 +11,7 @@ import type { PlayerSponsorBlockState, SponsorBlockSegment } from '../typings/playback/player.types.ts' -import { logger, sendErrorResponse } from '../utils.ts' +import { sendErrorResponse } from '../utils.ts' /** * Minimal player manager contract required by the SponsorBlock route. @@ -19,15 +20,19 @@ interface SponsorBlockPlayerManager { /** * Returns current SponsorBlock state for a player. */ - getSponsorBlock: (guildId: string) => PlayerSponsorBlockState + getSponsorBlock: ( + guildId: string + ) => Promise /** * Updates SponsorBlock settings for a player. */ updateSponsorBlock: ( guildId: string, - updates: Partial> - ) => void + updates: Partial< + Omit + > + ) => Promise /** * Overrides SponsorBlock segments for a player. @@ -35,12 +40,14 @@ interface SponsorBlockPlayerManager { setSponsorBlockSegments: ( guildId: string, segments: SponsorBlockSegment[] - ) => void + ) => Promise /** * Clears SponsorBlock state for a player. */ - clearSponsorBlock: (guildId: string) => void + clearSponsorBlock: ( + guildId: string + ) => Promise } /** @@ -154,7 +161,7 @@ async function handleGetSponsorBlock( } try { - const state = session.players.getSponsorBlock(pathParams.guildId) + const state = await session.players.getSponsorBlock(pathParams.guildId) sendResponse(req, res, state, 200) } catch (error) { const errorMessage = @@ -175,26 +182,62 @@ async function handlePatchSponsorBlock( ): Promise { const session = runtime.sessions.get(pathParams.sessionId) if (!session) { - sendErrorResponse(req, res, 404, 'Not Found', "The provided sessionId doesn't exist.", req.url || '') + sendErrorResponse( + req, + res, + 404, + 'Not Found', + "The provided sessionId doesn't exist.", + req.url || '' + ) return } const body = req.body as Partial if (!body || typeof body !== 'object' || Array.isArray(body)) { - sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid body', req.url || '') + sendErrorResponse( + req, + res, + 400, + 'Bad Request', + 'Invalid body', + req.url || '' + ) return } try { - session.players.updateSponsorBlock(pathParams.guildId, { - enabled: body.enabled, - categories: body.categories, - actionTypes: body.actionTypes, - skipMarginMs: body.skipMarginMs - }) - sendResponse(req, res, session.players.getSponsorBlock(pathParams.guildId), 200) + const result = await session.players.updateSponsorBlock( + pathParams.guildId, + { + enabled: body.enabled, + categories: body.categories, + actionTypes: body.actionTypes, + skipMarginMs: body.skipMarginMs + } + ) + + if (result && 'status' in result && result.status !== 200) { + sendErrorResponse( + req, + res, + (result.status as number) || 500, + 'Internal Server Error', + result.message || 'Operation failed', + req.url || '' + ) + return + } + + sendResponse( + req, + res, + await session.players.getSponsorBlock(pathParams.guildId), + 200 + ) } catch (error) { - const errorMessage = error instanceof Error ? error.message : 'Player not found' + const errorMessage = + error instanceof Error ? error.message : 'Player not found' sendErrorResponse(req, res, 404, 'Not Found', errorMessage, req.url || '') } } @@ -211,21 +254,57 @@ async function handlePostSponsorBlock( ): Promise { const session = runtime.sessions.get(pathParams.sessionId) if (!session) { - sendErrorResponse(req, res, 404, 'Not Found', "The provided sessionId doesn't exist.", req.url || '') + sendErrorResponse( + req, + res, + 404, + 'Not Found', + "The provided sessionId doesn't exist.", + req.url || '' + ) return } const body = req.body as { segments: SponsorBlockSegment[] } if (!body?.segments || !Array.isArray(body.segments)) { - sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid segments array', req.url || '') + sendErrorResponse( + req, + res, + 400, + 'Bad Request', + 'Invalid segments array', + req.url || '' + ) return } try { - session.players.setSponsorBlockSegments(pathParams.guildId, body.segments) - sendResponse(req, res, session.players.getSponsorBlock(pathParams.guildId), 200) + const result = await session.players.setSponsorBlockSegments( + pathParams.guildId, + body.segments + ) + + if (result && 'status' in result && result.status !== 200) { + sendErrorResponse( + req, + res, + (result.status as number) || 500, + 'Internal Server Error', + result.message || 'Operation failed', + req.url || '' + ) + return + } + + sendResponse( + req, + res, + await session.players.getSponsorBlock(pathParams.guildId), + 200 + ) } catch (error) { - const errorMessage = error instanceof Error ? error.message : 'Player not found' + const errorMessage = + error instanceof Error ? error.message : 'Player not found' sendErrorResponse(req, res, 404, 'Not Found', errorMessage, req.url || '') } } @@ -241,16 +320,24 @@ async function handleDeleteSponsorBlock( ): Promise { const session = runtime.sessions.get(pathParams.sessionId) if (!session) { - sendErrorResponse(req, res, 404, 'Not Found', "The provided sessionId doesn't exist.", req.url || '') + sendErrorResponse( + req, + res, + 404, + 'Not Found', + "The provided sessionId doesn't exist.", + req.url || '' + ) return } try { - session.players.clearSponsorBlock(pathParams.guildId) + await session.players.clearSponsorBlock(pathParams.guildId) res.writeHead(204) res.end() } catch (error) { - const errorMessage = error instanceof Error ? error.message : 'Player not found' + const errorMessage = + error instanceof Error ? error.message : 'Player not found' sendErrorResponse(req, res, 404, 'Not Found', errorMessage, req.url || '') } } @@ -267,13 +354,29 @@ async function handler( ): Promise { const runtime = getSponsorBlockRuntime(nodelink) if (!runtime) { - sendErrorResponse(req, res, 500, 'Internal Server Error', 'SponsorBlock runtime contract is incomplete.', parsedUrl.pathname, true) + sendErrorResponse( + req, + res, + 500, + 'Internal Server Error', + 'SponsorBlock runtime contract is incomplete.', + parsedUrl.pathname, + true + ) return } const pathParams = getPathParams(parsedUrl) if (!pathParams) { - sendErrorResponse(req, res, 400, 'Bad Request', 'Invalid path parameters', parsedUrl.pathname, true) + sendErrorResponse( + req, + res, + 400, + 'Bad Request', + 'Invalid path parameters', + parsedUrl.pathname, + true + ) return } @@ -297,7 +400,14 @@ async function handler( return } - sendErrorResponse(req, res, 405, 'Method Not Allowed', 'Method Not Allowed', parsedUrl.pathname) + sendErrorResponse( + req, + res, + 405, + 'Method Not Allowed', + 'Method Not Allowed', + parsedUrl.pathname + ) } const sponsorBlockRoute: ApiRouteModule = { diff --git a/src/api/sessions.id.players.ts b/src/api/sessions.id.players.ts index a34e2b4f..f781595d 100644 --- a/src/api/sessions.id.players.ts +++ b/src/api/sessions.id.players.ts @@ -97,6 +97,11 @@ interface PlayerPatchPayload { */ loudnessNormalizer?: boolean + /** + * Auto-ducking toggle (lowers music when users speak). + */ + ducking?: boolean + /** * Optional filter payload. */ @@ -217,6 +222,11 @@ interface PlayerPatchBodyInput { */ loudnessNormalizer?: boolean + /** + * Candidate auto-ducking toggle. + */ + ducking?: boolean + /** * Candidate filters payload. */ @@ -271,6 +281,16 @@ interface FadingConfigInput { seek?: FadingSectionInput pause?: FadingSectionInput resume?: FadingSectionInput + + /** + * Candidate ducking configuration. + */ + ducking?: { + enabled?: boolean + duration?: number + targetVolume?: number + curve?: string + } } /** @@ -455,6 +475,18 @@ interface PlayersRoutePlayerManager { enabled: boolean ) => Promise + /** + * Toggles auto-ducking. + * + * @param guildId - Target guild identifier. + * @param enabled - Whether auto-ducking should be enabled. + * @returns Promise resolving once the command is applied. + */ + setDucking: ( + guildId: string, + enabled: boolean + ) => Promise + /** * Updates voice state. * @@ -819,6 +851,11 @@ function getPlayerPatchPayload( return null } + const ducking = payload.ducking + if (ducking !== undefined && typeof ducking !== 'boolean') { + return null + } + const filtersValue = payload.filters if ( filtersValue !== undefined && @@ -867,6 +904,7 @@ function getPlayerPatchPayload( volume, paused, loudnessNormalizer, + ducking, filters: filtersValue as FiltersState | undefined, fading, voice: voice ?? undefined @@ -936,6 +974,22 @@ function sanitizeFadingConfig(raw: ApiRequest['body']): FadingConfig { updateSection('pause') updateSection('resume') + if (isObjectRecord(payload.ducking)) { + const duckingInput = payload.ducking as NonNullable + safe.ducking = { + enabled: duckingInput.enabled === true, + duration: + typeof duckingInput.duration === 'number' && Number.isFinite(duckingInput.duration) + ? Math.max(0, duckingInput.duration) + : 500, + targetVolume: + typeof duckingInput.targetVolume === 'number' && Number.isFinite(duckingInput.targetVolume) + ? Math.max(0, Math.min(1, duckingInput.targetVolume)) + : 0.3, + curve: typeof duckingInput.curve === 'string' ? duckingInput.curve : 'linear' + } + } + return safe } @@ -1232,6 +1286,10 @@ async function applyPlayerPatch( ) } + if (payload.ducking !== undefined) { + await session.players.setDucking(guildId, payload.ducking) + } + return await session.players.toJSON(guildId) } diff --git a/src/api/trackstream.ts b/src/api/trackstream.ts index 94642851..e59bdaf1 100644 --- a/src/api/trackstream.ts +++ b/src/api/trackstream.ts @@ -180,7 +180,7 @@ async function handler( sendResponse: ApiSendResponse, parsedUrl: URL ): Promise { - if (!nodelink.options.enableTrackStreamEndpoint) { + if (!nodelink.options.api.enableTrackStreamEndpoint) { sendErrorResponse( req, res, diff --git a/src/constants.ts b/src/constants.ts index 79086393..e04e02b4 100644 --- a/src/constants.ts +++ b/src/constants.ts @@ -316,6 +316,8 @@ export const SupportedFormats = { WAV: 'wav', /** Flash Video container format */ FLV: 'flv', + /** Apple Lossless Audio Codec */ + ALAC: 'alac', /** Unknown or unsupported audio format */ UNKNOWN: 'unknown' } as const @@ -441,6 +443,8 @@ export function normalizeFormat( if (!type) return SupportedFormats.UNKNOWN const lowerType = type.toLowerCase() + if (lowerType.includes('alac')) return SupportedFormats.ALAC + if ( lowerType.includes('opus') || lowerType.includes('webm') || diff --git a/src/index.ts b/src/index.ts index b39d32ca..fe0d45d1 100644 --- a/src/index.ts +++ b/src/index.ts @@ -4,12 +4,18 @@ import http from 'node:http' import { resolve as resolvePath } from 'node:path' import { pathToFileURL } from 'node:url' import WebSocketServer from '@performanc/pwsl-server' - +import type ProxyManager from './managers/proxyManager.ts' import RoutePlannerManager from './managers/routePlannerManager.ts' import SessionManager from './managers/sessionManager.ts' import StatsManager from './managers/statsManager.ts' +import { + migrateConfig, + persistConfig +} from './modules/config/configMigration.ts' +import { cleanupBunServer, createBunServer } from './server/bunServer.ts' import { applyEnvOverrides, + checkDependencyUpdates, checkForUpdates, cleanupHttpAgents, cleanupLogger, @@ -23,7 +29,6 @@ import { verifyDiscordID } from './utils.ts' import 'dotenv/config' -import type { ServerWebSocket } from 'bun' import { GatewayEvents, MINIMUM_NODE_VERSION } from './constants.ts' import ConfigValidationManager from './managers/configValidationManager.ts' import type ConnectionManager from './managers/connectionManager.ts' @@ -38,14 +43,15 @@ import type SourceWorkerManager from './managers/sourceWorkerManager.ts' import type TrackCacheManager from './managers/trackCacheManager.ts' import type WorkerManager from './managers/workerManager.ts' import type { ApiMiddlewareExtension } from './typings/api/api.types.ts' -import type { NodelinkConfig } from './typings/config/config.types.ts' +import type { + JsonValue, + NodelinkConfig +} from './typings/config/config.types.ts' import type { AudioInterceptorExtension, - BunSocketData, ConfigLoadError, FilterExtension, GitInfo, - IBunSocketWrapper, NodelinkServer as INodelinkServer, NodelinkExtensions, NodelinkServerType, @@ -55,7 +61,6 @@ import type { PlayerInterceptorExtension, PlayerManagerConstructor, RequestShim, - ResponseShim, RouteExtension, SessionSocket, SourceExtension, @@ -63,7 +68,7 @@ import type { VoiceRelay, WebSocketInterceptorExtension } from './typings/index.types.ts' -import type { ClientInfo, IPCMessage, ReqShim } from './typings/shared.types.ts' +import type { ClientInfo, IPCMessage } from './typings/shared.types.ts' import { parseVoiceFrameHeader } from './voice/voiceFrames.ts' import { createVoiceRelay } from './voice/voiceRelay.ts' @@ -73,9 +78,11 @@ type ProfilerApiModule = typeof import('./api/profiler.ts') let profilerApiPromise: Promise | null = null const isRuntimeAtLeast = (current: string, minimum: string): boolean => - current.replace(/^v/, '').localeCompare(minimum.replace(/^v/, ''), undefined, { - numeric: true - }) >= 0 + current + .replace(/^v/, '') + .localeCompare(minimum.replace(/^v/, ''), undefined, { + numeric: true + }) >= 0 type NodeLtsCacheEntry = { version: string @@ -85,7 +92,8 @@ type NodeLtsCacheEntry = { const NODE_LTS_CREDENTIAL_KEY = 'runtime.node.latestLts' const NODE_LTS_CREDENTIAL_TTL_MS = 24 * 60 * 60 * 1000 const NODE_LTS_MEMORY_TTL_MS = 10 * 60 * 1000 -let latestNodeLtsCache: { value: string | null; expiresAt: number } | null = null +let latestNodeLtsCache: { value: string | null; expiresAt: number } | null = + null const getLatestNodeLtsVersion = async ( credentialManager: CredentialManager | null @@ -285,34 +293,136 @@ const getTrackCacheManagerClass = async (): Promise< } let config: NodelinkConfig -const resolveRootConfigUrl = (fileName: string): string => - pathToFileURL(resolvePath(process.cwd(), fileName)).href - -try { - config = (await import(resolveRootConfigUrl('config.js'))) - .default as unknown as NodelinkConfig -} catch (e) { - const error = e as ConfigLoadError - if (error.code === 'ERR_MODULE_NOT_FOUND' || error.code === 'ENOENT') { + +const loadConfig = async (): Promise => { + const resolveRootConfigUrl = (fileName: string): string => + pathToFileURL(resolvePath(process.cwd(), fileName)).href + const resolveConfigExport = ( + importedModule: Record, + fileName: string + ): Record => { + const candidate = + ( + importedModule as { + default?: unknown + config?: unknown + } + ).default ?? + ( + importedModule as { + default?: unknown + config?: unknown + } + ).config + + if ( + candidate && + typeof candidate === 'object' && + Object.keys(candidate as Record).length > 0 + ) { + return candidate as Record + } + + throw new Error( + `[ERROR] Config: ${fileName} must export a non-empty configuration object (default export or named "config").` + ) + } + + /** + * Loads and merges configuration files. + * Prioritizes config.ts/js, falls back to config.default.ts/js. + * @returns Migrated and merged configuration object. + */ + const loadAndMerge = async (): Promise => { + // 1. Load defaults (Mandatory) + let baseConfig: Record = {} + let defaultFileName = 'config.default.ts' try { - config = (await import(resolveRootConfigUrl('config.default.js'))) - .default as unknown as NodelinkConfig - console.log( - '[WARN] Config: config.js not found, using config.default.js. It is recommended to create a config.js file for your own configuration.' - ) - } catch (e2) { - console.error( - '[ERROR] Config: Failed to load config.default.js. Please make sure it exists.' + const module = await import(resolveRootConfigUrl('config.default.ts')) + baseConfig = resolveConfigExport( + module as Record, + 'config.default.ts' ) - throw e2 + } catch { + try { + const module = await import(resolveRootConfigUrl('config.default.js')) + baseConfig = resolveConfigExport( + module as Record, + 'config.default.js' + ) + defaultFileName = 'config.default.js' + } catch { + throw new Error( + '[ERROR] Config: Base configuration (config.default.ts/js) not found.' + ) + } + } + + // 2. Try to load user configuration + let userConfig: Record = {} + let userFileName: string | null = null + const userCandidates = ['config.ts', 'config.js'] + + for (const fileName of userCandidates) { + try { + const module = await import(resolveRootConfigUrl(fileName)) + userConfig = resolveConfigExport( + module as Record, + fileName + ) + userFileName = fileName + console.log(`[INFO] Config: Loaded user configuration from ${fileName}`) + break + } catch (e) { + const error = e as ConfigLoadError + const isNotFound = + error.code === 'ERR_MODULE_NOT_FOUND' || + error.code === 'ENOENT' || + error.message?.includes('Cannot find module') + if (isNotFound) continue + throw e + } + } + + if (!userFileName) { + console.log(`[INFO] Config: No user configuration found. Using defaults.`) } - } else { - throw e + + // 3. Merge user config over defaults + // We do a deep merge for 'sources', 'lyrics', 'meanings', 'pluginConfig' + // and a shallow merge for the rest to keep it simple but functional. + const merged = { ...baseConfig } + for (const [key, value] of Object.entries(userConfig)) { + if ( + value && + typeof value === 'object' && + !Array.isArray(value) && + baseConfig[key] && + typeof baseConfig[key] === 'object' && + !Array.isArray(baseConfig[key]) + ) { + merged[key] = { + ...(baseConfig[key] as Record), + ...(value as Record) + } + } else { + merged[key] = value + } + } + + const migrated = migrateConfig(merged as Record) + await persistConfig(migrated, userFileName ?? defaultFileName) + + return migrated as unknown as NodelinkConfig } + + return await loadAndMerge() } +config = await loadConfig() + // Apply environment variable overrides after config is loaded -applyEnvOverrides(config) +applyEnvOverrides(config as unknown as Record) const clusterEnabled = // biome-ignore lint/complexity/useLiteralKeys: TypeScript requires index signature access @@ -337,6 +447,22 @@ initLogger( const isBun = typeof Bun !== 'undefined' if (!cluster.isWorker) { + const supportGuidelines = `\x1b[35m +╭──────────────────────────────────────────────────────────────────────────────╮ +│ SUPPORT GUIDELINES │ +│ │ +│ 1. Turn on debugging in config.ts before asking for help. │ +│ 2. Test the 'dev' branch (git checkout dev) to ensure it's not fixed yet. │ +│ 3. If providing logs, start copying EXACTLY from this box onwards. │ +│ 4. Cut logs or missing Node.js version will result in an ignored ticket. │ +│ 5. FAQ and Rules: https://discord.gg/bVz6ppZ3SP │ +│ https://discord.gg/z4ayqfeBdB │ +╰──────────────────────────────────────────────────────────────────────────────╯\x1b[0m + + * +` + process.stdout.write(supportGuidelines) + const ascii = ` ▄ ████▄ ██▄ ▄███▄ █ ▄█ ▄ █ █▀ █ █ █ █ █ █▀ ▀ █ ██ █ █▄█ @@ -344,115 +470,24 @@ if (!cluster.isWorker) { █ █ █ ▀████ █ █ █▄ ▄▀ ███▄ ▐█ █ █ █ █ █ v${getVersion()} █ █ █ ███▀ ▀███▀ ▀ ▐ █ █ █ █ Powered by PerformanC; █ ██ █ ██ ▀ rewritten by 1Lucas1.apk; + maintained by 1Lucas1.apk & ToddyTheNoobDud ` process.stdout.write(`\x1b[32m${ascii}\x1b[0m\n`) -} - -await checkForUpdates() -memoryTrace('bootstrap:after-check-for-updates') - -/** - * Wrapper for Bun's ServerWebSocket that implements EventEmitter - * Provides compatibility with Node.js WebSocket implementations - */ -class BunSocketWrapper extends EventEmitter implements IBunSocketWrapper { - ws: ServerWebSocket - remoteAddress: string - - /** - * Creates a new BunSocketWrapper - * @param ws - Bun ServerWebSocket instance - */ - constructor(ws: ServerWebSocket) { - super() - this.ws = ws - this.remoteAddress = ws?.data?.remoteAddress || 'unknown' - } - - /** - * Sends data through the WebSocket connection - * @param data - Data to send - * @returns True if sent successfully - */ - /** - * Sends data through the WebSocket connection - * @param data - Data to send - * @returns True if sent successfully - * @public - */ - send(data: string | Buffer): boolean { - try { - const r = this.ws.send(data) - return r !== 0 - } catch { - return false - } - } - - /** - * Sends a WebSocket ping frame - * @param data - Optional ping data - * @returns True if sent successfully - * @public - */ - ping(data?: string | Buffer): boolean { - try { - this.ws.ping?.(data) - return true - } catch { - return false - } - } - - /** - * Closes the connection. - * - * Here is a list of close codes: - * - `1000` means "normal closure" **(default)** - * - `1009` means a message was too big and was rejected - * - `1011` means the server encountered an error - * - `1012` means the server is restarting - * - `1013` means the server is too busy or the client is rate-limited - * - `4000` through `4999` are reserved for applications (you can use it!) - * - * To close the connection abruptly, use `terminate()`. - * - * @param code The close code to send - * @param reason The close reason to send - * @public - */ - close(code?: number, reason?: string): void { - this.ws.close(code, reason) - } - - /** - * Terminates the connection immediately - * @public - */ - terminate(): void { - this.ws.close(1000, 'Terminated') - } - - /** - * Internal handler for received messages - * @param message - Message data - * @internal - */ - _handleMessage(message: string | Buffer): void { - this.emit('message', message) + try { + await checkForUpdates() + } catch (e: unknown) { + logger('error', 'Git', `Update check failed: ${(e as Error).message}`) } - /** - * Internal handler for connection close events - * @param code - Close code - * @param reason - Close reason - * @internal - */ - _handleClose(code: number, reason: string): void { - this.emit('close', code, reason) + try { + await checkDependencyUpdates() + } catch (e: unknown) { + logger('error', 'Git', `Dependency check failed: ${(e as Error).message}`) } } +memoryTrace('bootstrap:after-check-for-updates') + /** * Main NodeLink server class * Handles WebSocket connections, audio sources, and player management @@ -468,6 +503,7 @@ class NodelinkServer extends EventEmitter { lyrics: LyricsManager | null meanings: MeaningManager | null _sourceInitPromise: Promise + proxyManager: ProxyManager | null routePlanner: RoutePlannerManager credentialManager: CredentialManager | null trackCacheManager: TrackCacheManager | null @@ -530,6 +566,7 @@ class NodelinkServer extends EventEmitter { this.routePlanner = new RoutePlannerManager(this) memoryTrace('constructor:after-route-planner') + this.proxyManager = null this.credentialManager = null memoryTrace('constructor:after-credential-manager') this.trackCacheManager = null @@ -567,8 +604,8 @@ class NodelinkServer extends EventEmitter { this.voiceSockets = new Map() this.voiceRelay = createVoiceRelay({ - enabled: options.voiceReceive?.enabled || false, - format: options.voiceReceive?.format || 'pcm', + enabled: options.playback.voiceReceive?.enabled || false, + format: options.playback.voiceReceive?.format || 'pcm', sendFrame: (frame: Buffer) => this.handleVoiceFrame(frame), logger }) as unknown as VoiceRelay @@ -659,13 +696,13 @@ class NodelinkServer extends EventEmitter { .then(([CredentialManagerClass, TrackCacheManagerClass]) => { if (!this.credentialManager) { this.credentialManager = new CredentialManagerClass( - this as unknown as { options: Record } + this as unknown as { options: NodelinkConfig } ) as unknown as CredentialManager } if (!this.trackCacheManager) { this.trackCacheManager = new TrackCacheManagerClass( - this as unknown as { options: Record } + this as unknown as { options: NodelinkConfig } ) as unknown as TrackCacheManager } }) @@ -677,11 +714,16 @@ class NodelinkServer extends EventEmitter { } /** - * Starts the heartbeat interval to keep WebSocket connections alive + * Starts the heartbeat interval to keep WebSocket connections alive. + * + * No-op when running under `Bun.serve` because Bun handles WebSocket pings + * natively via `websocket.sendPings: true`. Running both would double the + * keepalive traffic. * @internal */ _startHeartbeat() { if (this._heartbeatInterval) return + if (this._usingBunServer) return this._heartbeatInterval = setInterval(() => { for (const session of this.sessions.activeSessions.values()) { @@ -891,84 +933,91 @@ class NodelinkServer extends EventEmitter { 'Resume', `Processing websocket connection. oldSessionId: ${oldSessionId}` ) + let session = null if (oldSessionId) { - const session = this.sessions.resume(oldSessionId, socket) + session = this.sessions.resume(oldSessionId, socket) - if (session) { + if (!session) { logger( - 'info', + 'warn', 'Server', - `\x1b[36m${clientInfo.name}\x1b[0m${ - clientInfo.version - ? `/\x1b[32mv${clientInfo.version}\x1b[0m` - : '' - } resumed session with ID: ${oldSessionId}` + `Session-ID provided by ${clientInfo.name} does not exist or is not resumable: ${oldSessionId}, creating a new session` ) - this.statsManager.incrementSessionResume(clientInfo.name, true) - - socket.on('close', (...args: (string | number | Buffer)[]) => { - const code = args[0] as number - const reason = args[1] as string - if (!this.sessions.has(oldSessionId)) return - - const session = this.sessions.get(oldSessionId) - if (!session) return + } + } - logger( - 'info', - 'Server', - `\x1b[36m${clientInfo.name}\x1b[0m/\x1b[32mv${ - clientInfo.version - }\x1b[0m disconnected with code ${code} and reason: ${ - reason || 'without reason' - }` - ) + if (session) { + logger( + 'info', + 'Server', + `\x1b[36m${clientInfo.name}\x1b[0m${ + clientInfo.version ? `/\x1b[32mv${clientInfo.version}\x1b[0m` : '' + } resumed session with ID: ${oldSessionId}` + ) + this.statsManager.incrementSessionResume(clientInfo.name, true) - if (session.resuming) { - this.sessions.pause(oldSessionId) - } else { - this.sessions.shutdown(oldSessionId) - } + socket.on('close', (...args: (string | number | Buffer)[]) => { + const code = args[0] as number + const reason = args[1] as string + if (!this.sessions.has(oldSessionId)) return - const sessionCount = this.sessions.activeSessions?.size || 0 - this.statsManager.setWebsocketConnections(sessionCount) - }) + const session = this.sessions.get(oldSessionId) + if (!session) return - socket.send( - JSON.stringify({ - op: 'ready', - resumed: true, - sessionId: oldSessionId - }) + logger( + 'info', + 'Server', + `\x1b[36m${clientInfo.name}\x1b[0m/\x1b[32mv${ + clientInfo.version + }\x1b[0m disconnected with code ${code} and reason: ${ + reason || 'without reason' + }` ) - while (session.eventQueue.length > 0) { - const event = session.eventQueue.shift() - if (event) socket.send(event) - } - - for (const [ - playerKey, - playerInfo - ] of session.players.players.entries()) { - if (this.workerManager) { - const worker = this.workerManager.getWorkerForGuild(playerKey) - if (worker) { - this.workerManager.execute(worker, 'playerCommand', { - sessionId: session.id, - guildId: playerInfo.guildId, - command: 'forceUpdate', - args: [] - }) - } - } else { - playerInfo._sendUpdate() - } + if (session.resuming) { + this.sessions.pause(oldSessionId) + } else { + this.sessions.shutdown(oldSessionId) } const sessionCount = this.sessions.activeSessions?.size || 0 this.statsManager.setWebsocketConnections(sessionCount) + }) + + socket.send( + JSON.stringify({ + op: 'ready', + resumed: true, + sessionId: oldSessionId + }) + ) + + while (session.eventQueue.length > 0) { + const event = session.eventQueue.shift() + if (event) socket.send(event) + } + + for (const [ + playerKey, + playerInfo + ] of session.players.players.entries()) { + if (this.workerManager) { + const worker = this.workerManager.getWorkerForGuild(playerKey) + if (worker) { + this.workerManager.execute(worker, 'playerCommand', { + sessionId: session.id, + guildId: playerInfo.guildId, + command: 'forceUpdate', + args: [] + }) + } + } else { + playerInfo._sendUpdate() + } } + + const sessionCount = this.sessions.activeSessions?.size || 0 + this.statsManager.setWebsocketConnections(sessionCount) } else { const sessionId = this.sessions.create( request as unknown as RequestShim, @@ -1199,366 +1248,133 @@ class NodelinkServer extends EventEmitter { } } ) - } - - /** - * Creates and configures Bun HTTP server with WebSocket support - * @internal - */ - _createBunServer() { - const port = this.options.server.port - const host = this.options.server.host || '0.0.0.0' - const password = this.options.server.password - const self = this - - logger( - 'warn', - 'Server', - 'Running with Bun.serve, remember this is experimental!' - ) - - this.server = Bun.serve({ - port, - hostname: host, - maxRequestBodySize: 1024 * 1024 * 50, - - async fetch(req, server) { - const url = new URL(req.url) - const pathname = url.pathname.endsWith('/') - ? url.pathname.slice(0, -1) - : url.pathname - - if (pathname === '/v4/profiler/socket') { - const remoteAddress = server.requestIP(req)?.address || 'unknown' - const isInternal = /^(::1|localhost|127\.0\.0\.1)/.test(remoteAddress) - const endpoint = self.options.cluster?.endpoint || {} - const patchEnabled = endpoint.patchEnabled === true - const allowExternalPatch = endpoint.allowExternalPatch === true - const expectedCode = - typeof endpoint.code === 'string' && endpoint.code.length > 0 - ? endpoint.code - : 'CAPYBARA' - const providedCode = - url.searchParams.get('code') || - req.headers.get('x-nodelink-code') || - req.headers.get('x-worker-code') - - if (!patchEnabled) { - return new Response('Profiler socket endpoint is disabled.', { - status: 403, - statusText: 'Forbidden' - }) - } - if (!allowExternalPatch && !isInternal) { - return new Response('External profiler socket access is blocked.', { - status: 403, - statusText: 'Forbidden' - }) - } - if (!providedCode || providedCode !== expectedCode) { - return new Response('Invalid or missing profiler code.', { - status: 403, - statusText: 'Forbidden' - }) - } - - const success = server.upgrade(req, { - data: { - clientInfo: { name: 'ProfilerUI', version: '1' }, - sessionId: null, - reqHeaders: Object.fromEntries(req.headers), - remoteAddress, - url: req.url - } - }) - - if (success) return undefined - return new Response('WebSocket upgrade failed', { status: 400 }) - } - - if (pathname === '/v4/websocket') { - const remoteAddress = server.requestIP(req)?.address || 'unknown' - const clientAddress = `[External] (${remoteAddress})` - - const clientName = req.headers.get('client-name') - const auth = req.headers.get('authorization') - const userId = req.headers.get('user-id') - const sessionId = req.headers.get('session-id') - - if (auth !== password) { - logger( - 'warn', - 'Server', - `Unauthorized connection attempt from ${clientAddress} - Invalid password provided: ${auth || 'None'}` - ) - return new Response('Invalid password provided.', { - status: 401, - statusText: 'Unauthorized', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }) - } - - if (!clientName) { - logger( - 'warn', - 'Server', - `Missing client-name from ${clientAddress}` - ) - return new Response('Invalid or missing Client-Name header.', { - status: 400, - statusText: 'Bad Request', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }) - } - - if (!userId || !verifyDiscordID(userId)) { - logger('warn', 'Server', `Invalid user ID from ${clientAddress}`) - return new Response('Invalid or missing User-Id header.', { - status: 400, - statusText: 'Bad Request', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }) - } - const clientInfo = parseClient(clientName) as ClientInfo | null - if (!clientInfo) { - logger( - 'warn', - 'Server', - `Invalid client-name from ${clientAddress}` - ) - return new Response('Invalid or missing Client-Name header.', { - status: 400, - statusText: 'Bad Request', - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }) - } - - const success = server.upgrade(req, { - data: { - clientInfo, - sessionId, - reqHeaders: Object.fromEntries(req.headers), - remoteAddress, - url: req.url - } - }) + this.socket?.on( + '/v4/websocket/voice', + ( + socket: SessionSocket, + request: RequestShim, + _clientInfo: ClientInfo, + _sessionId: string, + guildId: string + ) => { + socket.guildId = guildId - if (success) return undefined - return new Response('WebSocket upgrade failed', { - status: 400, - headers: { - 'Nodelink-Api-Version': '4', - IamNodelink: 'true' - } - }) + if (!this.options.playback.voiceReceive?.enabled) { + try { + socket.close(1008, 'Voice receive disabled') + } catch {} + return } - return new Promise((resolve) => { - interface RequestShimInternal extends RequestShim { - _endCb?: () => void - } - - const reqShim: RequestShimInternal = { - method: req.method, - url: url.pathname + url.search, - headers: Object.fromEntries(req.headers), - socket: { remoteAddress: server.requestIP(req)?.address }, - on: (event: string, cb: (data: Buffer) => void) => { - if (event === 'data') { - req - .arrayBuffer() - .then((buf: ArrayBuffer) => { - cb(Buffer.from(buf)) - if (reqShim._endCb) reqShim._endCb() - }) - .catch(() => {}) - } - if (event === 'end') { - reqShim._endCb = cb as () => void - } - } - } - - const resShim: ResponseShim = { - _status: 200, - _headers: {}, - _body: [], - writeHead( - status: number, - headers?: Record - ) { - this._status = status - if (headers) Object.assign(this._headers, headers) - }, - setHeader(name: string, value: string | string[]) { - this._headers[name] = value - }, - getHeader(name: string) { - return this._headers[name] as string | string[] | undefined - }, - end(data?: string | Buffer) { - if (data) this._body.push(data) - const finalBody = Buffer.concat( - this._body.map((chunk) => - Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk) - ) - ) + logger( + 'info', + 'Voice', + `Voice websocket connected from ${request.socket?.remoteAddress || 'unknown'} | guild ${guildId}` + ) - const headers = new Headers() - for (const [key, value] of Object.entries(this._headers)) { - if (Array.isArray(value)) { - for (const v of value) headers.append(key, v) - } else if (value !== undefined) { - headers.set(key, String(value)) - } - } + this.registerVoiceSocket(guildId, socket) + } + ) - const response = new Response(finalBody, { - status: this._status, - headers - }) - resolve(response) - }, - write(data: string | Buffer) { - if (data) this._body.push(data) - } - } + this.socket?.on( + '/v4/websocket/youtube/live', + ( + socket: SessionSocket, + request: RequestShim, + _clientInfo: ClientInfo, + _sessionId: string, + id: string + ) => { + let videoId = id + socket.guildId = id // Tag it with videoId or guildId equivalent - void getRequestHandler() - .then((handler) => - handler( - self as unknown as Parameters[0], - reqShim as unknown as RequestShim, - resShim - ) - ) - .catch((error: Error) => { - logger( - 'error', - 'Server', - `Failed to handle Bun request: ${error.message}` - ) - if (!resShim._status || resShim._status < 400) { - resShim.writeHead(500, { 'Content-Type': 'text/plain' }) - } - resShim.end('Internal Server Error') - }) - }) - }, - - websocket: { - sendPings: true, - data: {} as BunSocketData, - open(ws) { - if (!ws.data) return - const wrapper = new BunSocketWrapper(ws) - ws.data.wrapper = wrapper - - const { clientInfo, sessionId, reqHeaders } = ws.data - - const reqShim: ReqShim = { - headers: reqHeaders as Record, - url: ws.data.url, - socket: { remoteAddress: ws.data.remoteAddress } + if (/^\d{17,20}$/.test(id)) { + const player = this.sessions.getPlayer(id) + if (player?.track?.info?.sourceName?.includes('youtube')) { + videoId = player.track.info.identifier } - - let pathname = '/v4/websocket' + } else if (id.length > 50) { try { - pathname = new URL(ws.data.url).pathname - } catch {} + const decoded = decodeTrack(id) + if (decoded?.info?.sourceName?.includes('youtube')) { + videoId = decoded.info.identifier + } + } catch (_e) {} + } - if (pathname === '/v4/profiler/socket') { - logger( - 'info', - 'ProfilerSocket', - `Profiler socket connected from [External] (${ws.data.remoteAddress})` - ) - self.socket?.emit( - '/v4/profiler/socket', - wrapper, - reqShim, - null, - null - ) + if (!this.sourceWorkerManager) { + const yt = this.sources?.getSource('youtube') + if (!yt) { + socket.close(1008, 'YouTube source not enabled') return } + const liveChatFn = yt.handleLiveChat + if (typeof liveChatFn === 'function') { + liveChatFn.call(yt, socket, videoId) + } else { + socket.close(1008, 'YouTube live chat not supported') + } + return + } - logger( - 'info', - 'Server', - `\x1b[36m${clientInfo.name}\x1b[0m${ - clientInfo.version ? `/\x1b[32mv${clientInfo.version}\x1b[0m` : '' - } connected from [External] (${ws.data.remoteAddress}) | \x1b[33mURL:\x1b[0m ${ws.data.url}` - ) - - let eventName = '/v4/websocket' - let guildId = null - let liveId = null - try { - const url = new URL(ws.data.url) - const voiceMatch = url.pathname.match( - /^\/v4\/websocket\/voice\/([A-Za-z0-9]+)\/?$/ - ) - const liveMatch = url.pathname.match( - /^\/v4\/websocket\/youtube\/live\/([^/]+)\/?$/ - ) - - if (voiceMatch) { - if (!self.options.voiceReceive?.enabled) { - try { - wrapper.close(1008, 'Voice receive disabled') - } catch {} - return - } - eventName = '/v4/websocket/voice' - guildId = voiceMatch[1] - } else if (liveMatch) { - eventName = '/v4/websocket/youtube/live' - liveId = liveMatch[1] - } - } catch {} + logger( + 'info', + 'YouTube-LiveChat', + `Delegating live chat for video: ${videoId} to worker` + ) - if (self.socket) { - self.socket.emit( - eventName, - wrapper, - reqShim, - clientInfo, - sessionId, - guildId || liveId - ) - } - }, - message(ws: ServerWebSocket, message: string | Buffer) { - ws.data?.wrapper?._handleMessage(message) - }, - close( - ws: ServerWebSocket, - code: number, - reason: string - ) { - ws.data?.wrapper?._handleClose(code, reason) + const resShim = { + headersSent: false, + send: (data: string | Buffer) => { + const payload = Buffer.isBuffer(data) + ? data + : Buffer.from(String(data)) + socket.sendFrame?.(payload, { + len: payload.length, + fin: true, + opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 + }) + }, + writeHead: (status: number) => { + if (status !== 200) socket.close(1011, 'Worker failed') + }, + write: (data: string | Buffer) => { + const payload = Buffer.isBuffer(data) + ? data + : Buffer.from(String(data)) + socket.sendFrame?.(payload, { + len: payload.length, + fin: true, + opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 + }) + }, + end: () => socket.close(1000, 'Finished'), + on: ( + event: string, + cb: (...args: (string | Buffer | number)[]) => void + ) => socket.on(event, cb) } + + this.sourceWorkerManager.delegate( + request, + resShim, + 'loadLiveChat', + { videoId }, + { isWebSocket: true } + ) } - }) + ) + } - logger( - 'started', - 'Server', - `Successfully listening on ${host}:${port} (Bun Native)` + /** + * Creates and configures Bun HTTP server with WebSocket support + * @internal + */ + _createBunServer() { + this.server = createBunServer( + this as unknown as import('./server/bunServer.ts').BunServerContext, + getRequestHandler ) } @@ -1850,7 +1666,7 @@ class NodelinkServer extends EventEmitter { return rejectUpgrade(400, 'Bad Request', 'Invalid User-Id header.') } - if (voiceMatch && !this.options.voiceReceive?.enabled) { + if (voiceMatch && !this.options.playback.voiceReceive?.enabled) { return rejectUpgrade( 404, 'Not Found', @@ -1932,123 +1748,6 @@ class NodelinkServer extends EventEmitter { } } ) - - this.socket?.on( - '/v4/websocket/voice', - ( - socket: SessionSocket, - request: RequestShim, - _clientInfo: ClientInfo, - _sessionId: string, - guildId: string - ) => { - socket.guildId = guildId - - if (!this.options.voiceReceive?.enabled) { - try { - socket.close(1008, 'Voice receive disabled') - } catch {} - return - } - - logger( - 'info', - 'Voice', - `Voice websocket connected from ${request.socket?.remoteAddress || 'unknown'} | guild ${guildId}` - ) - - this.registerVoiceSocket(guildId, socket) - } - ) - - this.socket?.on( - '/v4/websocket/youtube/live', - ( - socket: SessionSocket, - request: RequestShim, - _clientInfo: ClientInfo, - _sessionId: string, - id: string - ) => { - let videoId = id - socket.guildId = id // Tag it with videoId or guildId equivalent - - if (/^\d{17,20}$/.test(id)) { - const player = this.sessions.getPlayer(id) - if (player?.track?.info?.sourceName?.includes('youtube')) { - videoId = player.track.info.identifier - } - } else if (id.length > 50) { - try { - const decoded = decodeTrack(id) - if (decoded?.info?.sourceName?.includes('youtube')) { - videoId = decoded.info.identifier - } - } catch (_e) {} - } - - if (!this.sourceWorkerManager) { - const yt = this.sources?.getSource('youtube') - if (!yt) { - socket.close(1008, 'YouTube source not enabled') - return - } - const liveChatFn = yt.handleLiveChat - if (typeof liveChatFn === 'function') { - liveChatFn.call(yt, socket, videoId) - } else { - socket.close(1008, 'YouTube live chat not supported') - } - return - } - - logger( - 'info', - 'YouTube-LiveChat', - `Delegating live chat for video: ${videoId} to worker` - ) - - const resShim = { - headersSent: false, - send: (data: string | Buffer) => { - const payload = Buffer.isBuffer(data) - ? data - : Buffer.from(String(data)) - socket.sendFrame?.(payload, { - len: payload.length, - fin: true, - opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 - }) - }, - writeHead: (status: number) => { - if (status !== 200) socket.close(1011, 'Worker failed') - }, - write: (data: string | Buffer) => { - const payload = Buffer.isBuffer(data) - ? data - : Buffer.from(String(data)) - socket.sendFrame?.(payload, { - len: payload.length, - fin: true, - opcode: Buffer.isBuffer(data) ? 0x02 : 0x01 - }) - }, - end: () => socket.close(1000, 'Finished'), - on: ( - event: string, - cb: (...args: (string | Buffer | number)[]) => void - ) => socket.on(event, cb) - } - - this.sourceWorkerManager.delegate( - request, - resShim, - 'loadLiveChat', - { videoId }, - { isWebSocket: true } - ) - } - ) } /** @@ -2108,16 +1807,16 @@ class NodelinkServer extends EventEmitter { if (this._globalUpdater) return const updateInterval = Math.max( 1, - this.options?.playerUpdateInterval ?? 5000 + this.options?.playback.playerUpdateInterval ?? 5000 ) const statsSendInterval = Math.max( 1, - this.options?.statsUpdateInterval ?? 30000 + this.options?.playback.statsUpdateInterval ?? 30000 ) - const metricsInterval = this.options?.metrics?.enabled + const metricsInterval = this.options?.api.metrics?.enabled ? 5000 : statsSendInterval - const zombieThreshold = this.options?.zombieThresholdMs ?? 60000 + const zombieThreshold = this.options?.playback.zombieThresholdMs ?? 60000 this._globalUpdater = setInterval(() => { for (const session of this.sessions.values()) { @@ -2228,29 +1927,13 @@ class NodelinkServer extends EventEmitter { */ async _cleanupWebSocketServer(): Promise { if (this._usingBunServer && this.server) { - try { - logger('info', 'WebSocket', 'Stopping Bun server...') - await ( - this.server as { - stop: (force: boolean) => Promise - unref: () => void - } - ).stop(true) - ;( - this.server as { - stop: (force: boolean) => Promise - unref: () => void - } - ).unref() - logger('info', 'WebSocket', 'Bun server stopped successfully') - } catch (e) { - const error = e as Error - logger( - 'error', - 'WebSocket', - `Error stopping Bun server: ${error?.message ?? String(e)}` - ) - } + await cleanupBunServer( + this as unknown as import('./server/bunServer.ts').BunServerContext, + this.server as { + stop: (force?: boolean) => Promise + unref: () => void + } + ) return } @@ -2492,7 +2175,7 @@ class NodelinkServer extends EventEmitter { 'Running as cluster worker — waiting for sockets from master.' ) process.on('message', (msg: IPCMessage | { type: string }, handle) => { - if (!msg || msg.type !== 'sticky-session') return + if (msg?.type !== 'sticky-session') return if (!handle) return try { try { @@ -2529,6 +2212,7 @@ class NodelinkServer extends EventEmitter { this.connectionManager?.start() memoryTrace('start:ready') + return this } @@ -2540,9 +2224,9 @@ class NodelinkServer extends EventEmitter { if (this._globalUpdater) return const statsSendInterval = Math.max( 1, - this.options?.statsUpdateInterval ?? 30000 + this.options?.playback.statsUpdateInterval ?? 30000 ) - const metricsInterval = this.options?.metrics?.enabled + const metricsInterval = this.options?.api.metrics?.enabled ? 5000 : statsSendInterval @@ -2702,7 +2386,7 @@ process.on('unhandledRejection', (reason, promise) => { if (clusterEnabled && cluster.isPrimary) { if (config.sources?.youtube?.getOAuthToken) { - // dynamicly import OAuth (if enabled) + // dynamically import OAuth (if enabled) const OAuth = ( await import('./sources/youtube/OAuth.ts').catch((e) => { logger( @@ -2775,6 +2459,12 @@ if (clusterEnabled && cluster.isPrimary) { process.stdout.write( ' \x1b[1m\x1b[34m➜\x1b[0m \x1b[36mhttps://discord.gg/fzjksWS65v\x1b[0m\n\n' ) + process.stdout.write( + ' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mHaving issues? Use "git checkout dev" to see if it\'s fixed.\x1b[0m\n' + ) + process.stdout.write( + ' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mRead the FAQ & follow the support template in our Discord.\x1b[0m\n\n' + ) logger( 'info', @@ -2855,6 +2545,13 @@ if (clusterEnabled && cluster.isPrimary) { await nserver.trackCacheManager?.forceSave() nserver.sourceWorkerManager?.destroy?.() + nserver.workerManager?.destroy?.() + nserver.connectionManager?.destroy?.() + nserver.proxyManager?.destroy?.() + nserver.routePlanner?.dispose?.() + nserver.credentialManager?.destroy?.() + nserver.trackCacheManager?.destroy?.() + await nserver._cleanupWebSocketServer() if ((nserver.server as http.Server)?.listening) { @@ -2878,6 +2575,12 @@ if (clusterEnabled && cluster.isPrimary) { process.stdout.write( ' \x1b[1m\x1b[34m➜\x1b[0m \x1b[36mhttps://discord.gg/fzjksWS65v\x1b[0m\n\n' ) + process.stdout.write( + ' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mHaving issues? Use "git checkout dev" to see if it\'s fixed.\x1b[0m\n' + ) + process.stdout.write( + ' \x1b[1m\x1b[35m➜\x1b[0m \x1b[35mRead the FAQ & follow the support template in our Discord.\x1b[0m\n\n' + ) process.exit(0) } diff --git a/src/lyrics/monochrome.ts b/src/lyrics/monochrome.ts index 0396044c..cb11ddf7 100644 --- a/src/lyrics/monochrome.ts +++ b/src/lyrics/monochrome.ts @@ -7,8 +7,7 @@ import type { } from '../managers/lyricsManager.ts' import type { InstanceHealth, - MonochromeLyricsResponse, - MonochromeSourceConfig + MonochromeLyricsResponse } from '../typings/sources/monochrome.types.ts' import { logger, makeRequest } from '../utils.ts' @@ -33,13 +32,8 @@ export default class MonochromeLyrics implements LyricsSourceInstance { */ constructor(nodelink: LyricsManagerContext) { this.nodelink = nodelink - const sources = nodelink.options?.sources as - | Record - | undefined - const config = - (sources?.monochrome as unknown as MonochromeSourceConfig) || { - enabled: false - } + const sources = nodelink.options.sources + const config = sources.monochrome const defaultUrls = [ 'https://eu-central.monochrome.tf', diff --git a/src/managers/baseCacheManager.ts b/src/managers/baseCacheManager.ts new file mode 100644 index 00000000..3daefde5 --- /dev/null +++ b/src/managers/baseCacheManager.ts @@ -0,0 +1,419 @@ +import crypto from 'node:crypto' +import fs from 'node:fs/promises' +import { logger } from '../utils.ts' + +export type BaseCacheEntry = { + value: T + createdAt: number + updatedAt: number + expiresAt: number | null +} + +export type BaseCachePayload = { + version: number + savedAt: number + entries: Record> +} + +export interface BaseCacheOptions { + name: string + passwordHashKey: string + salt: string + filePath: string + saveDelayMs?: number + cleanupIntervalMs?: number + maxEntries?: number + version?: number +} + +const isRecord = (value: unknown): value is Record => + typeof value === 'object' && value !== null && !Array.isArray(value) + +const getErrorMessage = (error: unknown): string => + error instanceof Error ? error.message : String(error ?? 'Unknown error') + +const getErrorCode = (error: unknown): string | undefined => { + if (!error || typeof error !== 'object' || !('code' in error)) { + return undefined + } + const code = (error as NodeJS.ErrnoException).code + return typeof code === 'string' ? code : undefined +} + +/** + * Generic encrypted cache file store using AES-256-GCM. + * Handles atomic saves, TTL purging, and max entry eviction. + */ +export default abstract class BaseCacheManager { + protected readonly cacheName: string + private readonly passwordHashKey: string + private readonly salt: string + private key: Buffer + private legacyKey: Buffer | null + protected readonly filePath: string + protected readonly tempFilePath: string + protected readonly saveDelayMs: number + protected readonly cleanupIntervalMs: number + protected readonly maxEntries: number + protected readonly version: number + + protected cache: Map> + private saveTimeout: NodeJS.Timeout | null + private cleanupInterval: NodeJS.Timeout | null + private savePromise: Promise | null + private saveQueued: boolean + + protected lastLoadedAt: number | null + protected lastSavedAt: number | null + + constructor(options: BaseCacheOptions) { + this.cacheName = options.name + this.passwordHashKey = options.passwordHashKey + this.salt = options.salt + this.filePath = options.filePath + this.tempFilePath = `${options.filePath}.tmp` + this.saveDelayMs = options.saveDelayMs ?? 5000 + this.cleanupIntervalMs = options.cleanupIntervalMs ?? 60000 + this.maxEntries = options.maxEntries ?? 0 + this.version = options.version ?? 1 + + this.key = this._deriveFastKey(this.passwordHashKey) + this.legacyKey = null + this.cache = new Map() + + this.saveTimeout = null + this.savePromise = null + this.saveQueued = false + this.lastLoadedAt = null + this.lastSavedAt = null + + this.cleanupInterval = setInterval(() => { + const expiredCount = this._purgeExpired() + const evictedCount = this._enforceMaxEntries() + if (expiredCount > 0 || evictedCount > 0) this.save() + }, this.cleanupIntervalMs) + this.cleanupInterval.unref?.() + } + + async load(): Promise { + try { + const data = await fs.readFile(this.filePath) + if (data.length < 32) return + + let payload: BaseCachePayload + let migratedFromLegacy = false + + try { + payload = this._decodePayload(data, this.key) + } catch { + const legacyKey = this._getLegacyKey() + payload = this._decodePayload(data, legacyKey) + migratedFromLegacy = true + } + + this.cache = new Map(Object.entries(payload.entries)) + + const expiredCount = this._purgeExpired() + const evictedCount = this._enforceMaxEntries() + if (expiredCount > 0 || evictedCount > 0 || migratedFromLegacy) + this.save() + + this.lastLoadedAt = Date.now() + logger( + 'debug', + this.cacheName, + `Loaded ${this.cache.size} entries from disk.` + ) + } catch (error) { + const code = getErrorCode(error) + if (code !== 'ENOENT') { + logger( + 'error', + this.cacheName, + `Failed to load cache: ${getErrorMessage(error)}` + ) + } + this.cache = new Map() + } + } + + save(): void { + if (this.saveTimeout) return + + this.saveTimeout = setTimeout(() => { + this.saveTimeout = null + void this.forceSave() + }, this.saveDelayMs) + } + + async forceSave(): Promise { + if (this.saveTimeout) { + clearTimeout(this.saveTimeout) + this.saveTimeout = null + } + + try { + this._purgeExpired() + this._enforceMaxEntries() + await this._flushSaveQueue() + logger('debug', this.cacheName, 'Force saved to disk.') + } catch (error) { + logger( + 'error', + this.cacheName, + `Failed to force save: ${getErrorMessage(error)}` + ) + } + } + + clear(): void { + if (this.cache.size === 0) return + this.cache.clear() + this.save() + } + + /** + * Cleans up internal timers and resources. + */ + destroy(): void { + if (this.cleanupInterval) { + clearInterval(this.cleanupInterval) + this.cleanupInterval = null + } + if (this.saveTimeout) { + clearTimeout(this.saveTimeout) + this.saveTimeout = null + } + } + + protected _getValidEntry(key: string): BaseCacheEntry | null { + const entry = this.cache.get(key) + if (!entry) return null + if (entry.expiresAt && Date.now() > entry.expiresAt) { + this.cache.delete(key) + this.save() + return null + } + + if (this.maxEntries > 0) { + this.cache.delete(key) + this.cache.set(key, entry) + } + + return entry + } + + private _deriveFastKey(password: string): Buffer { + return crypto + .createHash('sha256') + .update(`${this.salt}:${password}`) + .digest() + } + + private _getLegacyKey(): Buffer { + if (!this.legacyKey) { + this.legacyKey = crypto.scryptSync(this.passwordHashKey, this.salt, 32) + } + return this.legacyKey + } + + private _purgeExpired(): number { + const now = Date.now() + let expiredCount = 0 + for (const [key, entry] of this.cache.entries()) { + if (entry.expiresAt && now > entry.expiresAt) { + this.cache.delete(key) + expiredCount++ + } + } + return expiredCount + } + + protected _enforceMaxEntries(): number { + if (this.maxEntries <= 0 || this.cache.size <= this.maxEntries) return 0 + + let removed = 0 + while (this.cache.size > this.maxEntries) { + const oldestKey = this.cache.keys().next().value + if (!oldestKey) break + this.cache.delete(oldestKey) + removed++ + } + return removed + } + + private _decodePayload(data: Buffer, key: Buffer): BaseCachePayload { + const iv = data.subarray(0, 16) + const tag = data.subarray(16, 32) + const encrypted = data.subarray(32) + + const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv) + decipher.setAuthTag(tag) + + const decrypted = Buffer.concat([ + decipher.update(encrypted), + decipher.final() + ]).toString('utf8') + const parsed = JSON.parse(decrypted) as unknown + return this._normalizePayload(parsed) + } + + private _normalizePayload(raw: unknown): BaseCachePayload { + const now = Date.now() + + if (isRecord(raw) && !('version' in raw) && !('entries' in raw)) { + return { + version: this.version, + savedAt: now, + entries: this._normalizeEntries(raw, now) + } + } + + if (isRecord(raw)) { + const payloadCandidate = raw as Partial> & { + entries?: unknown + savedAt?: unknown + } + const entriesValue = payloadCandidate.entries + if (isRecord(entriesValue)) { + return { + version: payloadCandidate.version ?? this.version, + savedAt: + typeof payloadCandidate.savedAt === 'number' + ? payloadCandidate.savedAt + : now, + entries: this._normalizeEntries(entriesValue, now) + } + } + } + + return { + version: this.version, + savedAt: now, + entries: {} + } + } + + private _normalizeEntries( + rawEntries: Record, + fallbackTime: number + ): Record> { + const entries: Record> = {} + for (const [key, value] of Object.entries(rawEntries)) { + entries[key] = this._normalizeEntry(value, fallbackTime) + } + return entries + } + + private _normalizeEntry( + rawValue: unknown, + fallbackTime: number + ): BaseCacheEntry { + if (isRecord(rawValue)) { + const entryCandidate = rawValue as Partial> & { + value?: unknown + } + const value = Object.hasOwn(entryCandidate, 'value') + ? entryCandidate.value + : rawValue + + const createdAt = + typeof entryCandidate.createdAt === 'number' + ? entryCandidate.createdAt + : fallbackTime + const updatedAt = + typeof entryCandidate.updatedAt === 'number' + ? entryCandidate.updatedAt + : createdAt + const expiresAt = + typeof entryCandidate.expiresAt === 'number' && + entryCandidate.expiresAt > 0 + ? entryCandidate.expiresAt + : null + + return { + value: value as T, + createdAt, + updatedAt, + expiresAt + } + } + + return { + value: rawValue as T, + createdAt: fallbackTime, + updatedAt: fallbackTime, + expiresAt: null + } + } + + private _buildPayload(): BaseCachePayload { + return { + version: this.version, + savedAt: Date.now(), + entries: Object.fromEntries(this.cache) + } + } + + private async _flushSaveQueue(): Promise { + if (this.savePromise) { + this.saveQueued = true + await this.savePromise + if (this.saveQueued) { + this.saveQueued = false + await this._flushSaveQueue() + } + return + } + + const payload = this._buildPayload() + this.savePromise = this._writeToDisk(payload) + try { + await this.savePromise + } finally { + this.savePromise = null + } + + if (this.saveQueued) { + this.saveQueued = false + await this._flushSaveQueue() + } + } + + private async _writeToDisk(payload: BaseCachePayload): Promise { + const plainText = JSON.stringify(payload) + const iv = crypto.randomBytes(16) + const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv) + + const encrypted = Buffer.concat([ + cipher.update(plainText, 'utf8'), + cipher.final() + ]) + const tag = cipher.getAuthTag() + const outBuffer = Buffer.concat([iv, tag, encrypted]) + + await fs.mkdir('./.cache', { recursive: true }) + try { + await fs.writeFile(this.tempFilePath, outBuffer) + await fs.rename(this.tempFilePath, this.filePath) + } catch (error) { + logger( + 'debug', + this.cacheName, + `Atomic save failed, falling back to direct write: ${getErrorMessage(error)}` + ) + await fs.writeFile(this.filePath, outBuffer) + try { + await fs.unlink(this.tempFilePath) + } catch (cleanupError) { + logger( + 'debug', + this.cacheName, + `Failed to remove temp cache file: ${getErrorMessage(cleanupError)}` + ) + } + } + + this.lastSavedAt = payload.savedAt + } +} diff --git a/src/managers/configValidationManager.ts b/src/managers/configValidationManager.ts index be5de867..acb5367d 100644 --- a/src/managers/configValidationManager.ts +++ b/src/managers/configValidationManager.ts @@ -1,1518 +1,263 @@ import type { NodelinkConfig } from '../typings/config/config.types.ts' +import { logger } from '../utils.ts' +import { validator } from '../validators.ts' -type ValidationRule = { - path: string - expected: string - value: unknown - validate: (v: unknown) => boolean -} - -type ValidationWarning = { - path: string - message: string -} - -const KNOWN_PLACEHOLDERS = new Set([ - 'your_token_here', - 'changeme', - 'change_me', - 'your-token-here', - 'insert_token_here', - 'placeholder', - 'PLACEHOLDER', - 'YOUR_TOKEN', - 'YOUR_API_KEY', - 'YOUR_CLIENT_ID', - 'YOUR_CLIENT_SECRET' -]) - -const VALID_AUDIO_QUALITIES = new Set(['high', 'medium', 'low', 'lowest']) -const VALID_RESAMPLING_QUALITIES = new Set([ - 'best', - 'medium', - 'fastest', - 'zero', - 'linear' -]) -const VALID_FADING_CURVES = new Set([ - 'linear', - 'exponential', - 'sinusoidal', - 'start', - 'wash', - 'stop', - 'random', - 'baby' -]) -const VALID_FADING_TYPES = new Set(['volume', 'tape', 'both', 'scratch']) -const VALID_VOICE_FORMATS = new Set(['opus', 'pcm_s16le']) -const VALID_ROUTE_STRATEGIES = new Set([ - 'RotateOnBan', - 'RoundRobin', - 'LoadBalance' -]) -const VALID_METRICS_AUTH_TYPES = new Set(['Bearer', 'Basic']) - +/** + * Validates the NodeLink configuration object using a schema-based approach. + * Supports the new hierarchical configuration structure. + */ export default class ConfigValidationManager { - private warnings: ValidationWarning[] = [] - - constructor(private options: NodelinkConfig) {} - - validate(): void { - this.warnings = [] - - const allRules: ValidationRule[] = [ - ...this.validateServer(), - ...this.validateCluster(), - ...this.validateAudio(), - ...this.validatePlayback(), - ...this.validateSources(), - ...this.validateSearch(), - ...this.validateRoutePlanner(), - ...this.validateRateLimit(), - ...this.validateDosProtection(), - ...this.validateLogging(), - ...this.validateConnection(), - ...this.validateVoiceReceive(), - ...this.validateMix(), - ...this.validateMetrics(), - ...this.validateFilters() - ] - - const errors: string[] = [] - for (const rule of allRules) { - if (!rule.validate(rule.value)) { - errors.push( - `Configuration error:\n` + - `- Property: ${rule.path}\n` + - `- Received: ${JSON.stringify(rule.value)}\n` + - `- Expected: ${rule.expected}` - ) - } - } - - if (this.warnings.length > 0) { - const warningLines = this.warnings - .map((w) => ` ⚠ ${w.path}: ${w.message}`) - .join('\n') - console.warn(`\n[NodeLink] Configuration warnings:\n${warningLines}\n`) - } - - if (errors.length > 0) { - throw new Error(`Configuration errors:\n\n${errors.join('\n\n')}`) - } - } - - private validateServer(): ValidationRule[] { - const server = this.options.server - - return [ - this.nonEmptyStringRule('server.host', server?.host), - this.intRangeRule('server.port', server?.port, 1, 65535), - this.nonEmptyStringRule('server.password', server?.password), - this.booleanRule('server.useBunServer', server?.useBunServer) - ] - } - - private validateCluster(): ValidationRule[] { - const cluster = this.options.cluster - if (!cluster) return [] - - const workers = cluster.workers - - const rules: ValidationRule[] = [ - this.booleanRule('cluster.enabled', cluster.enabled) - ] - - if (typeof cluster.enabled !== 'boolean') return rules - - if (cluster.enabled === false) return rules - - rules.push( - this.nonNegativeIntRule('cluster.workers', workers), - this.nonNegativeIntRule('cluster.minWorkers', cluster.minWorkers), - { - path: 'cluster.minWorkers', - expected: - workers === 0 - ? 'integer (auto-scaled workers, unknown value allowed)' - : `integer <= cluster.workers (${workers})`, - value: cluster.minWorkers, - validate: (v: unknown) => - typeof v === 'number' && - Number.isInteger(v) && - Number.isInteger(workers) && - (workers === 0 || v <= workers) - }, - this.positiveIntRule('cluster.commandTimeout', cluster.commandTimeout), - this.positiveIntRule( - 'cluster.fastCommandTimeout', - cluster.fastCommandTimeout - ), - this.nonNegativeIntRule('cluster.maxRetries', cluster.maxRetries) - ) - - if (cluster.hibernation) { - rules.push( - this.booleanRule( - 'cluster.hibernation.enabled', - cluster.hibernation.enabled - ), - this.positiveIntRule( - 'cluster.hibernation.timeoutMs', - cluster.hibernation.timeoutMs - ) - ) - } - - const ssw = cluster.specializedSourceWorker - if (ssw) { - rules.push( - this.booleanRule( - 'cluster.specializedSourceWorker.enabled', - ssw.enabled - ), - this.positiveIntRule( - 'cluster.specializedSourceWorker.count', - ssw.count - ), - this.positiveIntRule( - 'cluster.specializedSourceWorker.microWorkers', - ssw.microWorkers - ), - this.positiveIntRule( - 'cluster.specializedSourceWorker.tasksPerWorker', - ssw.tasksPerWorker - ), - this.booleanRule( - 'cluster.specializedSourceWorker.silentLogs', - ssw.silentLogs - ) - ) - } - - const runtime = cluster.runtime - if (runtime) { - rules.push( - this.nonNegativeIntRule( - 'cluster.runtime.workerMaxOldSpaceMb', - runtime.workerMaxOldSpaceMb - ), - this.nonNegativeIntRule( - 'cluster.runtime.sourceWorkerMaxOldSpaceMb', - runtime.sourceWorkerMaxOldSpaceMb - ), - this.booleanRule( - 'cluster.runtime.workerExposeGc', - runtime.workerExposeGc - ), - this.booleanRule( - 'cluster.runtime.sourceWorkerExposeGc', - runtime.sourceWorkerExposeGc - ), - this.stringArrayRule( - 'cluster.runtime.workerExecArgv', - runtime.workerExecArgv - ), - this.stringArrayRule( - 'cluster.runtime.sourceWorkerExecArgv', - runtime.sourceWorkerExecArgv - ) - ) - } - - const scaling = cluster.scaling - if (scaling) { - rules.push( - this.positiveIntRule( - 'cluster.scaling.maxPlayersPerWorker', - scaling.maxPlayersPerWorker - ), - this.positiveIntRule( - 'cluster.scaling.checkIntervalMs', - scaling.checkIntervalMs - ), - this.positiveIntRule( - 'cluster.scaling.idleWorkerTimeoutMs', - scaling.idleWorkerTimeoutMs - ), - this.positiveIntRule( - 'cluster.scaling.queueLengthScaleUpFactor', - scaling.queueLengthScaleUpFactor - ), - this.positiveIntRule( - 'cluster.scaling.lagPenaltyLimit', - scaling.lagPenaltyLimit - ), - { - path: 'cluster.scaling.scaleUpThreshold', - expected: 'number between 0 and 1 (exclusive)', - value: scaling.scaleUpThreshold, - validate: (v: unknown) => typeof v === 'number' && v > 0 && v < 1 - }, - { - path: 'cluster.scaling.cpuPenaltyLimit', - expected: 'number between 0 and 1 (exclusive)', - value: scaling.cpuPenaltyLimit, - validate: (v: unknown) => typeof v === 'number' && v > 0 && v < 1 - }, - this.floatMustBeBelow( - 'cluster.scaling.scaleDownThreshold', - scaling.scaleDownThreshold, - scaling.scaleUpThreshold, - 'cluster.scaling.scaleUpThreshold' - ), - { - path: 'cluster.scaling.targetUtilization', - expected: `number between scaleDownThreshold (${scaling.scaleDownThreshold}) and scaleUpThreshold (${scaling.scaleUpThreshold})`, - value: scaling.targetUtilization, - validate: (v: unknown) => - typeof scaling.scaleDownThreshold === 'number' && - typeof scaling.scaleUpThreshold === 'number' && - typeof v === 'number' && - v >= scaling.scaleDownThreshold && - v <= scaling.scaleUpThreshold + private config: NodelinkConfig + + constructor(config: NodelinkConfig) { + this.config = config + } + + /** + * Performs a full validation of the configuration. + * @throws Error if validation fails. + */ + public validate(): void { + const schema = { + server: { + type: 'object', + props: { + host: { type: 'string', default: '0.0.0.0' }, + port: { + type: 'number', + integer: true, + min: 1, + max: 65535, + default: 3000 + }, + engine: { + type: 'string', + enum: ['default', 'bun'], + default: 'default', + optional: true + }, + password: { type: 'string', min: 1, optional: true }, + useBunServer: { type: 'boolean', default: false, optional: true } } - ) - } - - const endpoint = cluster.endpoint - if (endpoint) { - rules.push( - this.booleanRule( - 'cluster.endpoint.patchEnabled', - endpoint.patchEnabled - ), - this.booleanRule( - 'cluster.endpoint.allowExternalPatch', - endpoint.allowExternalPatch - ), - this.nonEmptyStringRule('cluster.endpoint.code', endpoint.code) - ) - } - - return rules - } - - private validateAudio(): ValidationRule[] { - const audio = this.options.audio - - const rules: ValidationRule[] = [ - this.booleanRule('audio.loudnessNormalizer', audio?.loudnessNormalizer), - this.nonNegativeIntRule('audio.lookaheadMs', audio?.lookaheadMs), - { - path: 'audio.gateThresholdLUFS', - expected: 'number <= 0', - value: audio?.gateThresholdLUFS, - validate: (v: unknown) => typeof v === 'number' && v <= 0 }, - this.enumRule('audio.quality', audio?.quality, VALID_AUDIO_QUALITIES), - this.enumRule( - 'audio.resamplingQuality', - audio?.resamplingQuality, - VALID_RESAMPLING_QUALITIES - ) - ] - - const fading = audio?.fading - if (fading) { - rules.push(this.booleanRule('audio.fading.enabled', fading.enabled)) - - const fadingEvents = [ - 'trackStart', - 'trackEnd', - 'trackStop', - 'seek', - 'pause', - 'resume' - ] as const - for (const event of fadingEvents) { - const ev = fading[event] - if (!ev) continue - rules.push( - this.nonNegativeIntRule( - `audio.fading.${event}.duration`, - ev.duration - ), - this.enumRule( - `audio.fading.${event}.curve`, - ev.curve, - VALID_FADING_CURVES - ), - this.enumRule( - `audio.fading.${event}.type`, - ev.type, - VALID_FADING_TYPES - ) - ) - } - - const ducking = fading.ducking - if (ducking) { - rules.push( - this.booleanRule('audio.fading.ducking.enabled', ducking.enabled), - this.nonNegativeIntRule( - 'audio.fading.ducking.duration', - ducking.duration - ), - this.enumRule( - 'audio.fading.ducking.curve', - ducking.curve, - VALID_FADING_CURVES - ), - { - path: 'audio.fading.ducking.targetVolume', - expected: 'number between 0 and 1 (inclusive)', - value: ducking.targetVolume, - validate: (v: unknown) => typeof v === 'number' && v >= 0 && v <= 1 + cluster: { + type: 'object', + props: { + enabled: { type: 'boolean', default: true }, + workers: { type: 'number', integer: true, min: 0 }, + minWorkers: { type: 'number', integer: true, min: 0, default: 1 }, + timeouts: { + type: 'object', + optional: true, + props: { + heavyMs: { + type: 'number', + integer: true, + min: 100, + default: 6000 + }, + fastMs: { type: 'number', integer: true, min: 100, default: 4000 } + } } - ) - } - } - - return rules - } - - private validatePlayback(): ValidationRule[] { - const trackStuck = this.options.trackStuckThresholdMs - - return [ - this.intRangeRule( - 'playerUpdateInterval', - this.options.playerUpdateInterval, - 250, - 60000 - ), - this.positiveIntRule( - 'statsUpdateInterval', - this.options.statsUpdateInterval - ), - this.positiveIntRule('eventTimeoutMs', this.options.eventTimeoutMs), - this.booleanRule('enableHoloTracks', this.options.enableHoloTracks), - this.booleanRule( - 'enableTrackStreamEndpoint', - this.options.enableTrackStreamEndpoint - ), - this.booleanRule( - 'enableLoadStreamEndpoint', - this.options.enableLoadStreamEndpoint - ), - this.booleanRule( - 'resolveExternalLinks', - this.options.resolveExternalLinks - ), - this.booleanRule('fetchChannelInfo', this.options.fetchChannelInfo), - { - path: 'trackStuckThresholdMs', - expected: 'integer >= 1000 (milliseconds)', - value: trackStuck, - validate: (v: unknown) => - typeof v === 'number' && Number.isInteger(v) && v >= 1000 - }, - this.intMustExceed( - 'zombieThresholdMs', - this.options.zombieThresholdMs, - trackStuck, - 'trackStuckThresholdMs' - ) - ] - } - - private validateSources(): ValidationRule[] { - const sources = this.options.sources - if (!sources) return [] - - const rules: ValidationRule[] = [] - - const allSources = [ - 'youtube', - 'soundcloud', - 'spotify', - 'tidal', - 'applemusic', - 'audius', - 'jiosaavn', - 'eternalbox', - 'pipertts', - 'pandora', - 'yandexmusic', - 'monochrome', - 'gaana', - 'flowery', - 'lazypytts', - 'qobuz', - 'iheartradio', - 'vkmusic', - 'amazonmusic', - 'bluesky', - 'anghami', - 'rss', - 'songlink', - 'mixcloud', - 'audiomack', - 'deezer', - 'bandcamp', - 'local', - 'http', - 'vimeo', - 'telegram', - 'shazam', - 'bilibili', - 'genius', - 'pinterest', - 'google-tts', - 'instagram', - 'kwai', - 'twitch', - 'nicovideo', - 'reddit', - 'tumblr', - 'twitter', - 'lastfm', - 'letrasmus' - ] - - for (const name of allSources) { - const sourceConfig = (sources as Record)[name] as - | Record - | undefined - if (sourceConfig !== undefined) { - rules.push( - this.booleanRule(`sources.${name}.enabled`, sourceConfig.enabled) - ) - } - } - - rules.push( - ...this.validateSourceSpotify(sources.spotify), - ...this.validateSourceAppleMusic(sources.applemusic), - ...this.validateSourceTidal(sources.tidal), - ...this.validateSourceAudius(sources.audius), - ...this.validateSourceJiosaavn(sources.jiosaavn), - ...this.validateSourceEternalbox(sources.eternalbox), - ...this.validateSourceYoutube(sources.youtube), - ...this.validateSourcePipertts(sources.pipertts), - ...this.validateSourcePandora(sources.pandora), - ...this.validateSourceQobuz(sources.qobuz), - ...this.validateSourceLastfm(sources.lastfm), - ...this.validateSourceBilibili(sources.bilibili), - ...this.validateSourceYandexMusic(sources.yandexmusic), - ...this.validateSourceGaana(sources.gaana), - ...this.validateSourceFlowery(sources.flowery), - ...this.validateSourceLazypytts(sources.lazypytts), - ...this.validateSourceMonochrome(sources.monochrome) - ) - - return rules - } - - private validateSourceSpotify(spotify: unknown): ValidationRule[] { - if ( - typeof spotify !== 'object' || - spotify === null || - !(spotify as Record).enabled - ) - return [] - - const s = spotify as Record - - const rules: ValidationRule[] = [ - this.nonNegativeIntRule( - 'sources.spotify.playlistLoadLimit', - s.playlistLoadLimit - ), - this.nonNegativeIntRule( - 'sources.spotify.albumLoadLimit', - s.albumLoadLimit - ), - this.positiveIntRule( - 'sources.spotify.playlistPageLoadConcurrency', - s.playlistPageLoadConcurrency - ), - this.positiveIntRule( - 'sources.spotify.albumPageLoadConcurrency', - s.albumPageLoadConcurrency - ), - this.booleanRule('sources.spotify.allowLocalFiles', s.allowLocalFiles), - { - path: 'sources.spotify.clientId', - expected: 'non-empty string when sources.spotify.clientSecret is set', - value: s.clientId, - validate: (v: unknown) => - !s.clientSecret || (typeof v === 'string' && v.trim().length > 0) + } }, - { - path: 'sources.spotify.clientSecret', - expected: 'non-empty string when sources.spotify.clientId is set', - value: s.clientSecret, - validate: (v: unknown) => - !s.clientId || (typeof v === 'string' && v.trim().length > 0) + logging: { + type: 'object', + props: { + level: { type: 'string', default: 'info' }, + file: { + type: 'object', + props: { + enabled: { type: 'boolean', default: false }, + path: { type: 'string', default: 'logs' } + } + } + } }, - this.placeholderWarningRule('sources.spotify.clientId', s.clientId), - this.placeholderWarningRule( - 'sources.spotify.clientSecret', - s.clientSecret - ) - ] - - if (s.externalAuthUrl) { - rules.push( - this.urlRule('sources.spotify.externalAuthUrl', s.externalAuthUrl) - ) - } - - return rules - } - - private validateSourceAppleMusic(applemusic: unknown): ValidationRule[] { - if ( - typeof applemusic !== 'object' || - applemusic === null || - !(applemusic as Record).enabled - ) - return [] - - const a = applemusic as Record - - return [ - this.nonNegativeIntRule( - 'sources.applemusic.playlistLoadLimit', - a.playlistLoadLimit - ), - this.nonNegativeIntRule( - 'sources.applemusic.albumLoadLimit', - a.albumLoadLimit - ), - this.positiveIntRule( - 'sources.applemusic.playlistPageLoadConcurrency', - a.playlistPageLoadConcurrency - ), - this.positiveIntRule( - 'sources.applemusic.albumPageLoadConcurrency', - a.albumPageLoadConcurrency - ), - this.placeholderWarningRule( - 'sources.applemusic.mediaApiToken', - a.mediaApiToken, - ['token_here'] - ) - ] - } - - private validateSourceTidal(tidal: unknown): ValidationRule[] { - if ( - typeof tidal !== 'object' || - tidal === null || - !(tidal as Record).enabled - ) - return [] - - const t = tidal as Record - - const rules: ValidationRule[] = [ - this.nonNegativeIntRule( - 'sources.tidal.playlistLoadLimit', - t.playlistLoadLimit - ), - this.positiveIntRule( - 'sources.tidal.playlistPageLoadConcurrency', - t.playlistPageLoadConcurrency - ) - ] - - if (t.token !== undefined) { - rules.push( - { - path: 'sources.tidal.token', - expected: 'string (non-whitespace if provided)', - value: t.token, - validate: (v: unknown) => - typeof v === 'string' && (v === '' || v.trim().length > 0) - }, - this.placeholderWarningRule('sources.tidal.token', t.token, [ - 'token_here' - ]) - ) - } - - return rules - } - - private validateSourceAudius(audius: unknown): ValidationRule[] { - if ( - typeof audius !== 'object' || - audius === null || - !(audius as Record).enabled - ) - return [] - - const au = audius as Record - - return [ - { - path: 'sources.audius.appName', - expected: 'string', - value: au.appName, - validate: (v: unknown) => v === undefined || typeof v === 'string' + connection: { + type: 'object', + props: { + interval: { type: 'number', integer: true, min: 1000 }, + timeout: { type: 'number', integer: true, min: 1000 } + } }, - { - path: 'sources.audius.apiKey', - expected: 'string', - value: au.apiKey, - validate: (v: unknown) => v === undefined || typeof v === 'string' + rateLimit: { + type: 'object', + props: { + enabled: { type: 'boolean', default: true }, + global: { type: 'object' }, + perIp: { type: 'object' } + } }, - { - path: 'sources.audius.apiSecret', - expected: 'string', - value: au.apiSecret, - validate: (v: unknown) => v === undefined || typeof v === 'string' + dosProtection: { + type: 'object', + props: { + enabled: { type: 'boolean', default: true }, + thresholds: { type: 'object' }, + mitigation: { type: 'object' } + } }, - this.nonNegativeIntRule( - 'sources.audius.playlistLoadLimit', - au.playlistLoadLimit - ), - this.nonNegativeIntRule( - 'sources.audius.albumLoadLimit', - au.albumLoadLimit - ), - this.placeholderWarningRule('sources.audius.apiKey', au.apiKey), - this.placeholderWarningRule('sources.audius.apiSecret', au.apiSecret) - ] - } - - private validateSourceJiosaavn(jiosaavn: unknown): ValidationRule[] { - if ( - typeof jiosaavn !== 'object' || - jiosaavn === null || - !(jiosaavn as Record).enabled - ) - return [] - - const j = jiosaavn as Record - - return [ - this.nonNegativeIntRule( - 'sources.jiosaavn.playlistLoadLimit', - j.playlistLoadLimit - ), - this.nonNegativeIntRule( - 'sources.jiosaavn.artistLoadLimit', - j.artistLoadLimit - ) - ] - } - - private validateSourceEternalbox(eternalbox: unknown): ValidationRule[] { - if ( - typeof eternalbox !== 'object' || - eternalbox === null || - !(eternalbox as Record).enabled - ) - return [] - - const e = eternalbox as Record - - return [ - this.urlRule('sources.eternalbox.baseUrl', e.baseUrl), - this.positiveIntRule('sources.eternalbox.searchResults', e.searchResults), - this.positiveIntRule('sources.eternalbox.maxBranches', e.maxBranches), - this.nonNegativeIntRule( - 'sources.eternalbox.cacheMaxBytes', - e.cacheMaxBytes - ), - this.booleanRule('sources.eternalbox.enrichSpotify', e.enrichSpotify), - this.booleanRule('sources.eternalbox.includeAnalysis', e.includeAnalysis), - this.booleanRule('sources.eternalbox.eternalStream', e.eternalStream), - this.booleanRule('sources.eternalbox.infiniteStream', e.infiniteStream), - this.nonNegativeIntRule( - 'sources.eternalbox.maxReconnects', - e.maxReconnects - ), - this.positiveIntRule( - 'sources.eternalbox.reconnectDelayMs', - e.reconnectDelayMs - ), - { - path: 'sources.eternalbox.minRandomBranchChance', - expected: 'number between 0 and 1 (inclusive)', - value: e.minRandomBranchChance, - validate: (v: unknown) => typeof v === 'number' && v >= 0 && v <= 1 + trustProxy: { type: 'boolean', default: false }, + network: { + type: 'object', + props: { + proxy: { + type: 'object', + props: { + enabled: { type: 'boolean', default: false }, + strategy: { + type: 'string', + enum: [ + 'RoundRobin', + 'LeastConnections', + 'LowestLatency', + 'WeightedHealth' + ] + } + } + }, + connection: { + type: 'object', + props: { + interval: { type: 'number', integer: true, min: 1000 }, + timeout: { type: 'number', integer: true, min: 1000 } + } + } + } }, - { - path: 'sources.eternalbox.maxRandomBranchChance', - expected: 'number between 0 and 1 (inclusive)', - value: e.maxRandomBranchChance, - validate: (v: unknown) => typeof v === 'number' && v >= 0 && v <= 1 + search: { + type: 'object', + props: { + maxResults: { + type: 'number', + integer: true, + min: 1, + max: 100, + default: 10 + }, + defaultSource: { + type: 'multi', + rules: [{ type: 'array', items: 'string' }, { type: 'string' }] + }, + unifiedSources: { type: 'array', items: 'string', optional: true }, + resolveExternalLinks: { type: 'boolean', default: false }, + fetchChannelInfo: { type: 'boolean', default: false } + } }, - this.floatMustNotExceed( - 'sources.eternalbox.minRandomBranchChance', - e.minRandomBranchChance, - e.maxRandomBranchChance, - 'sources.eternalbox.maxRandomBranchChance' - ) - ] - } - - private validateSourceYoutube(youtube: unknown): ValidationRule[] { - if (typeof youtube !== 'object' || youtube === null) return [] - const y = youtube as Record - if (!y.enabled || !y.cipher) return [] - const cipher = y.cipher as Record - if (cipher.url === undefined) return [] - - return [this.urlRule('sources.youtube.cipher.url', cipher.url)] - } - - private validateSourcePipertts(pipertts: unknown): ValidationRule[] { - if ( - typeof pipertts !== 'object' || - pipertts === null || - !(pipertts as Record).enabled - ) - return [] - - const p = pipertts as Record - - return [this.urlRule('sources.pipertts.url', p.url)] - } - - private validateSourcePandora(pandora: unknown): ValidationRule[] { - if (typeof pandora !== 'object' || pandora === null) return [] - const pa = pandora as Record - if (!pa.enabled || !pa.remoteTokenUrl) return [] - - return [this.urlRule('sources.pandora.remoteTokenUrl', pa.remoteTokenUrl)] - } - - private validateSourceQobuz(qobuz: unknown): ValidationRule[] { - if ( - typeof qobuz !== 'object' || - qobuz === null || - !(qobuz as Record).enabled - ) - return [] - - const q = qobuz as Record - - return [this.placeholderWarningRule('sources.qobuz.userToken', q.userToken)] - } - - private validateSourceLastfm(lastfm: unknown): ValidationRule[] { - if ( - typeof lastfm !== 'object' || - lastfm === null || - !(lastfm as Record).enabled - ) - return [] - - const l = lastfm as Record - - return [this.placeholderWarningRule('sources.lastfm.apiKey', l.apiKey)] - } - - private validateSourceBilibili(bilibili: unknown): ValidationRule[] { - if ( - typeof bilibili !== 'object' || - bilibili === null || - !(bilibili as Record).enabled - ) - return [] - - const b = bilibili as Record - - return [ - this.placeholderWarningRule('sources.bilibili.sessdata', b.sessdata) - ] - } - - private validateSourceYandexMusic(yandexmusic: unknown): ValidationRule[] { - if ( - typeof yandexmusic !== 'object' || - yandexmusic === null || - !(yandexmusic as Record).enabled - ) - return [] - - const ym = yandexmusic as Record - - return [ - this.nonNegativeIntRule( - 'sources.yandexmusic.artistLoadLimit', - ym.artistLoadLimit - ), - this.nonNegativeIntRule( - 'sources.yandexmusic.albumLoadLimit', - ym.albumLoadLimit - ), - this.nonNegativeIntRule( - 'sources.yandexmusic.playlistLoadLimit', - ym.playlistLoadLimit - ), - this.placeholderWarningRule( - 'sources.yandexmusic.accessToken', - ym.accessToken - ) - ] - } - - private validateSourceGaana(gaana: unknown): ValidationRule[] { - if ( - typeof gaana !== 'object' || - gaana === null || - !(gaana as Record).enabled - ) - return [] - - const g = gaana as Record - - return [ - this.nonNegativeIntRule( - 'sources.gaana.playlistLoadLimit', - g.playlistLoadLimit - ), - this.nonNegativeIntRule('sources.gaana.albumLoadLimit', g.albumLoadLimit), - this.nonNegativeIntRule( - 'sources.gaana.artistLoadLimit', - g.artistLoadLimit - ) - ] - } - - private validateSourceFlowery(flowery: unknown): ValidationRule[] { - if ( - typeof flowery !== 'object' || - flowery === null || - !(flowery as Record).enabled - ) - return [] - - const fl = flowery as Record - - return [ - this.positiveNumberRule('sources.flowery.speed', fl.speed), - this.nonNegativeIntRule('sources.flowery.silence', fl.silence), - this.booleanRule('sources.flowery.translate', fl.translate), - this.booleanRule('sources.flowery.enforceConfig', fl.enforceConfig) - ] - } - - private validateSourceLazypytts(lazypytts: unknown): ValidationRule[] { - if ( - typeof lazypytts !== 'object' || - lazypytts === null || - !(lazypytts as Record).enabled - ) - return [] - - const lp = lazypytts as Record - - return [ - this.positiveIntRule('sources.lazypytts.maxTextLength', lp.maxTextLength), - this.booleanRule('sources.lazypytts.enforceConfig', lp.enforceConfig) - ] - } - - private validateSourceMonochrome(monochrome: unknown): ValidationRule[] { - if ( - typeof monochrome !== 'object' || - monochrome === null || - !(monochrome as Record).enabled - ) - return [] - - const m = monochrome as Record - - return [ - this.stringArrayRule('sources.monochrome.instances', m.instances), - this.stringArrayRule( - 'sources.monochrome.streamingInstances', - m.streamingInstances - ), - { - path: 'sources.monochrome.quality', - expected: 'one of [HI_RES_LOSSLESS, LOSSLESS, HIGH, LOW]', - value: m.quality, - validate: (v: unknown) => - ['HI_RES_LOSSLESS', 'LOSSLESS', 'HIGH', 'LOW'].includes(v as string) - } - ] - } - - private validateSearch(): ValidationRule[] { - const rules: ValidationRule[] = [ - this.intRangeRule( - 'maxSearchResults', - this.options.maxSearchResults, - 1, - 100 - ), - this.intRangeRule( - 'maxAlbumPlaylistLength', - this.options.maxAlbumPlaylistLength, - 1, - 500 - ), - { - path: 'defaultSearchSource', - expected: - 'string or non-empty string[] of enabled source names in config.sources', - value: this.options.defaultSearchSource, - validate: (v: unknown) => { - const sources = this.options.sources - if (!sources) return false - const sourcesRecord = sources as Record - if (typeof v === 'string') - return ( - (sourcesRecord[v] as Record)?.enabled === true - ) - if (Array.isArray(v)) { - if (v.length === 0) return false - return v.every( - (name: unknown) => - typeof name === 'string' && - (sourcesRecord[name] as Record)?.enabled === - true - ) - } - return false + playback: { + type: 'object', + props: { + maxPlaylistLength: { + type: 'number', + integer: true, + min: 0, + default: 100 + }, + playerUpdateInterval: { + type: 'number', + integer: true, + min: 100, + default: 2000, + optional: true + }, + statsUpdateInterval: { + type: 'number', + integer: true, + min: 100, + default: 30000, + optional: true + }, + trackStuckThresholdMs: { + type: 'number', + integer: true, + min: 100, + default: 10000, + optional: true + }, + eventTimeoutMs: { + type: 'number', + integer: true, + min: 100, + default: 3000, + optional: true + }, + zombieThresholdMs: { + type: 'number', + integer: true, + min: 100, + default: 300000, + optional: true + }, + sponsorblock: { + type: 'object', + optional: true, + props: { + enabled: { type: 'boolean', default: false }, + api: { type: 'string', optional: true }, + categories: { type: 'array', items: 'string', optional: true }, + actionTypes: { type: 'array', items: 'string', optional: true } + } + }, + filters: { type: 'object', optional: true }, + audio: { + type: 'object', + optional: true, + props: { + quality: { + type: 'string', + enum: ['high', 'medium', 'low', 'lowest'] + }, + encryption: { type: 'string', optional: true }, + resamplingQuality: { type: 'string', optional: true }, + loudnessNormalizer: { type: 'boolean', optional: true }, + fading: { type: 'object', optional: true }, + crossfade: { type: 'object', optional: true } + } + }, + voiceReceive: { type: 'object', optional: true }, + mix: { type: 'object', optional: true } } - } - ] - - const unified = this.options.unifiedSearchSources - if (unified !== undefined) { - rules.push({ - path: 'unifiedSearchSources', - expected: - 'non-empty string[] of enabled source names in config.sources', - value: unified, - validate: (v: unknown) => { - const sources = this.options.sources - if (!sources || !Array.isArray(v) || v.length === 0) return false - const sourcesRecord = sources as Record - return v.every( - (name: unknown) => - typeof name === 'string' && - (sourcesRecord[name] as Record)?.enabled === true - ) + }, + api: { + type: 'object', + props: { + enableTrackStreamEndpoint: { type: 'boolean', default: false }, + enableLoadStreamEndpoint: { type: 'boolean', default: false }, + metrics: { type: 'object', optional: true } } - }) - } - - return rules - } - - private validateRoutePlanner(): ValidationRule[] { - const routePlanner = this.options.routePlanner - if (!routePlanner) return [] - - const rules: ValidationRule[] = [ - this.enumRule( - 'routePlanner.strategy', - routePlanner.strategy, - VALID_ROUTE_STRATEGIES - ) - ] - - if (routePlanner.bannedIpCooldown !== undefined) { - rules.push( - this.positiveIntRule( - 'routePlanner.bannedIpCooldown', - routePlanner.bannedIpCooldown - ) - ) - } - - return rules - } - - private validateRateLimit(): ValidationRule[] { - const rateLimit = this.options.rateLimit - if (!rateLimit || rateLimit.enabled === false) return [] - - const rules: ValidationRule[] = [ - this.booleanRule('rateLimit.enabled', rateLimit.enabled) - ] - - type RateLimitSection = { maxRequests: number; timeWindowMs: number } - - const sections = ['global', 'perIp', 'perUserId', 'perGuildId'] as const - let prevSection: string | null = null - let prevCfg: RateLimitSection | null = null - - for (const section of sections) { - const cfg = rateLimit[section] as RateLimitSection | undefined - if (!cfg) { - continue - } - - rules.push( - this.positiveIntRule( - `rateLimit.${section}.maxRequests`, - cfg.maxRequests - ), - this.positiveIntRule( - `rateLimit.${section}.timeWindowMs`, - cfg.timeWindowMs - ) - ) - - if (prevSection !== null && prevCfg !== null) { - const capturedPrevSection = prevSection - const capturedPrevCfg = prevCfg - rules.push( - this.intMustNotExceed( - `rateLimit.${section}.maxRequests`, - cfg.maxRequests, - capturedPrevCfg.maxRequests, - `rateLimit.${capturedPrevSection}.maxRequests` - ), - this.intMustNotExceed( - `rateLimit.${section}.timeWindowMs`, - cfg.timeWindowMs, - capturedPrevCfg.timeWindowMs, - `rateLimit.${capturedPrevSection}.timeWindowMs` - ) - ) - } - - prevSection = section - prevCfg = cfg - } - - return rules - } - - private validateDosProtection(): ValidationRule[] { - const dos = this.options.dosProtection - if (!dos) return [] - - const rules: ValidationRule[] = [ - this.booleanRule('dosProtection.enabled', dos.enabled) - ] - - if (dos.thresholds) { - rules.push( - this.positiveIntRule( - 'dosProtection.thresholds.burstRequests', - dos.thresholds.burstRequests - ), - this.positiveIntRule( - 'dosProtection.thresholds.timeWindowMs', - dos.thresholds.timeWindowMs - ) - ) - } - - if (dos.mitigation) { - rules.push( - this.nonNegativeIntRule( - 'dosProtection.mitigation.delayMs', - dos.mitigation.delayMs - ), - this.positiveIntRule( - 'dosProtection.mitigation.blockDurationMs', - dos.mitigation.blockDurationMs - ) - ) - } - - return rules - } - - private validateLogging(): ValidationRule[] { - const logging = this.options.logging - if (!logging) return [] - - const rules: ValidationRule[] = [] - - if (logging.file) { - rules.push( - this.booleanRule('logging.file.enabled', logging.file.enabled), - this.positiveIntRule('logging.file.ttlDays', logging.file.ttlDays) - ) - - if (logging.file.enabled) { - rules.push( - this.nonEmptyStringRule('logging.file.path', logging.file.path) - ) - } - } - - if (logging.debug) { - const debugFields = [ - 'all', - 'request', - 'session', - 'player', - 'filters', - 'sources', - 'lyrics', - 'youtube', - 'youtube-cipher', - 'sabr', - 'potoken' - ] as const - for (const field of debugFields) { - if (logging.debug[field] !== undefined) { - rules.push( - this.booleanRule(`logging.debug.${field}`, logging.debug[field]) - ) + }, + experimental: { + type: 'object', + props: { + enableHoloTracks: { type: 'boolean', default: false } } - } - } - - return rules - } - - private validateConnection(): ValidationRule[] { - const connection = this.options.connection - if (!connection) return [] - - const rules: ValidationRule[] = [ - this.booleanRule('connection.logAllChecks', connection.logAllChecks), - this.positiveIntRule('connection.interval', connection.interval), - this.positiveIntRule('connection.timeout', connection.timeout) - ] - - if (connection.thresholds) { - rules.push( - this.positiveNumberRule( - 'connection.thresholds.bad', - connection.thresholds.bad - ), - this.positiveNumberRule( - 'connection.thresholds.average', - connection.thresholds.average - ), - this.floatMustBeBelow( - 'connection.thresholds.bad', - connection.thresholds.bad, - connection.thresholds.average, - 'connection.thresholds.average' + }, + sources: { type: 'object' }, + lyrics: { type: 'object' }, + meanings: { type: 'object' }, + metrics: { type: 'object' }, + mix: { type: 'object' }, + plugins: { type: 'array', items: 'object', optional: true }, + pluginConfig: { type: 'object', optional: true } + } + + const check = validator.compile(schema) + const result = check(this.config) + + if (result !== true) { + const errors = Array.isArray(result) ? result : [] + for (const error of errors) { + logger( + 'error', + 'Config', + `Validation error at ${error.field}: ${error.message}` ) - ) - } - - return rules - } - - private validateVoiceReceive(): ValidationRule[] { - const voiceReceive = this.options.voiceReceive - if (!voiceReceive) return [] - - return [ - this.booleanRule('voiceReceive.enabled', voiceReceive.enabled), - this.enumRule( - 'voiceReceive.format', - voiceReceive.format, - VALID_VOICE_FORMATS - ) - ] - } - - private validateMix(): ValidationRule[] { - const mix = this.options.mix - if (!mix) return [] - - return [ - this.booleanRule('mix.enabled', mix.enabled), - this.positiveIntRule('mix.maxLayersMix', mix.maxLayersMix), - this.booleanRule('mix.autoCleanup', mix.autoCleanup), - { - path: 'mix.defaultVolume', - expected: 'number between 0 and 1 (inclusive)', - value: mix.defaultVolume, - validate: (v: unknown) => typeof v === 'number' && v >= 0 && v <= 1 } - ] - } - - private validateMetrics(): ValidationRule[] { - const metrics = this.options.metrics - if (!metrics) return [] - - const rules: ValidationRule[] = [ - this.booleanRule('metrics.enabled', metrics.enabled) - ] - - if (metrics.authorization) { - rules.push( - this.enumRule( - 'metrics.authorization.type', - metrics.authorization.type, - VALID_METRICS_AUTH_TYPES - ) + throw new Error( + `Configuration validation failed: ${errors.map((e) => e.message).join(', ')}` ) } - return rules - } - - private validateFilters(): ValidationRule[] { - const filters = this.options.filters - if (filters === undefined) return [] - - if (filters === null || typeof filters !== 'object') { - return [ - { - path: 'filters', - expected: 'object with an enabled key', - value: filters, - validate: () => false - } - ] - } - - if (!('enabled' in filters)) { - return [ - { - path: 'filters.enabled', - expected: 'object of filter flags', - value: undefined, - validate: () => false - } - ] - } - - if (filters.enabled === null || typeof filters.enabled !== 'object') { - return [ - { - path: 'filters.enabled', - expected: 'object of filter flags', - value: filters.enabled, - validate: () => false - } - ] - } - - if (Object.keys(filters.enabled).length === 0) return [] - - const filterFields = [ - 'tremolo', - 'vibrato', - 'lowpass', - 'highpass', - 'rotation', - 'karaoke', - 'distortion', - 'channelMix', - 'equalizer', - 'chorus', - 'compressor', - 'echo', - 'phaser', - 'timescale' - ] as const - - return filterFields - .filter((f) => filters.enabled[f] !== undefined) - .map((f) => this.booleanRule(`filters.enabled.${f}`, filters.enabled[f])) - } - - private placeholderWarningRule( - path: string, - value: unknown, - except: string[] = [] - ): ValidationRule { - return { - path, - expected: 'non-placeholder value', - value, - validate: (v: unknown) => { - if ( - typeof v === 'string' && - KNOWN_PLACEHOLDERS.has(v) && - !except.includes(v) - ) { - this.warnings.push({ - path, - message: `Value "${v}" looks like an unfilled placeholder. The source may fail to authenticate at runtime.` - }) - } - return true - } - } - } - - private nonNegativeIntRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'integer >= 0', - value, - validate: (v: unknown) => - typeof v === 'number' && Number.isInteger(v) && v >= 0 - } - } - - private positiveIntRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'integer > 0', - value, - validate: (v: unknown) => - typeof v === 'number' && Number.isInteger(v) && v > 0 - } - } - - private intRangeRule( - path: string, - value: unknown, - min: number, - max: number - ): ValidationRule { - return { - path, - expected: `integer between ${min} and ${max}`, - value, - validate: (v: unknown) => - typeof v === 'number' && Number.isInteger(v) && v >= min && v <= max - } - } - - private booleanRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'boolean', - value, - validate: (v: unknown) => typeof v === 'boolean' - } - } - - private nonEmptyStringRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'non-empty string', - value, - validate: (v: unknown) => typeof v === 'string' && v.trim().length > 0 - } - } - - private enumRule( - path: string, - value: unknown, - allowed: Set - ): ValidationRule { - const label = [...allowed].join(', ') - return { - path, - expected: `one of [${label}]`, - value, - validate: (v: unknown) => allowed.has(v as string) - } - } - - private urlRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'valid http or https URL (e.g. https://example.com)', - value, - validate: (v: unknown) => { - if (typeof v !== 'string' || v.trim().length === 0) return false - if (v !== v.trim()) { - this.warnings.push({ - path, - message: `URL value has leading or trailing whitespace. This may cause issues at runtime.` - }) - } - try { - const url = new URL(v.trim()) - return url.protocol === 'http:' || url.protocol === 'https:' - } catch { - return false - } - } - } - } - - private intMustExceed( - path: string, - value: unknown, - dependency: unknown, - dependencyPath: string - ): ValidationRule { - return { - path, - expected: `integer > ${dependencyPath} (${dependency})`, - value, - validate: (v: unknown) => - typeof v === 'number' && - Number.isInteger(v) && - typeof dependency === 'number' && - Number.isInteger(dependency) && - v > dependency - } - } - - private intMustNotExceed( - path: string, - value: unknown, - dependency: unknown, - dependencyPath: string - ): ValidationRule { - return { - path, - expected: `integer <= ${dependencyPath} (${dependency})`, - value, - validate: (v: unknown) => - typeof v === 'number' && - Number.isInteger(v) && - typeof dependency === 'number' && - Number.isInteger(dependency) && - v <= dependency - } - } - - private floatMustNotExceed( - path: string, - value: unknown, - dependency: unknown, - dependencyPath: string - ): ValidationRule { - return { - path, - expected: `number <= ${dependencyPath} (${dependency})`, - value, - validate: (v: unknown) => - typeof v === 'number' && - typeof dependency === 'number' && - v <= dependency - } - } - - private floatMustBeBelow( - path: string, - value: unknown, - dependency: unknown, - dependencyPath: string - ): ValidationRule { - return { - path, - expected: `number < ${dependencyPath} (${dependency})`, - value, - validate: (v: unknown) => - typeof v === 'number' && - typeof dependency === 'number' && - v < dependency - } - } - - private positiveNumberRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'number > 0', - value, - validate: (v: unknown) => typeof v === 'number' && v > 0 - } - } - - private stringArrayRule(path: string, value: unknown): ValidationRule { - return { - path, - expected: 'array of strings', - value, - validate: (v: unknown) => - Array.isArray(v) && v.every((item) => typeof item === 'string') - } + logger('info', 'Config', 'Configuration validated successfully.') } } diff --git a/src/managers/connectionManager.ts b/src/managers/connectionManager.ts index 42df3b33..da9236ef 100644 --- a/src/managers/connectionManager.ts +++ b/src/managers/connectionManager.ts @@ -70,7 +70,8 @@ export default class ConnectionManager { constructor(nodelink: ConnectionManagerContext) { this.nodelink = nodelink - this.config = nodelink.options.connection || {} + this.config = + nodelink.options.network?.connection || nodelink.options.connection || {} this.interval = null this.status = 'unknown' this.metrics = { timestamp: Date.now() } @@ -80,9 +81,6 @@ export default class ConnectionManager { this._lastPingMs = undefined } - /** - * Starts the periodic connection monitor. - */ start(): void { const checkInterval = Math.max(1, this.config.interval || 300000) if (checkInterval > 0) { @@ -91,8 +89,14 @@ export default class ConnectionManager { 'ConnectionManager', `Starting connection checks every ${checkInterval}ms.` ) - this.checkConnection() - this.interval = setInterval(() => this.checkConnection(), checkInterval) + // Delay the first check so it doesn't feel like part of the startup latency + setTimeout(() => { + this.checkConnection().catch(() => {}) + }, 5000) + this.interval = setInterval( + () => this.checkConnection().catch(() => {}), + checkInterval + ) } } @@ -106,6 +110,13 @@ export default class ConnectionManager { } } + /** + * Stops the monitor and releases resources. + */ + destroy(): void { + this.stop() + } + /** * Runs a full connectivity check and updates metrics. */ diff --git a/src/managers/credentialManager.ts b/src/managers/credentialManager.ts index 31a21456..6590cfa3 100644 --- a/src/managers/credentialManager.ts +++ b/src/managers/credentialManager.ts @@ -1,11 +1,9 @@ -import crypto from 'node:crypto' -import fs from 'node:fs/promises' +import type { NodelinkConfig } from '../typings/config/config.types.ts' import type { CredentialEntry, - CredentialManagerStats, - CredentialStorePayload + CredentialManagerStats } from '../typings/modules/credential.types.ts' -import { logger } from '../utils.ts' +import BaseCacheManager from './baseCacheManager.ts' const CREDENTIALS_SALT = 'nodelink-salt' const CREDENTIALS_VERSION = 1 @@ -14,23 +12,12 @@ const DEFAULT_CREDENTIALS_PATH = './.cache/credentials.bin' const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 1000 type CredentialManagerContext = { - options: Record + options: NodelinkConfig } -const isRecord = (value: unknown): value is Record => +const _isRecord = (value: unknown): value is Record => typeof value === 'object' && value !== null && !Array.isArray(value) -const getErrorMessage = (error: unknown): string => - error instanceof Error ? error.message : String(error ?? 'Unknown error') - -const getErrorCode = (error: unknown): string | undefined => { - if (!error || typeof error !== 'object' || !('code' in error)) { - return undefined - } - const code = (error as NodeJS.ErrnoException).code - return typeof code === 'string' ? code : undefined -} - /** * Encrypted credential store with TTL support and debounced persistence. * @remarks @@ -44,122 +31,27 @@ const getErrorCode = (error: unknown): string | undefined => { * ``` * @public */ -export default class CredentialManager { +export default class CredentialManager extends BaseCacheManager { private readonly nodelink: CredentialManagerContext - private readonly password: string - private key: Buffer - private legacyKey: Buffer | null - private readonly filePath: string - private readonly tempFilePath: string - private readonly saveDelayMs: number - private credentials: Map> - private saveTimeout: NodeJS.Timeout | null - private cleanupInterval: NodeJS.Timeout | null - private savePromise: Promise | null - private saveQueued: boolean - private lastLoadedAt: number | null - private lastSavedAt: number | null /** * Creates a new credential manager instance. * @param nodelink - NodeLink runtime used to derive the encryption key. */ constructor(nodelink: CredentialManagerContext) { - this.nodelink = nodelink - this.password = this._resolvePassword(nodelink.options) - this.key = this._deriveFastKey(this.password) - this.legacyKey = null - this.filePath = DEFAULT_CREDENTIALS_PATH - this.tempFilePath = `${DEFAULT_CREDENTIALS_PATH}.tmp` - this.saveDelayMs = DEFAULT_SAVE_DELAY_MS - this.credentials = new Map() - this.saveTimeout = null - this.cleanupInterval = setInterval(() => { - const expiredCount = this._purgeExpired() - if (expiredCount > 0) this.save() - }, DEFAULT_CLEANUP_INTERVAL_MS) - this.cleanupInterval.unref?.() - this.savePromise = null - this.saveQueued = false - this.lastLoadedAt = null - this.lastSavedAt = null - } - - /** - * Loads and decrypts credential data from disk. - * @remarks Purges expired entries and persists if cleanup occurs. - */ - async load(): Promise { - try { - const data = await fs.readFile(this.filePath) - if (data.length < 32) return - - let payload: CredentialStorePayload - let migratedFromLegacy = false - - try { - payload = this._decodePayload(data, this.key) - } catch { - const legacyKey = this._getLegacyKey() - payload = this._decodePayload(data, legacyKey) - migratedFromLegacy = true - } - - this.credentials = new Map(Object.entries(payload.entries)) - const expiredCount = this._purgeExpired() - if (expiredCount > 0 || migratedFromLegacy) this.save() - - this.lastLoadedAt = Date.now() - logger( - 'debug', - 'Credentials', - `Loaded ${this.credentials.size} encrypted credentials from disk.` - ) - } catch (error) { - const code = getErrorCode(error) - if (code !== 'ENOENT') { - logger( - 'error', - 'Credentials', - `Failed to decrypt credentials: ${getErrorMessage(error)}` - ) - } - this.credentials = new Map() - } - } - - /** - * Debounces credential persistence to disk. - */ - save(): void { - if (this.saveTimeout) return - - this.saveTimeout = setTimeout(() => { - this.saveTimeout = null - void this.forceSave() - }, this.saveDelayMs) - } - - /** - * Forces credentials to be written immediately. - */ - async forceSave(): Promise { - if (this.saveTimeout) { - clearTimeout(this.saveTimeout) - this.saveTimeout = null - } + const password = CredentialManager._resolvePassword(nodelink.options) + + super({ + name: 'Credentials', + passwordHashKey: password, + salt: CREDENTIALS_SALT, + filePath: DEFAULT_CREDENTIALS_PATH, + saveDelayMs: DEFAULT_SAVE_DELAY_MS, + cleanupIntervalMs: DEFAULT_CLEANUP_INTERVAL_MS, + version: CREDENTIALS_VERSION + }) - try { - this._purgeExpired() - await this._flushSaveQueue() - logger('debug', 'Credentials', 'Force saved credentials to disk.') - } catch (error) { - logger( - 'error', - 'Credentials', - `Failed to force save credentials: ${getErrorMessage(error)}` - ) - } + this.nodelink = nodelink } /** @@ -181,7 +73,7 @@ export default class CredentialManager { const entry = this._getValidEntry(key) if (!entry) return null return { - ...(entry as CredentialEntry) + ...(entry as unknown as CredentialEntry) } } @@ -193,9 +85,10 @@ export default class CredentialManager { */ set(key: string, value: T, ttlMs = 0): void { const now = Date.now() - const current = this.credentials.get(key) + const current = this.cache.get(key) const expiresAt = ttlMs > 0 ? now + ttlMs : null - this.credentials.set(key, { + + this.cache.set(key, { value, createdAt: current?.createdAt ?? now, updatedAt: now, @@ -210,7 +103,7 @@ export default class CredentialManager { * @returns True if an entry was removed. */ delete(key: string): boolean { - const existed = this.credentials.delete(key) + const existed = this.cache.delete(key) if (existed) this.save() return existed } @@ -223,261 +116,28 @@ export default class CredentialManager { return this._getValidEntry(key) !== null } - /** - * Clears all stored credentials. - */ - clear(): void { - if (this.credentials.size === 0) return - this.credentials.clear() - this.save() - } - /** * Returns runtime statistics for credential storage. */ getStats(): CredentialManagerStats { const now = Date.now() - const expiredEntries = this._countExpired(now) + let expiredEntries = 0 + for (const entry of this.cache.values()) { + if (entry.expiresAt && now > entry.expiresAt) expiredEntries++ + } return { - totalEntries: this.credentials.size, + totalEntries: this.cache.size, expiredEntries, lastLoadedAt: this.lastLoadedAt ?? undefined, lastSavedAt: this.lastSavedAt ?? undefined } } - private _resolvePassword(options: Record): string { - const optionsCandidate = options as { server?: unknown } - const serverCandidate = optionsCandidate.server - const server = isRecord(serverCandidate) - ? (serverCandidate as { password?: unknown }) - : null - const password = - server && typeof server.password === 'string' ? server.password : null + private static _resolvePassword(options: NodelinkConfig): string { + const password = options.server?.password if (!password) { throw new Error('CredentialManager requires options.server.password') } return password } - - private _deriveFastKey(password: string): Buffer { - return crypto - .createHash('sha256') - .update(`${CREDENTIALS_SALT}:${password}`) - .digest() - } - - private _getLegacyKey(): Buffer { - if (!this.legacyKey) { - this.legacyKey = crypto.scryptSync(this.password, CREDENTIALS_SALT, 32) - } - - return this.legacyKey - } - - private _getValidEntry(key: string): CredentialEntry | null { - const entry = this.credentials.get(key) - if (!entry) return null - if (entry.expiresAt && Date.now() > entry.expiresAt) { - this.credentials.delete(key) - this.save() - return null - } - return entry - } - - private _purgeExpired(): number { - const now = Date.now() - let expiredCount = 0 - for (const [key, entry] of this.credentials.entries()) { - if (entry.expiresAt && now > entry.expiresAt) { - this.credentials.delete(key) - expiredCount++ - } - } - return expiredCount - } - - private _countExpired(now: number): number { - let expiredCount = 0 - for (const entry of this.credentials.values()) { - if (entry.expiresAt && now > entry.expiresAt) expiredCount++ - } - return expiredCount - } - - private _decodePayload(data: Buffer, key: Buffer): CredentialStorePayload { - const iv = data.subarray(0, 16) - const tag = data.subarray(16, 32) - const encrypted = data.subarray(32) - - const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv) - decipher.setAuthTag(tag) - - const decrypted = Buffer.concat([ - decipher.update(encrypted), - decipher.final() - ]).toString('utf8') - const parsed = JSON.parse(decrypted) as unknown - return this._normalizePayload(parsed) - } - - private _normalizePayload(raw: unknown): CredentialStorePayload { - const now = Date.now() - if (isRecord(raw)) { - const payloadCandidate = raw as Partial & { - entries?: unknown - savedAt?: unknown - } - const entriesValue = payloadCandidate.entries - if (isRecord(entriesValue)) { - const entries = this._normalizeEntries(entriesValue, now) - const savedAt = - typeof payloadCandidate.savedAt === 'number' - ? payloadCandidate.savedAt - : now - return { - version: CREDENTIALS_VERSION, - savedAt, - entries - } - } - - return { - version: CREDENTIALS_VERSION, - savedAt: now, - entries: this._normalizeEntries(raw, now) - } - } - - return { - version: CREDENTIALS_VERSION, - savedAt: now, - entries: {} - } - } - - private _normalizeEntries( - rawEntries: Record, - fallbackTime: number - ): Record> { - const entries: Record> = {} - - for (const [key, value] of Object.entries(rawEntries)) { - entries[key] = this._normalizeEntry(value, fallbackTime) - } - - return entries - } - - private _normalizeEntry( - rawValue: unknown, - fallbackTime: number - ): CredentialEntry { - if (isRecord(rawValue)) { - const entryCandidate = rawValue as Partial> & { - value?: unknown - } - const value = Object.hasOwn(entryCandidate, 'value') - ? entryCandidate.value - : rawValue - const createdAt = - typeof entryCandidate.createdAt === 'number' - ? entryCandidate.createdAt - : fallbackTime - const updatedAt = - typeof entryCandidate.updatedAt === 'number' - ? entryCandidate.updatedAt - : createdAt - const expiresAt = - typeof entryCandidate.expiresAt === 'number' && - entryCandidate.expiresAt > 0 - ? entryCandidate.expiresAt - : null - - return { - value, - createdAt, - updatedAt, - expiresAt - } - } - - return { - value: rawValue, - createdAt: fallbackTime, - updatedAt: fallbackTime, - expiresAt: null - } - } - - private _buildPayload(): CredentialStorePayload { - return { - version: CREDENTIALS_VERSION, - savedAt: Date.now(), - entries: Object.fromEntries(this.credentials) - } - } - - private async _flushSaveQueue(): Promise { - if (this.savePromise) { - this.saveQueued = true - await this.savePromise - if (this.saveQueued) { - this.saveQueued = false - await this._flushSaveQueue() - } - return - } - - const payload = this._buildPayload() - this.savePromise = this._writeToDisk(payload) - try { - await this.savePromise - } finally { - this.savePromise = null - } - - if (this.saveQueued) { - this.saveQueued = false - await this._flushSaveQueue() - } - } - - private async _writeToDisk(payload: CredentialStorePayload): Promise { - const plainText = JSON.stringify(payload) - const iv = crypto.randomBytes(16) - const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv) - - const encrypted = Buffer.concat([ - cipher.update(plainText, 'utf8'), - cipher.final() - ]) - const tag = cipher.getAuthTag() - const outBuffer = Buffer.concat([iv, tag, encrypted]) - - await fs.mkdir('./.cache', { recursive: true }) - try { - await fs.writeFile(this.tempFilePath, outBuffer) - await fs.rename(this.tempFilePath, this.filePath) - } catch (error) { - logger( - 'debug', - 'Credentials', - `Atomic save failed, falling back to direct write: ${getErrorMessage(error)}` - ) - await fs.writeFile(this.filePath, outBuffer) - try { - await fs.unlink(this.tempFilePath) - } catch (cleanupError) { - logger( - 'debug', - 'Credentials', - `Failed to remove temp credentials file: ${getErrorMessage(cleanupError)}` - ) - } - } - - this.lastSavedAt = payload.savedAt - } } diff --git a/src/managers/dosProtectionManager.ts b/src/managers/dosProtectionManager.ts index ec731e3d..6e20c19d 100644 --- a/src/managers/dosProtectionManager.ts +++ b/src/managers/dosProtectionManager.ts @@ -11,6 +11,14 @@ import { logger } from '../utils.ts' type DosProtectionContext = { options?: { dosProtection?: Partial + api?: { + dosProtection?: Partial + [key: string]: unknown + } + security?: { + dosProtection?: Partial + [key: string]: unknown + } } } @@ -58,7 +66,11 @@ export default class DosProtectionManager { */ constructor(nodelink: DosProtectionContext) { this.nodelink = nodelink - this.config = this._resolveConfig(nodelink.options?.dosProtection) + this.config = this._resolveConfig( + nodelink.options?.api?.dosProtection ?? + nodelink.options?.security?.dosProtection ?? + nodelink.options?.dosProtection + ) this.ipRequestCounts = new Map() this.cleanupInterval = setInterval( () => this._cleanup(), diff --git a/src/managers/groupManager.ts b/src/managers/groupManager.ts new file mode 100644 index 00000000..a44dd7f0 --- /dev/null +++ b/src/managers/groupManager.ts @@ -0,0 +1,189 @@ +import type { + GroupStateJSON, + PlayerGroup +} from '../typings/playback/group.types.ts' +import { logger } from '../utils.ts' + +/** + * Manages groups of players within a session for multi-guild synchronization. + * + * @remarks + * A group is a pure orchestration layer — it does not share streams, decoders, + * or buffers between players. Each player in a group keeps its own independent + * audio pipeline (decoder, FlowController, OpusEncoder, voice connection). + * + * The group provides a single API surface to apply the same operations + * (play, pause, seek, volume, filters, etc.) to all member players at once, + * while still allowing individual player control. + * + * This is designed for radio bots that need to keep N guilds synchronized + * on the same track and position. + */ +export default class GroupManager { + /** + * Map of group ID to PlayerGroup. + */ + private readonly groups: Map = new Map() + + /** + * Creates a new player group. + * + * @param id - Unique group identifier. + * @param guildIds - Initial set of guild IDs to include. + * @returns The created group. + * @throws Error if a group with the same ID already exists. + */ + create(id: string, guildIds: string[] = []): PlayerGroup { + if (this.groups.has(id)) { + throw new Error(`Group '${id}' already exists`) + } + + const group: PlayerGroup = { + id, + guildIds: new Set(guildIds), + createdAt: Date.now() + } + + this.groups.set(id, group) + + logger( + 'debug', + 'GroupManager', + `Group '${id}' created with ${guildIds.length} player(s)` + ) + + return group + } + + /** + * Retrieves a group by ID. + * + * @param id - Group identifier. + * @returns The group, or `undefined` if not found. + */ + get(id: string): PlayerGroup | undefined { + return this.groups.get(id) + } + + /** + * Checks whether a group exists. + * + * @param id - Group identifier. + * @returns `true` when the group exists. + */ + has(id: string): boolean { + return this.groups.has(id) + } + + /** + * Deletes a group. Does not destroy the member players. + * + * @param id - Group identifier. + * @returns `true` if the group existed and was deleted. + */ + delete(id: string): boolean { + const existed = this.groups.delete(id) + + if (existed) { + logger('debug', 'GroupManager', `Group '${id}' deleted`) + } + + return existed + } + + /** + * Adds a guild to a group. + * + * @param groupId - Target group identifier. + * @param guildId - Guild to add. + * @throws Error if the group does not exist. + */ + addPlayer(groupId: string, guildId: string): void { + const group = this.groups.get(groupId) + if (!group) throw new Error(`Group '${groupId}' not found`) + + group.guildIds.add(guildId) + + logger( + 'debug', + 'GroupManager', + `Added guild ${guildId} to group '${groupId}' (${group.guildIds.size} member(s))` + ) + } + + /** + * Removes a guild from a group. + * + * @param groupId - Target group identifier. + * @param guildId - Guild to remove. + * @throws Error if the group does not exist. + */ + removePlayer(groupId: string, guildId: string): void { + const group = this.groups.get(groupId) + if (!group) throw new Error(`Group '${groupId}' not found`) + + group.guildIds.delete(guildId) + + logger( + 'debug', + 'GroupManager', + `Removed guild ${guildId} from group '${groupId}' (${group.guildIds.size} member(s))` + ) + } + + /** + * Returns the guild IDs for a group. + * + * @param groupId - Target group identifier. + * @returns Array of guild IDs, or empty array if group not found. + */ + getGuildIds(groupId: string): string[] { + const group = this.groups.get(groupId) + return group ? Array.from(group.guildIds) : [] + } + + /** + * Lists all groups as JSON. + * + * @returns Array of serialized group states. + */ + list(): GroupStateJSON[] { + return Array.from(this.groups.values()).map((g) => this._toJSON(g)) + } + + /** + * Serializes a specific group to JSON. + * + * @param groupId - Target group identifier. + * @returns Serialized group state, or `null` if not found. + */ + toJSON(groupId: string): GroupStateJSON | null { + const group = this.groups.get(groupId) + return group ? this._toJSON(group) : null + } + + /** + * Destroys all groups. Called during session cleanup. + */ + destroy(): void { + this.groups.clear() + } + + /** + * Returns the number of groups. + */ + get size(): number { + return this.groups.size + } + + /** + * Internal JSON serialization helper. + */ + private _toJSON(group: PlayerGroup): GroupStateJSON { + return { + id: group.id, + guildIds: Array.from(group.guildIds), + createdAt: group.createdAt + } + } +} diff --git a/src/managers/lyricsManager.ts b/src/managers/lyricsManager.ts index f4de566e..e30f5ced 100644 --- a/src/managers/lyricsManager.ts +++ b/src/managers/lyricsManager.ts @@ -2,6 +2,7 @@ import fs from 'node:fs/promises' import path from 'node:path' import { fileURLToPath } from 'node:url' import { alignLyrics } from '../modules/lyricsAligner.ts' +import type { NodelinkConfig } from '../typings/config/config.types.ts' import type { SourceResult } from '../typings/sources/source.types.ts' import { logger } from '../utils.ts' @@ -83,10 +84,7 @@ export type LyricsLoadResult = */ export interface LyricsManagerContext { /** Server options. */ - options?: Record & { - /** Lyrics source configuration bucket. */ - lyrics?: Record - } + options: NodelinkConfig /** Source manager accessor. */ sources?: { /** Re-resolves a track URI into reliable source metadata. */ @@ -313,8 +311,13 @@ export default class LyricsManager { } } - for (const [name, source] of this.lyricsSources) { - if (name === sourceName) continue + const sources = new Set([ + ...(this.nodelink.options.lyrics?.preferredSources ?? []), + ...this.lyricsSources.keys() + ]) + for (const name of sources) { + const source = this.lyricsSources.get(name) + if (!source || name === sourceName) continue logger( 'debug', diff --git a/src/managers/playerManager.ts b/src/managers/playerManager.ts index dc68c6f1..06c9b7ea 100644 --- a/src/managers/playerManager.ts +++ b/src/managers/playerManager.ts @@ -5,11 +5,11 @@ import type { FiltersState, NodeLink as PlaybackNodeLink, Session as PlaybackSession, + PlayerSponsorBlockState, PlayerStateJSON, PlayerTrack, PlayerVoiceState, PlayPayload, - PlayerSponsorBlockState, SponsorBlockSegment } from '../typings/playback/player.types.ts' import { logger } from '../utils.ts' @@ -106,7 +106,11 @@ interface CreatePlayerResult { * Generic player command response payload for cluster commands. * @public */ -interface PlayerCommandResponse extends Record { +export interface PlayerCommandResponse extends Record { + /** HTTP-like status code. */ + status?: number + /** Success/failure message or error details. */ + message?: string playerNotFound?: boolean } @@ -892,11 +896,11 @@ export default class PlayerManager { /** * Returns current SponsorBlock state for a player. */ - getSponsorBlock( + async getSponsorBlock( guildId: string - ): PlayerSponsorBlockState | PlayerCommandResponse { + ): Promise { if (this.isCluster) { - return this.runClusterPlayerCommand(guildId, 'getSponsorBlock', []) as any + return this.runClusterPlayerCommand(guildId, 'getSponsorBlock', []) } const player = this.getLocalPlayerOrThrow(this.getPlayerKey(guildId)) @@ -915,7 +919,7 @@ export default class PlayerManager { if (this.isCluster) { return this.runClusterPlayerCommand(guildId, 'updateSponsorBlock', [ updates - ]) as any + ]) } const player = this.getLocalPlayerOrThrow(this.getPlayerKey(guildId)) @@ -933,7 +937,7 @@ export default class PlayerManager { if (this.isCluster) { return this.runClusterPlayerCommand(guildId, 'setSponsorBlockSegments', [ segments - ]) as any + ]) } const player = this.getLocalPlayerOrThrow(this.getPlayerKey(guildId)) @@ -948,7 +952,7 @@ export default class PlayerManager { guildId: string ): Promise { if (this.isCluster) { - return this.runClusterPlayerCommand(guildId, 'clearSponsorBlock', []) as any + return this.runClusterPlayerCommand(guildId, 'clearSponsorBlock', []) } const player = this.getLocalPlayerOrThrow(this.getPlayerKey(guildId)) diff --git a/src/managers/pluginManager.ts b/src/managers/pluginManager.ts index a9ee010d..891cad52 100644 --- a/src/managers/pluginManager.ts +++ b/src/managers/pluginManager.ts @@ -171,6 +171,13 @@ export default class PluginManager { PluginHookName, Array<(...args: unknown[]) => void> > + /** Tracks which hooks belong to which plugin for cleanup. */ + private readonly pluginHooks: Map< + string, + Set<{ name: PluginHookName; callback: (...args: unknown[]) => void }> + > + /** Tracks the current plugin being initialized to associate hooks correctly. */ + private executingPluginName: string | null = null /** * Creates a new plugin manager instance. @@ -185,6 +192,7 @@ export default class PluginManager { this.pluginsDir = path.join(process.cwd(), 'plugins') this.loadedPlugins = new Map() this.hooks = new Map() + this.pluginHooks = new Map() } /** @@ -221,12 +229,60 @@ export default class PluginManager { name: PluginHookName, callback: (...args: unknown[]) => void ): void { + if (this.executingPluginName) { + if (!this.pluginHooks.has(this.executingPluginName)) { + this.pluginHooks.set(this.executingPluginName, new Set()) + } + this.pluginHooks.get(this.executingPluginName)?.add({ name, callback }) + } + if (!this.hooks.has(name)) { this.hooks.set(name, []) } this.hooks.get(name)?.push(callback) } + /** + * Unloads a plugin by removing its hooks and cache entry. + * @param name - The name of the plugin to unload. + * @public + */ + public unloadPlugin(name: string): void { + const pluginHooks = this.pluginHooks.get(name) + if (pluginHooks) { + for (const { name: hookName, callback } of pluginHooks) { + const list = this.hooks.get(hookName) + if (list) { + const index = list.indexOf(callback) + if (index !== -1) list.splice(index, 1) + } + } + this.pluginHooks.delete(name) + } + + this.loadedPlugins.delete(name) + logger('info', 'PluginManager', `Unloaded plugin: ${name}`) + } + + /** + * Reloads a specific plugin. + * @param name - Name of the plugin. + * @param contextType - Process context. + * @public + */ + public async reloadPlugin( + name: string, + contextType: PluginContextType + ): Promise { + const def = this.config.find((d) => d.name === name) + if (!def) { + throw new Error(`Plugin '${name}' not found in configuration.`) + } + + this.unloadPlugin(name) + await this._loadPlugin(def, contextType, true) + } + /** * Synchronously executes all callbacks registered for a hook. * @param name - The name of the hook to trigger. @@ -416,17 +472,19 @@ export default class PluginManager { * Loads a single plugin definition and executes its entrypoint. * @param def - Plugin definition from config. * @param contextType - Current runtime context identifier. + * @param forceReload - Whether to bypass cache and use timestamp for reloading. * @internal */ private async _loadPlugin( def: PluginDefinition, - contextType: PluginContextType + contextType: PluginContextType, + forceReload = false ): Promise { const { name, source, path: localPath, package: packageName } = def if (!name || name.trim().length === 0) return - if (this.loadedPlugins.has(name)) { + if (!forceReload && this.loadedPlugins.has(name)) { const cached = this.loadedPlugins.get(name) if (!cached) return @@ -517,7 +575,10 @@ export default class PluginManager { if (!entryPoint) return - const fileUrl = pathToFileURL(entryPoint).href + let fileUrl = pathToFileURL(entryPoint).href + if (forceReload) { + fileUrl += `?t=${Date.now()}` + } const importedModule: unknown = await import(fileUrl) const pluginModule = this._coercePluginModule(importedModule) @@ -534,7 +595,12 @@ export default class PluginManager { meta: pluginMeta }) - await this._executePlugin(pluginModule, name, contextType, pluginMeta) + this.executingPluginName = name + try { + await this._executePlugin(pluginModule, name, contextType, pluginMeta) + } finally { + this.executingPluginName = null + } const author = `\x1b[36m${pluginMeta.author}\x1b[0m` const pluginName = `\x1b[1m\x1b[32m${name}\x1b[0m` @@ -545,7 +611,11 @@ export default class PluginManager { const creditString = `[${author}] ${pluginName} ${version}${topic}` - logger('info', 'PluginManager', `Loaded: ${creditString}`) + logger( + 'info', + 'PluginManager', + `${forceReload ? 'Reloaded' : 'Loaded'}: ${creditString}` + ) } catch (error) { const message = error instanceof Error ? error.message : String(error) logger( diff --git a/src/managers/proxyManager.ts b/src/managers/proxyManager.ts new file mode 100644 index 00000000..987459ad --- /dev/null +++ b/src/managers/proxyManager.ts @@ -0,0 +1,552 @@ +import { logger } from '../utils.ts' + +export type ProxyProtocol = 'http' | 'https' | 'socks4' | 'socks5' + +export interface ProxyTarget { + id: string + url: string + protocol: ProxyProtocol + type: 'forward' | 'reverse' + username?: string + password?: string + host: string + port: number +} + +export interface ProxyHealthState { + status: 'UP' | 'DOWN' | 'COOLDOWN' + consecutiveFailures: number + totalFailures: number + totalSuccesses: number + activeConnections: number + movingAverageLatency: number + lastFailureAt: number | null + lastSuccessAt: number | null + cooldownEndsAt: number | null +} + +export interface ProxySnapshot { + target: ProxyTarget + state: ProxyHealthState +} + +export type ProxyStrategy = + | 'RoundRobin' + | 'LeastConnections' + | 'LowestLatency' + | 'WeightedHealth' + +export interface ProxyManagerConfig { + enabled: boolean + strategy: ProxyStrategy + disabledSources: string[] + maxConsecutiveFailures: number + cooldownDurationMs: number + latencyWeight: number +} + +const DEFAULT_CONFIG: ProxyManagerConfig = { + enabled: false, + strategy: 'WeightedHealth', + disabledSources: [], + maxConsecutiveFailures: 3, + cooldownDurationMs: 60 * 1000 * 5, // 5 minutes + latencyWeight: 0.2 // EMA alpha +} + +const isRecord = (val: unknown): val is Record => + typeof val === 'object' && val !== null && !Array.isArray(val) + +export default class ProxyManager { + private readonly config: ProxyManagerConfig + private readonly targets: Map + private readonly states: Map + private roundRobinIndex: number = 0 + + constructor(options: Record) { + this.targets = new Map() + this.states = new Map() + + const network = isRecord(options.network) ? options.network : {} + const rawConfig = isRecord(network.proxy) ? network.proxy : {} + this.config = this.parseConfig(rawConfig) + + this.extractTargets(rawConfig, options) + } + + /** + * Evaluates if a given source is allowed to use proxies. + */ + public isEnabledForSource(sourceName: string): boolean { + if (!this.config.enabled) return false + if (this.config.disabledSources.includes(sourceName.toLowerCase())) + return false + return this.targets.size > 0 + } + + /** + * Selects the most optimal proxy based on the configured Load Balancing strategy. + * Employs a Circuit Breaker pattern to avoid dead proxies. + * + * @param sourceName - The identifier of the requesting source (e.g. 'youtube', 'bilibili') + * @returns A safe snapshot of the selected proxy, or `undefined` if none available. + */ + public getBestProxy(sourceName: string): ProxySnapshot | undefined { + if (!this.isEnabledForSource(sourceName)) return undefined + + this.processCooldowns() + + const availableIds = Array.from(this.states.entries()) + .filter(([_, state]) => state.status === 'UP') + .map(([id]) => id) + + if (availableIds.length === 0) { + logger( + 'warn', + 'ProxyManager', + `No healthy proxies available for source '${sourceName}'. All proxies are DOWN or in COOLDOWN.` + ) + return undefined + } + + let selectedId: string | undefined + + switch (this.config.strategy) { + case 'RoundRobin': + selectedId = this.selectRoundRobin(availableIds) + break + case 'LeastConnections': + selectedId = this.selectLeastConnections(availableIds) + break + case 'LowestLatency': + selectedId = this.selectLowestLatency(availableIds) + break + case 'WeightedHealth': + selectedId = this.selectWeightedHealth(availableIds) + break + default: + selectedId = this.selectWeightedHealth(availableIds) + } + + if (!selectedId) return undefined + + const state = this.states.get(selectedId) + const target = this.targets.get(selectedId) + + if (!state || !target) return undefined + + state.activeConnections++ + + return { + target: { ...target }, + state: { ...state } + } + } + + /** + * Reports the resolution of a request utilizing a proxy. + * Updates health metrics, calculates exponential moving average latency, + * and trips the circuit breaker if thresholds are met. + */ + public report( + proxyUrl: string, + success: boolean, + statusCode: number, + latencyMs: number = 0 + ): void { + const id = this.findIdByUrl(proxyUrl) + if (!id) return + + const state = this.states.get(id) + if (!state) return + + if (state.activeConnections > 0) { + state.activeConnections-- + } + + if (success) { + this.handleSuccess(state, latencyMs) + } else { + this.handleFailure(state, statusCode) + } + } + + /** + * Allows adding dynamic proxies in runtime. + */ + public addProxy(url: string, protocol: ProxyProtocol = 'http'): void { + try { + const parsed = this.parseProxyUrl(url, protocol) + if (!this.targets.has(parsed.id)) { + this.targets.set(parsed.id, parsed) + this.states.set(parsed.id, this.createInitialState()) + logger( + 'info', + 'ProxyManager', + `Dynamically added proxy: ${parsed.host}:${parsed.port}` + ) + } + } catch (err) { + logger( + 'error', + 'ProxyManager', + `Failed to add proxy ${url}: ${err instanceof Error ? err.message : String(err)}` + ) + } + } + + /** + * Cleans up proxy manager resources. + */ + public destroy(): void { + this.targets.clear() + this.states.clear() + } + + private handleSuccess(state: ProxyHealthState, latencyMs: number): void { + state.totalSuccesses++ + state.consecutiveFailures = 0 + state.lastSuccessAt = Date.now() + + if (latencyMs > 0) { + if (state.movingAverageLatency === 0) { + state.movingAverageLatency = latencyMs + } else { + const alpha = this.config.latencyWeight + state.movingAverageLatency = + alpha * latencyMs + (1 - alpha) * state.movingAverageLatency + } + } + + if (state.status === 'DOWN' || state.status === 'COOLDOWN') { + state.status = 'UP' + state.cooldownEndsAt = null + } + } + + private handleFailure(state: ProxyHealthState, statusCode: number): void { + state.totalFailures++ + state.consecutiveFailures++ + state.lastFailureAt = Date.now() + + // Status code severity analysis + let failureWeight = 1 + if (statusCode === 403 || statusCode === 429) { + failureWeight = 3 // Severe rate limit or ban + } else if (statusCode >= 500) { + failureWeight = 2 // Server side error + } + + state.consecutiveFailures += failureWeight - 1 + + if (state.consecutiveFailures >= this.config.maxConsecutiveFailures) { + this.tripCircuitBreaker(state) + } + } + + private tripCircuitBreaker(state: ProxyHealthState): void { + state.status = 'COOLDOWN' + state.cooldownEndsAt = Date.now() + this.config.cooldownDurationMs + logger( + 'warn', + 'ProxyManager', + `Circuit breaker tripped for proxy. Cooling down for ${this.config.cooldownDurationMs / 1000}s.` + ) + } + + private processCooldowns(): void { + const now = Date.now() + for (const state of this.states.values()) { + if ( + state.status === 'COOLDOWN' && + state.cooldownEndsAt && + now >= state.cooldownEndsAt + ) { + // Half-open state: transition back to UP to test it. If it fails once, it will trip again quickly. + state.status = 'UP' + state.cooldownEndsAt = null + // We reduce consecutive failures so it gets one more chance before tripping again + state.consecutiveFailures = Math.max( + 0, + this.config.maxConsecutiveFailures - 1 + ) + logger( + 'info', + 'ProxyManager', + 'Proxy exited cooldown and is entering half-open state.' + ) + } + } + } + + private selectRoundRobin(availableIds: string[]): string { + if (this.roundRobinIndex >= availableIds.length) { + this.roundRobinIndex = 0 + } + const selected = availableIds[this.roundRobinIndex] + this.roundRobinIndex = (this.roundRobinIndex + 1) % availableIds.length + return selected || availableIds[0] || '' + } + + private selectLeastConnections(availableIds: string[]): string { + return availableIds.reduce((prevId, currId) => { + const prevConnections = this.states.get(prevId)?.activeConnections ?? 0 + const currConnections = this.states.get(currId)?.activeConnections ?? 0 + return currConnections < prevConnections ? currId : prevId + }) + } + + private selectLowestLatency(availableIds: string[]): string { + return availableIds.reduce((prevId, currId) => { + const prevLatency = + this.states.get(prevId)?.movingAverageLatency || Infinity + const currLatency = + this.states.get(currId)?.movingAverageLatency || Infinity + + // If both are 0 (untested), fallback to random or first + if (prevLatency === Infinity && currLatency === Infinity) return prevId + + return currLatency < prevLatency ? currId : prevId + }) + } + + private selectWeightedHealth(availableIds: string[]): string { + // Sort by a composite score: (failures * high_penalty) + (active_connections * medium_penalty) + latency + const sorted = [...availableIds].sort((a, b) => { + const stateA = this.states.get(a) + const stateB = this.states.get(b) + + if (!stateA || !stateB) return 0 + + const scoreA = + stateA.consecutiveFailures * 1000 + + stateA.activeConnections * 100 + + (stateA.movingAverageLatency || 500) + + const scoreB = + stateB.consecutiveFailures * 1000 + + stateB.activeConnections * 100 + + (stateB.movingAverageLatency || 500) + + return scoreA - scoreB + }) + + // Pick from the top 3 randomly to distribute load while still preferring healthy proxies + const poolSize = Math.min(3, sorted.length) + const randomIndex = Math.floor(Math.random() * poolSize) + return sorted[randomIndex] || availableIds[0] || '' + } + + private findIdByUrl(url: string): string | undefined { + for (const [id, target] of this.targets.entries()) { + if (target.url === url) return id + } + return undefined + } + + private parseConfig(raw: Record): ProxyManagerConfig { + const disabledSourcesCandidate = Array.isArray(raw.disabledSources) + ? raw.disabledSources + .filter((s) => typeof s === 'string') + .map((s) => (s as string).toLowerCase()) + : DEFAULT_CONFIG.disabledSources + + let strategy = DEFAULT_CONFIG.strategy + if (typeof raw.strategy === 'string') { + const s = raw.strategy as ProxyStrategy + if ( + [ + 'RoundRobin', + 'LeastConnections', + 'LowestLatency', + 'WeightedHealth' + ].includes(s) + ) { + strategy = s + } + } + + return { + enabled: + typeof raw.enabled === 'boolean' ? raw.enabled : DEFAULT_CONFIG.enabled, + strategy, + disabledSources: disabledSourcesCandidate, + maxConsecutiveFailures: + typeof raw.maxConsecutiveFailures === 'number' + ? raw.maxConsecutiveFailures + : DEFAULT_CONFIG.maxConsecutiveFailures, + cooldownDurationMs: + typeof raw.cooldownDurationMs === 'number' + ? raw.cooldownDurationMs + : DEFAULT_CONFIG.cooldownDurationMs, + latencyWeight: + typeof raw.latencyWeight === 'number' + ? raw.latencyWeight + : DEFAULT_CONFIG.latencyWeight + } + } + + private extractTargets( + rawConfig: Record, + fullOptions: Record + ): void { + // 1. Check global proxy object (single) + if (typeof rawConfig.url === 'string' && rawConfig.url.length > 0) { + try { + const parsed = this.parseProxyUrl( + rawConfig.url, + (rawConfig.protocol as string) || 'http', + rawConfig.username as string, + rawConfig.password as string, + rawConfig.type as string + ) + this.targets.set(parsed.id, parsed) + } catch (err) { + logger( + 'error', + 'ProxyManager', + `Invalid global proxy URL: ${getErrorMessage(err)}` + ) + } + } + + // 2. Check global proxy list + if (Array.isArray(rawConfig.list)) { + for (const item of rawConfig.list) { + try { + if (typeof item === 'string') { + const parsed = this.parseProxyUrl(item) + this.targets.set(parsed.id, parsed) + } else if (isRecord(item) && typeof item.url === 'string') { + const parsed = this.parseProxyUrl( + item.url, + item.protocol as string, + item.username as string, + item.password as string, + item.type as string + ) + this.targets.set(parsed.id, parsed) + } + } catch (err) { + logger( + 'error', + 'ProxyManager', + `Invalid proxy in list: ${getErrorMessage(err)}` + ) + } + } + } + + // 3. Fallback: Migrate old YouTube proxies into the global pool if global list is empty + if (this.targets.size === 0) { + const sources = isRecord(fullOptions.sources) ? fullOptions.sources : {} + const yt = isRecord(sources.youtube) ? sources.youtube : {} + + if (Array.isArray(yt.proxies)) { + for (const item of yt.proxies) { + try { + if (typeof item === 'string') { + const parsed = this.parseProxyUrl(item) + this.targets.set(parsed.id, parsed) + } else if (isRecord(item) && typeof item.url === 'string') { + const parsed = this.parseProxyUrl( + item.url, + undefined, + undefined, + undefined, + item.type as string + ) + this.targets.set(parsed.id, parsed) + } + } catch (err) { + logger( + 'error', + 'ProxyManager', + `Invalid youtube fallback proxy: ${getErrorMessage(err)}` + ) + } + } + } + + // If we inherited proxies from youtube, implicitly enable the global manager + if (this.targets.size > 0 && typeof rawConfig.enabled !== 'boolean') { + this.config.enabled = true + logger( + 'info', + 'ProxyManager', + `Automatically enabled global ProxyManager using inherited YouTube proxies. (${this.targets.size} found)` + ) + } + } + + for (const id of this.targets.keys()) { + this.states.set(id, this.createInitialState()) + } + } + + private parseProxyUrl( + urlString: string, + defaultProtocol = 'http', + explicitUsername?: string, + explicitPassword?: string, + explicitType?: string + ): ProxyTarget { + let toParse = urlString + if (!toParse.includes('://')) { + toParse = `${defaultProtocol}://${toParse}` + } + + const url = new URL(toParse) + + let protocol = url.protocol.replace(':', '') as ProxyProtocol + if (!['http', 'https', 'socks4', 'socks5'].includes(protocol)) { + protocol = 'http' + } + + const username = + explicitUsername || + (url.username ? decodeURIComponent(url.username) : undefined) + const password = + explicitPassword || + (url.password ? decodeURIComponent(url.password) : undefined) + const host = url.hostname + const port = url.port + ? parseInt(url.port, 10) + : protocol === 'https' + ? 443 + : 80 + const typeStr = explicitType === 'reverse' ? 'reverse' : 'forward' + + const id = `${protocol}://${host}:${port}` + + return { + id, + url: toParse, + protocol, + type: typeStr as 'forward' | 'reverse', + host, + port, + username, + password + } + } + + private createInitialState(): ProxyHealthState { + return { + status: 'UP', + consecutiveFailures: 0, + totalFailures: 0, + totalSuccesses: 0, + activeConnections: 0, + movingAverageLatency: 0, + lastFailureAt: null, + lastSuccessAt: null, + cooldownEndsAt: null + } + } +} + +function getErrorMessage(error: unknown): string { + if (error instanceof Error) return error.message + return String(error) +} diff --git a/src/managers/rateLimitManager.ts b/src/managers/rateLimitManager.ts index 83add08f..dd426af7 100644 --- a/src/managers/rateLimitManager.ts +++ b/src/managers/rateLimitManager.ts @@ -12,6 +12,14 @@ import { logger } from '../utils.ts' type RateLimitContext = { options?: { rateLimit?: Partial + api?: { + rateLimit?: Partial + [key: string]: unknown + } + security?: { + rateLimit?: Partial + [key: string]: unknown + } } } @@ -69,7 +77,11 @@ export default class RateLimitManager { */ constructor(nodelink: RateLimitContext) { this.nodelink = nodelink - this.config = this._resolveConfig(nodelink.options?.rateLimit) + this.config = this._resolveConfig( + nodelink.options?.api?.rateLimit ?? + nodelink.options?.security?.rateLimit ?? + nodelink.options?.rateLimit + ) this.store = new Map() this.cleanupInterval = setInterval( () => this._cleanup(), diff --git a/src/managers/routePlannerManager.ts b/src/managers/routePlannerManager.ts index 73cc7af3..9651e3c8 100644 --- a/src/managers/routePlannerManager.ts +++ b/src/managers/routePlannerManager.ts @@ -1,3 +1,4 @@ +import type { NodelinkConfig } from '../typings/config/config.types.ts' import { logger } from '../utils.ts' /** @@ -21,7 +22,7 @@ interface RoutePlannerIpBlockConfig { interface RoutePlannerConfig { strategy?: RoutePlannerStrategy | string bannedIpCooldown?: number - ipBlocks?: RoutePlannerIpBlockConfig[] + ipBlocks?: Array } /** @@ -40,9 +41,40 @@ interface RoutePlannerBlock { * Minimal NodeLink runtime context used by the route planner manager. * @public */ -type RoutePlannerManagerContext = { - options: Record & { - routePlanner?: RoutePlannerConfig +export type RoutePlannerManagerContext = { + options: NodelinkConfig +} + +const normalizeIpBlocks = ( + blocks: Array | undefined +): RoutePlannerIpBlockConfig[] => { + if (!Array.isArray(blocks)) return [] + return blocks + .map((block) => { + if (typeof block === 'string') return { cidr: block } + if ( + block && + typeof block === 'object' && + typeof block.cidr === 'string' + ) { + return block + } + return null + }) + .filter((block): block is RoutePlannerIpBlockConfig => block !== null) +} + +type ResolvedRoutePlannerConfig = Omit & { + ipBlocks?: RoutePlannerIpBlockConfig[] +} + +const resolveConfig = ( + nodelink: RoutePlannerManagerContext +): ResolvedRoutePlannerConfig => { + const cfg = nodelink.options.network.routePlanner + return { + ...cfg, + ipBlocks: normalizeIpBlocks(cfg.ipBlocks) } } @@ -61,7 +93,7 @@ const BIGINT_MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER) */ export default class RoutePlannerManager { public readonly nodelink: RoutePlannerManagerContext - private readonly config: RoutePlannerConfig + private readonly config: ResolvedRoutePlannerConfig public readonly blocks: RoutePlannerBlock[] public readonly bannedIps: Map public readonly bannedBlocks: Map @@ -73,7 +105,7 @@ export default class RoutePlannerManager { */ constructor(nodelink: RoutePlannerManagerContext) { this.nodelink = nodelink - this.config = nodelink.options.routePlanner ?? {} + this.config = resolveConfig(nodelink) this.blocks = [] this.bannedIps = new Map() this.bannedBlocks = new Map() @@ -92,6 +124,13 @@ export default class RoutePlannerManager { return this.blocks } + /** + * Compatibility alias used by shutdown paths. + */ + public dispose(): void { + this.freeAll() + } + /** * Converts an IPv4 or IPv6 address string to bigint form. * @param ip - IP address string. diff --git a/src/managers/sessionManager.ts b/src/managers/sessionManager.ts index 24a597db..55c44915 100644 --- a/src/managers/sessionManager.ts +++ b/src/managers/sessionManager.ts @@ -8,6 +8,7 @@ import type { } from '../typings/index.types.ts' import type { ClientInfo } from '../typings/shared.types.ts' import { generateRandomLetters, logger } from '../utils.ts' +import GroupManager from './groupManager.ts' /** * Manages active and resumable WebSocket sessions for NodeLink. @@ -85,6 +86,7 @@ export default class SessionManager { userId: request.headers['user-id'] as string | string[] | undefined, socket, players, + groups: new GroupManager(), resuming: false, timeout: 60, isPaused: false, @@ -130,7 +132,11 @@ export default class SessionManager { public pause(sessionId: string): void { // [feat] session-resuming: guard double-pause and clear stale socket if (this.resumableSessions.has(sessionId)) { - logger('debug', 'SessionManager', `Session ${sessionId} is already paused.`) + logger( + 'debug', + 'SessionManager', + `Session ${sessionId} is already paused.` + ) return } @@ -220,10 +226,21 @@ export default class SessionManager { } } else { for (const player of players.players.values()) { - player.destroy?.() + try { + player.destroy?.() + } catch (error) { + const message = error instanceof Error ? error.message : String(error) + logger( + 'error', + 'SessionManager', + `Failed to destroy player for guild ${player.guildId} during session destruction: ${message}` + ) + } } + players.players.clear() } + session.groups.destroy() session.socket?.destroy?.() } diff --git a/src/managers/sourceManager.ts b/src/managers/sourceManager.ts index 07cb5d33..8cd42b9c 100644 --- a/src/managers/sourceManager.ts +++ b/src/managers/sourceManager.ts @@ -1,6 +1,13 @@ +import { AsyncLocalStorage } from 'node:async_hooks' import fs from 'node:fs/promises' import path from 'node:path' import { fileURLToPath } from 'node:url' +import type { + FeatureToggle, + NodelinkConfig, + SourceConfigBase, + SourcesRegistry +} from '../typings/config/config.types.ts' import type { SourceManagerLike, TrackFormat, @@ -16,7 +23,7 @@ import type { TrackStreamResult, TrackUrlResult } from '../typings/sources/source.types.ts' -import { logger } from '../utils.ts' +import { getBestMatch, logger } from '../utils.ts' /** * Context object required by the SourcesManager for operation. @@ -24,32 +31,7 @@ import { logger } from '../utils.ts' */ export interface SourcesManagerContext { /** Global NodeLink configuration options. */ - options: { - /** Map of source-specific configurations. */ - sources?: Record - /** Default source(s) used for keyword searches. */ - defaultSearchSource?: string | string[] - /** List of sources used for multi-source search. */ - unifiedSearchSources?: string[] - /** Maximum number of search results to return. */ - maxSearchResults?: number - /** Maximum track count for album and playlist loading. */ - maxAlbumPlaylistLength?: number - /** Default playback volume for new tracks. */ - defaultVolume?: number - /** Whether to enable advanced source-native seeking. */ - enableHoloTracks?: boolean - /** Whether to fetch supplemental channel metadata. */ - fetchChannelInfo?: boolean - /** Whether to resolve external links within metadata. */ - resolveExternalLinks?: boolean - /** Audio processing configuration. */ - audio?: { - /** Global loudness normalization preference. */ - loudnessNormalizer?: boolean - } - [key: string]: unknown - } + options: NodelinkConfig /** Global statistics manager for metric recording. */ statsManager?: { /** Increments success counter for a specific source. */ @@ -99,6 +81,10 @@ interface SourceModule { * @public */ export default class SourcesManager implements SourceManagerLike { + /** Source instances active in the current track URL resolution chain. */ + private readonly resolvingSources = new AsyncLocalStorage< + ReadonlySet + >() /** The parent NodeLink instance context. */ public nodelink: SourcesManagerContext /** Map of primary source instances keyed by their unique identifier. */ @@ -144,13 +130,9 @@ export default class SourcesManager implements SourceManagerLike { ): Promise => { const isYouTube = name === 'youtube' || name.includes('YouTube.ts') const sourceKey = isYouTube ? 'youtube' : name - const youtubeKey = 'youtube' const sourceConfig = this.nodelink.options.sources - const enabled = isYouTube - ? (sourceConfig?.[youtubeKey] as { enabled?: boolean } | undefined) - ?.enabled - : !!sourceConfig?.[sourceKey]?.enabled + const enabled = sourceConfig[sourceKey as keyof SourcesRegistry]?.enabled if (!enabled) return @@ -206,11 +188,16 @@ export default class SourcesManager implements SourceManagerLike { try { await fs.access(sourcesDir) - const enabledSourceKeys = Object.entries( - this.nodelink.options.sources || {} - ) - .filter(([, cfg]) => !!cfg?.enabled) - .map(([key]) => key.toLowerCase()) + const sources = this.nodelink.options.sources + const enabledSourceKeys = Object.keys(sources) + .filter((key) => { + const config = sources[key] as + | SourceConfigBase + | FeatureToggle + | undefined + return config?.enabled + }) + .map((key) => key.toLowerCase()) const uniqueEnabled = Array.from(new Set(enabledSourceKeys)) const sourceEntries = uniqueEnabled.map((sourceKey) => { @@ -386,13 +373,18 @@ export default class SourcesManager implements SourceManagerLike { * @public */ public async searchWithDefault(query: string): Promise { - const defaultSources = Array.isArray( - this.nodelink.options.defaultSearchSource - ) - ? this.nodelink.options.defaultSearchSource - : [this.nodelink.options.defaultSearchSource] + const configuredDefaultSource = this.nodelink.options.search.defaultSource + const defaultSources = Array.isArray(configuredDefaultSource) + ? configuredDefaultSource + : [configuredDefaultSource] + const activeSources = this.resolvingSources.getStore() for (const source of defaultSources) { + const instance = + activeSources && + (this.searchAliasMap.get(source) ?? this.sourceMap.get(source)) + if (instance && activeSources.has(instance)) continue + try { const result = await this.search(source as string, query) if ( @@ -421,9 +413,7 @@ export default class SourcesManager implements SourceManagerLike { * @public */ public async unifiedSearch(query: string): Promise { - const searchSources = (this.nodelink.options.unifiedSearchSources || [ - 'youtube' - ]) as string[] + const searchSources = this.nodelink.options.search.unifiedSources logger( 'debug', 'Sources', @@ -528,13 +518,15 @@ export default class SourcesManager implements SourceManagerLike { * @param track - The normalized track metadata. * @param itag - Optional YouTube-specific itag override. * @param isRecovering - Whether this is a recovery attempt. + * @param isUpscaling - Whether this is an upscale attempt. * @returns A promise resolving to the URL result. * @public */ public async getTrackUrl( track: TrackInfo | TrackInfoExtended, itag?: number, - isRecovering?: boolean + isRecovering?: boolean, + isUpscaling?: boolean ): Promise< TrackUrlResult & { protocol?: string @@ -549,16 +541,77 @@ export default class SourcesManager implements SourceManagerLike { `Source ${track.sourceName} not found or does not support getTrackUrl` ) } - return (await instance.getTrackUrl( - track, - itag, - isRecovering - )) as TrackUrlResult & { - protocol?: string - format?: TrackFormat - trackInfo?: TrackInfoExtended - additionalData?: Record + const sourceGetTrackUrl = instance.getTrackUrl + + const activeSources = this.resolvingSources.getStore() + if (activeSources?.has(instance)) { + return { + exception: { + message: `Circular track URL resolution detected for source ${track.sourceName}.`, + severity: 'fault' + } + } } + + const nextActiveSources = new Set(activeSources).add(instance) + + return this.resolvingSources.run(nextActiveSources, async () => { + // ISRC Upscale: If track has ISRC and is from YouTube, try high-quality sources first. + if ( + track.isrc && + !isUpscaling && + !isRecovering && + (track.sourceName === 'youtube' || track.sourceName === 'ytmusic') + ) { + const hqSources = ['tidal', 'qobuz', 'applemusic', 'deezer'] + for (const source of hqSources) { + const hqSource = this.sources.get(source) + if (!hqSource || nextActiveSources.has(hqSource)) continue + + try { + const searchResult = await this.search(source, track.isrc) + if ( + searchResult.loadType === 'search' && + Array.isArray(searchResult.data) && + searchResult.data.length > 0 + ) { + const match = getBestMatch(searchResult.data, track) + if (match) { + logger( + 'info', + 'Sources', + `ISRC Upscale: found match for ${track.isrc} on ${source}. Using high-quality source.` + ) + return await this.getTrackUrl( + match.info, + undefined, + false, + true + ) + } + } + } catch (e) { + logger( + 'debug', + 'Sources', + `ISRC Upscale attempt failed for ${source}: ${(e as Error).message}` + ) + } + } + } + + return (await sourceGetTrackUrl.call( + instance, + track, + itag, + isRecovering + )) as TrackUrlResult & { + protocol?: string + format?: TrackFormat + trackInfo?: TrackInfoExtended + additionalData?: Record + } + }) } /** @@ -662,7 +715,7 @@ export default class SourcesManager implements SourceManagerLike { const sources = this.nodelink.options.sources if (sources) { for (const sourceName in sources) { - if (sources[sourceName]?.enabled) { + if (sources[sourceName as keyof SourcesRegistry]?.enabled) { enabledNames.push(sourceName) } } diff --git a/src/managers/sourceWorkerManager.ts b/src/managers/sourceWorkerManager.ts index f7ebb362..c55ddad9 100644 --- a/src/managers/sourceWorkerManager.ts +++ b/src/managers/sourceWorkerManager.ts @@ -171,7 +171,8 @@ const buildSourceWorkerExecArgv = ( const env = process.env as NodeJS.ProcessEnv & SourceWorkerEnv for (const arg of Array.from(args)) { - if (arg.startsWith('--max-old-space-size=')) args.delete(arg) + if (arg.startsWith('--max-old-space-size=') || arg === '--expose-gc') + args.delete(arg) } const maxOldSpaceMb = parsePositiveInt( diff --git a/src/managers/statsManager.ts b/src/managers/statsManager.ts index 92207eea..54c786c1 100644 --- a/src/managers/statsManager.ts +++ b/src/managers/statsManager.ts @@ -5,6 +5,7 @@ import type { StatsSnapshot, WorkerMetricsPayload } from '../typings/api/stats.types.ts' +import type { NodelinkConfig } from '../typings/config/config.types.ts' import { logger } from '../utils.ts' type PromClientModule = typeof import('prom-client') @@ -13,15 +14,8 @@ type PromCounter = InstanceType type PromGauge = InstanceType type PromCollector = ReturnType -export type StatsManagerOptions = { - metrics?: { - enabled?: boolean - } - [key: string]: unknown -} - export type StatsManagerContext = { - options: StatsManagerOptions + options: NodelinkConfig } const MAX_ENDPOINT_ENTRIES = 500 @@ -137,7 +131,7 @@ export default class StatsManager { async initialize(): Promise { if (this.initialized) return - const metricsEnabled = this.nodelink.options.metrics?.enabled ?? false + const metricsEnabled = this.nodelink.options.api.metrics?.enabled ?? false if (!metricsEnabled) { this.initialized = true return @@ -543,6 +537,14 @@ export default class StatsManager { logger('info', 'StatsManager', 'Prometheus metrics initialized.') } + /** + * Returns the Prometheus registry for custom metric registration. + * @public + */ + public getRegistry(): PromRegistry | undefined { + return this.promRegister + } + /** * Returns a deep-copied snapshot of internal counters. */ diff --git a/src/managers/trackCacheManager.ts b/src/managers/trackCacheManager.ts index 63010f3c..ccd4c3ef 100644 --- a/src/managers/trackCacheManager.ts +++ b/src/managers/trackCacheManager.ts @@ -1,7 +1,5 @@ -import crypto from 'node:crypto' -import fs from 'node:fs/promises' -import type { TrackCacheEntry } from '../typings/playback/trackCache.types.ts' -import { logger } from '../utils.ts' +import type { NodelinkConfig } from '../typings/config/config.types.ts' +import BaseCacheManager from './baseCacheManager.ts' const TRACK_CACHE_SALT = 'nodelink-track-salt' const DEFAULT_CACHE_FILE = './.cache/tracks.bin' @@ -11,23 +9,12 @@ const DEFAULT_MAX_ENTRIES = 5000 const DEFAULT_CLEANUP_INTERVAL_MS = 60 * 1000 type TrackCacheContext = { - options: Record + options: NodelinkConfig } -const isRecord = (value: unknown): value is Record => +const _isRecord = (value: unknown): value is Record => typeof value === 'object' && value !== null && !Array.isArray(value) -const getErrorMessage = (error: unknown): string => - error instanceof Error ? error.message : String(error ?? 'Unknown error') - -const getErrorCode = (error: unknown): string | undefined => { - if (!error || typeof error !== 'object' || !('code' in error)) { - return undefined - } - const code = (error as NodeJS.ErrnoException).code - return typeof code === 'string' ? code : undefined -} - /** * Encrypted cache for resolved track metadata and URLs. * @remarks Uses AES-256-GCM and purges expired entries on load and access. @@ -40,121 +27,30 @@ const getErrorCode = (error: unknown): string | undefined => { * ``` * @public */ -export default class TrackCacheManager { +export default class TrackCacheManager extends BaseCacheManager { private readonly nodelink: TrackCacheContext - private readonly password: string - private key: Buffer - private legacyKey: Buffer | null - private readonly filePath: string - private readonly maxEntries: number - private readonly cleanupIntervalMs: number - private cache: Map> - private saveTimeout: NodeJS.Timeout | null - private cleanupInterval: NodeJS.Timeout | null /** * Creates a new track cache manager instance. * @param nodelink - NodeLink runtime context. */ constructor(nodelink: TrackCacheContext) { - this.nodelink = nodelink - this.password = this._resolvePassword(nodelink.options) - this.key = this._deriveFastKey(this.password) - this.legacyKey = null - const cacheOptions = this._resolveCacheOptions(nodelink.options) - this.filePath = DEFAULT_CACHE_FILE - this.maxEntries = cacheOptions.maxEntries - this.cleanupIntervalMs = cacheOptions.cleanupIntervalMs - this.cache = new Map() - this.saveTimeout = null - this.cleanupInterval = setInterval(() => { - const expiredCount = this._purgeExpired() - const evictedCount = this._enforceMaxEntries() - if (expiredCount > 0 || evictedCount > 0) this.save() - }, this.cleanupIntervalMs) - this.cleanupInterval.unref?.() - } - - /** - * Loads cached tracks from disk. - */ - async load(): Promise { - try { - const data = await fs.readFile(this.filePath) - if (data.length < 32) return - - let store: Record> - let migratedFromLegacy = false - - try { - store = this._decodeStore(data, this.key) - } catch { - const legacyKey = this._getLegacyKey() - store = this._decodeStore(data, legacyKey) - migratedFromLegacy = true - } - - this.cache = new Map(Object.entries(store)) - - const expiredCount = this._purgeExpired() - const evictedCount = this._enforceMaxEntries() - if (expiredCount > 0 || evictedCount > 0 || migratedFromLegacy) - this.save() - - logger( - 'debug', - 'TrackCache', - `Loaded ${this.cache.size} cached tracks from disk.` - ) - } catch (error) { - const code = getErrorCode(error) - if (code !== 'ENOENT') { - logger( - 'error', - 'TrackCache', - `Failed to load track cache: ${getErrorMessage(error)}` - ) - } - this.cache = new Map() - } - } - - /** - * Debounces cache persistence. - */ - save(): void { - if (this.saveTimeout) return - - this.saveTimeout = setTimeout(() => { - this.saveTimeout = null - void this.forceSave() - }, DEFAULT_SAVE_DELAY_MS) - } - - /** - * Forces the cache to be written to disk immediately. - */ - async forceSave(): Promise { - try { - const plainText = JSON.stringify(Object.fromEntries(this.cache)) - const iv = crypto.randomBytes(16) - const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv) - - const encrypted = Buffer.concat([ - cipher.update(plainText, 'utf8'), - cipher.final() - ]) - const tag = cipher.getAuthTag() + const password = TrackCacheManager._resolvePassword(nodelink.options) + const cacheOptions = TrackCacheManager._resolveCacheOptions( + nodelink.options + ) + + super({ + name: 'TrackCache', + passwordHashKey: password, + salt: TRACK_CACHE_SALT, + filePath: DEFAULT_CACHE_FILE, + saveDelayMs: DEFAULT_SAVE_DELAY_MS, + cleanupIntervalMs: cacheOptions.cleanupIntervalMs, + maxEntries: cacheOptions.maxEntries + }) - await fs.mkdir('./.cache', { recursive: true }) - await fs.writeFile(this.filePath, Buffer.concat([iv, tag, encrypted])) - } catch (error) { - logger( - 'error', - 'TrackCache', - `Failed to save track cache: ${getErrorMessage(error)}` - ) - } + this.nodelink = nodelink } /** @@ -164,16 +60,8 @@ export default class TrackCacheManager { */ get(source: string, identifier: string): T | null { const key = `${source}:${identifier}` - const entry = this.cache.get(key) - if (!entry) return null - if (entry.expiresAt && Date.now() > entry.expiresAt) { - this.cache.delete(key) - this.save() - return null - } - this.cache.delete(key) - this.cache.set(key, entry) - return entry.value as T + const entry = this._getValidEntry(key) + return entry ? (entry.value as T) : null } /** @@ -190,32 +78,39 @@ export default class TrackCacheManager { ttlMs: number = DEFAULT_TTL_MS ): void { const key = `${source}:${identifier}` - if (this.cache.has(key)) { - this.cache.delete(key) - } + const now = Date.now() + this.cache.set(key, { value, - expiresAt: ttlMs > 0 ? Date.now() + ttlMs : null + createdAt: now, + updatedAt: now, + expiresAt: ttlMs > 0 ? now + ttlMs : null }) + this._enforceMaxEntries() this.save() } - private _resolveCacheOptions(options: Record): { + /** + * Deletes a cached value by source/identifier. + * @param source - Source name (e.g., "youtube"). + * @param identifier - Track identifier. + */ + delete(source: string, identifier: string): boolean { + const key = `${source}:${identifier}` + const deleted = this.cache.delete(key) + if (deleted) this.save() + return deleted + } + + private static _resolveCacheOptions(options: NodelinkConfig): { maxEntries: number cleanupIntervalMs: number } { - const directCandidate = (options as { trackCache?: unknown }).trackCache - const rootCache = isRecord(directCandidate) ? directCandidate : null - const nestedCandidate = (options as { cache?: unknown }).cache - const nestedCache = isRecord(nestedCandidate) - ? (nestedCandidate as { track?: unknown }).track - : null - const nestedTrackCache = isRecord(nestedCache) ? nestedCache : null - const selected = rootCache ?? nestedTrackCache + const playback = options.playback - const maxEntriesRaw = selected?.maxEntries - const cleanupIntervalRaw = selected?.cleanupIntervalMs + const maxEntriesRaw = playback.maxPlaylistLength + const cleanupIntervalRaw = playback.statsUpdateInterval const maxEntries = typeof maxEntriesRaw === 'number' && Number.isFinite(maxEntriesRaw) @@ -230,112 +125,11 @@ export default class TrackCacheManager { return { maxEntries, cleanupIntervalMs } } - private _resolvePassword(options: Record): string { - const optionsCandidate = options as { server?: unknown } - const serverCandidate = optionsCandidate.server - const server = isRecord(serverCandidate) - ? (serverCandidate as { password?: unknown }) - : null - const password = - server && typeof server.password === 'string' ? server.password : null + private static _resolvePassword(options: NodelinkConfig): string { + const password = options.server?.password if (!password) { throw new Error('TrackCacheManager requires options.server.password') } return password } - - private _deriveFastKey(password: string): Buffer { - return crypto - .createHash('sha256') - .update(`${TRACK_CACHE_SALT}:${password}`) - .digest() - } - - private _getLegacyKey(): Buffer { - if (!this.legacyKey) { - this.legacyKey = crypto.scryptSync(this.password, TRACK_CACHE_SALT, 32) - } - - return this.legacyKey - } - - private _purgeExpired(): number { - const now = Date.now() - let expiredCount = 0 - for (const [key, entry] of this.cache.entries()) { - if (entry.expiresAt && now > entry.expiresAt) { - this.cache.delete(key) - expiredCount++ - } - } - return expiredCount - } - - private _enforceMaxEntries(): number { - if (this.cache.size <= this.maxEntries) return 0 - - let removed = 0 - while (this.cache.size > this.maxEntries) { - const oldestKey = this.cache.keys().next().value - if (!oldestKey) break - this.cache.delete(oldestKey) - removed++ - } - return removed - } - - private _decodeStore( - data: Buffer, - key: Buffer - ): Record> { - const iv = data.subarray(0, 16) - const tag = data.subarray(16, 32) - const encrypted = data.subarray(32) - - const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv) - decipher.setAuthTag(tag) - - const decrypted = Buffer.concat([ - decipher.update(encrypted), - decipher.final() - ]).toString('utf8') - const parsed = JSON.parse(decrypted) as unknown - return this._normalizeStore(parsed) - } - - private _normalizeStore( - raw: unknown - ): Record> { - if (!isRecord(raw)) return {} - - const store: Record> = {} - for (const [key, value] of Object.entries(raw)) { - store[key] = this._normalizeEntry(value) - } - return store - } - - private _normalizeEntry(rawValue: unknown): TrackCacheEntry { - if (isRecord(rawValue)) { - const entryCandidate = rawValue as Partial> & { - value?: unknown - } - const value = Object.hasOwn(entryCandidate, 'value') - ? entryCandidate.value - : rawValue - const expiresAt = - typeof entryCandidate.expiresAt === 'number' - ? entryCandidate.expiresAt - : null - return { - value, - expiresAt - } - } - - return { - value: rawValue, - expiresAt: null - } - } } diff --git a/src/managers/workerManager.ts b/src/managers/workerManager.ts index 462c4f61..55474b49 100644 --- a/src/managers/workerManager.ts +++ b/src/managers/workerManager.ts @@ -37,6 +37,10 @@ interface CommandSocket extends Socket { _workerId?: number } +interface EventSocket extends Socket { + _workerId?: number +} + /** * Runtime worker stats payload received from playback workers. * @internal @@ -350,7 +354,7 @@ export default class WorkerManager { private commandSocketPath: string private commandServer: net.Server | null private commandSockets: Map - private eventSockets: Set + private eventSockets: Map private socketRotateInProgress: boolean private lastSocketRotateAt: number @@ -363,13 +367,9 @@ export default class WorkerManager { this.nextStatelessWorkerIndex = 0 this.pendingRequests = new Map() this.streamRequests = new Map() - const availableParallelism = - typeof os.availableParallelism === 'function' - ? os.availableParallelism() - : os.cpus().length this.maxWorkers = config.cluster.workers === 0 - ? availableParallelism + ? os.cpus().length : Math.max(1, config.cluster.workers || 0) this.minWorkers = Math.max(1, config.cluster?.minWorkers || 1) this.workerLoad = new Map() @@ -409,7 +409,7 @@ export default class WorkerManager { this.commandSocketPath = createSocketPath('commands') this.commandServer = null this.commandSockets = new Map() - this.eventSockets = new Set() + this.eventSockets = new Map() this.socketRotateInProgress = false this.lastSocketRotateAt = 0 @@ -667,27 +667,14 @@ export default class WorkerManager { if (stats.isHibernating) return cost - const cpuLoad = stats.cpu?.nodelinkLoad ?? 0 - const lagP95 = stats.eventLoopLagP95 ?? stats.eventLoopLag ?? 0 - const frameDeficit = stats.frameStats?.deficit ?? 0 - const stuckRecoveries = stats.stuckRecoveries ?? 0 - - if (cpuLoad > this.scalingConfig.cpuPenaltyLimit) { + if ((stats.cpu?.nodelinkLoad ?? 0) > this.scalingConfig.cpuPenaltyLimit) { cost += this.scalingConfig.maxPlayersPerWorker + 5 } - if (lagP95 > this.scalingConfig.lagPenaltyLimit) { + if ((stats.eventLoopLag ?? 0) > this.scalingConfig.lagPenaltyLimit) { cost += this.scalingConfig.maxPlayersPerWorker / 2 } - if (frameDeficit > playingCount * 10) { - cost += this.scalingConfig.maxPlayersPerWorker / 4 - } - - if (stuckRecoveries > playingCount * 0.1 && playingCount > 0) { - cost += this.scalingConfig.maxPlayersPerWorker / 3 - } - return cost } @@ -722,17 +709,38 @@ export default class WorkerManager { ) } + private _registerEventSocket(pid: number, eventSocket: EventSocket): void { + const worker = this.workers.find((w) => w.process.pid === pid) + if (!worker) return + const existing = this.eventSockets.get(worker.id) + if (existing && existing !== eventSocket) { + try { + existing.destroy() + } catch {} + } + eventSocket._workerId = worker.id + this.eventSockets.set(worker.id, eventSocket) + } + + private _removeEventSocket(eventSocket: EventSocket): void { + const workerId = eventSocket?._workerId + if (!workerId) return + if (this.eventSockets.get(workerId) === eventSocket) { + this.eventSockets.delete(workerId) + } + } + private _startSocketServer(): void { this._safeUnlinkSocketPath(this.socketPath) this.server = net.createServer((socket) => { - this.eventSockets.add(socket) + const eventSocket = socket as EventSocket const frameChunks: Buffer[] = [] let frameBytes = 0 socket.on('error', () => { // Ignore per-connection transport errors (EPIPE/ECONNRESET). }) - socket.on('close', () => this.eventSockets.delete(socket)) + socket.on('close', () => this._removeEventSocket(eventSocket)) const peekBytes = (count: number): Buffer => { const first = frameChunks[0] @@ -812,7 +820,11 @@ export default class WorkerManager { try { const data = v8.deserialize(payload) - if (type === 3) { + if (type === 0) { + // Event socket hello - register socket to worker by PID + if (isPidPacket(data)) + this._registerEventSocket(data.pid, eventSocket) + } else if (type === 3) { // playerEvent const nodelink = getGlobalNodelink() if (nodelink) @@ -821,10 +833,12 @@ export default class WorkerManager { payload: data }) } else if (type === 4) { - // workerStats + // workerStats - prefer socket-mapped worker ID over payload workerId if (isWorkerStatsPacket(data)) { - const { workerId, ...stats } = data - this.statsUpdateBatch.set(workerId, stats) + const { workerId: payloadWorkerId, ...stats } = data + const resolvedWorkerId = + eventSocket._workerId ?? payloadWorkerId + this.statsUpdateBatch.set(resolvedWorkerId, stats) if (!this.statsUpdateTimer) { this.statsUpdateTimer = setTimeout( () => this._flushStatsUpdates(), @@ -1006,7 +1020,7 @@ export default class WorkerManager { `Rotating internal sockets after ${reason} (worker ${sourceWorkerId})` ) - for (const socket of this.eventSockets) { + for (const socket of this.eventSockets.values()) { try { socket.destroy() } catch {} @@ -1289,6 +1303,7 @@ export default class WorkerManager { WORKER_TYPE: 'playback' }) as PlaybackWorker worker.workerType = 'playback' + worker.send({ type: 'clusterId', clusterId: worker.id }) worker.ready = false this.workers.push(worker) @@ -1548,39 +1563,6 @@ export default class WorkerManager { } } - if (bestWorker) { - const ws = this.workerStats.get(bestWorker.id) - const localLoad = this.workerToGuilds.get(bestWorker.id)?.size ?? 0 - const lagP99 = ws?.eventLoopLagP99 ?? ws?.eventLoopLag ?? 0 - const cpuLoad = ws?.cpu?.nodelinkLoad ?? 0 - const stuckRecoveries = ws?.stuckRecoveries ?? 0 - const playingCount = localLoad - - const admissionDenied = - lagP99 > this.scalingConfig.lagPenaltyLimit * 3 || - cpuLoad > 0.95 || - (stuckRecoveries > playingCount * 0.5 && playingCount > 5) - - if (admissionDenied && this.workers.length < this.maxWorkers) { - logger( - 'warn', - 'Cluster', - `Worker #${bestWorker.id} admission denied (lagP99=${lagP99.toFixed(1)}ms, cpu=${cpuLoad.toFixed(2)}, stuckRecoveries=${stuckRecoveries}). Forking new worker.` - ) - const newWorker = this.forkWorker() - if (newWorker) { - this.assignGuildToWorker(playerKey, newWorker) - return newWorker - } - } else if (admissionDenied) { - logger( - 'warn', - 'Cluster', - `Worker #${bestWorker.id} admission denied but at max workers. Assigning anyway.` - ) - } - } - const threshold = this.scalingConfig.maxPlayersPerWorker const hasConnectedWorker = !!bestWorker @@ -1822,7 +1804,7 @@ export default class WorkerManager { } this.commandSockets.clear() - for (const socket of this.eventSockets) { + for (const socket of this.eventSockets.values()) { try { socket.destroy() } catch {} diff --git a/src/modules/config/configMigration.test.ts b/src/modules/config/configMigration.test.ts new file mode 100644 index 00000000..b8e51a14 --- /dev/null +++ b/src/modules/config/configMigration.test.ts @@ -0,0 +1,187 @@ +import assert from 'node:assert/strict' +import test from 'node:test' + +import defaultConfig from '../../../config.default.ts' +import type { NodelinkConfig } from '../../typings/config/config.types.ts' +import { migrateConfig, toTsLiteral } from './configMigration.ts' + +test('migrateConfig maps legacy flat config to hierarchical structure', () => { + const legacy = { + server: { + host: '0.0.0.0', + port: 3000, + password: 'legacy-pass', + useBunServer: false + }, + connection: { + interval: 12345, + timeout: 6789, + thresholds: { bad: 1, average: 5 }, + logAllChecks: true + }, + routePlanner: { + strategy: 'RotateOnBan', + bannedIpCooldown: 1000, + ipBlocks: ['1.1.1.0/24'] + }, + maxSearchResults: 25, + defaultSearchSource: ['youtube'], + unifiedSearchSources: ['youtube', 'soundcloud'], + resolveExternalLinks: true, + fetchChannelInfo: true, + maxAlbumPlaylistLength: 777, + playerUpdateInterval: 3000, + statsUpdateInterval: 15000, + trackStuckThresholdMs: 45000, + eventTimeoutMs: 3333, + zombieThresholdMs: 99999, + sponsorblock: { + enabled: true, + api: 'x', + categories: [], + actionTypes: ['skip'], + skipMarginMs: 1 + }, + filters: { enabled: { tremolo: true } }, + audio: { quality: 'high' }, + voiceReceive: { enabled: true, format: 'opus' }, + mix: { + enabled: true, + defaultVolume: 0.8, + maxLayersMix: 5, + autoCleanup: true + }, + enableTrackStreamEndpoint: true, + enableLoadStreamEndpoint: true, + dosProtection: { enabled: true }, + rateLimit: { enabled: true }, + metrics: { enabled: true }, + enableHoloTracks: true, + cluster: { + commandTimeout: 6000, + fastCommandTimeout: 4000 + } + } + + const migrated = migrateConfig( + legacy as Record + ) as unknown as NodelinkConfig + + assert.equal(migrated.search.maxResults, 25) + assert.deepEqual(migrated.search.defaultSource, ['youtube']) + assert.deepEqual(migrated.search.unifiedSources, ['youtube', 'soundcloud']) + assert.equal(migrated.search.resolveExternalLinks, true) + assert.equal(migrated.search.fetchChannelInfo, true) + + assert.equal(migrated.playback.maxPlaylistLength, 777) + assert.equal(migrated.playback.playerUpdateInterval, 3000) + assert.equal(migrated.playback.statsUpdateInterval, 15000) + assert.equal(migrated.playback.trackStuckThresholdMs, 45000) + assert.equal(migrated.playback.eventTimeoutMs, 3333) + assert.equal(migrated.playback.zombieThresholdMs, 99999) + assert.equal(migrated.playback.voiceReceive.enabled, true) + + assert.equal(migrated.api.enableTrackStreamEndpoint, true) + assert.equal(migrated.api.enableLoadStreamEndpoint, true) + assert.equal(migrated.experimental.enableHoloTracks, true) + + assert.deepEqual(migrated.network.connection.interval, 12345) + assert.deepEqual(migrated.network.routePlanner.ipBlocks, ['1.1.1.0/24']) + + assert.equal(migrated.cluster.timeouts?.heavyMs, 6000) + assert.equal(migrated.cluster.timeouts?.fastMs, 4000) + assert.equal(migrated.server.password, 'legacy-pass') +}) + +test('migrateConfig preserves explicit hierarchical values over legacy duplicates', () => { + const hybrid = { + server: { password: 'server-password' }, + trustProxy: true, + maxSearchResults: 10, + search: { maxResults: 50 }, + cluster: { + commandTimeout: 6000, + fastCommandTimeout: 4000, + timeouts: { heavyMs: 9000, fastMs: 7000 } + }, + network: { + proxy: { + enabled: true, + strategy: 'RoundRobin', + retries: 1, + timeout: 1, + shuffleOnStart: false, + list: [] + } + } + } + + const migrated = migrateConfig( + hybrid as Record + ) as unknown as NodelinkConfig + + assert.equal(migrated.server.password, 'server-password') + assert.equal(migrated.search.maxResults, 50) + assert.equal(migrated.cluster.timeouts?.heavyMs, 9000) + assert.equal(migrated.cluster.timeouts?.fastMs, 7000) + assert.equal(migrated.network.proxy.enabled, true) +}) + +test('migrateConfig fills required compatibility defaults', () => { + const minimalLegacy = { + server: { password: 'abc' }, + cluster: { commandTimeout: 1000, fastCommandTimeout: 2000 } + } + + const migrated = migrateConfig( + minimalLegacy as Record + ) as unknown as NodelinkConfig + assert.equal(migrated.server.password, 'abc') + assert.equal(migrated.cluster.timeouts?.heavyMs, 1000) + assert.equal(migrated.cluster.timeouts?.fastMs, 2000) + assert.equal(migrated.network.proxy.enabled, false) + assert.deepEqual(migrated.network.proxy.list, []) +}) + +test('migrateConfig keeps vanilla default config valid', () => { + const migrated = migrateConfig( + defaultConfig as unknown as Record + ) as unknown as NodelinkConfig + + assert.equal(migrated.server.host, defaultConfig.server.host) + assert.equal(migrated.search.maxResults, defaultConfig.search.maxResults) + assert.equal( + migrated.playback.playerUpdateInterval, + defaultConfig.playback.playerUpdateInterval + ) + assert.equal( + migrated.api.enableTrackStreamEndpoint, + defaultConfig.api.enableTrackStreamEndpoint + ) + assert.equal(migrated.server.password, defaultConfig.server.password) +}) + +test('toTsLiteral generates idiomatic TypeScript formatting', () => { + const input = { + a: 1, + 'b-c': 'val', + d: [1, { e: true }], + f: null, + g: "'quotes'" + } + + const expected = `{ + a: 1, + 'b-c': 'val', + d: [ + 1, + { + e: true + } + ], + f: null, + g: '\\'quotes\\'' +}` + + assert.equal(toTsLiteral(input as Record), expected) +}) diff --git a/src/modules/config/configMigration.ts b/src/modules/config/configMigration.ts new file mode 100644 index 00000000..1c9a5de4 --- /dev/null +++ b/src/modules/config/configMigration.ts @@ -0,0 +1,231 @@ +import fs from 'node:fs/promises' +import path from 'node:path' +import type { JsonValue } from '../../typings/config/config.types.ts' + +/** + * Migrates old flat configuration structures to the new hierarchical NodeLink schema. + */ +export function migrateConfig( + oldConfig: Record +): Record { + const newConfig: Record = JSON.parse( + JSON.stringify(oldConfig) + ) + + const migrationMap: Record = { + host: 'server.host', + port: 'server.port', + password: 'server.password', + useBunServer: 'server.useBunServer', + trustProxy: 'trustProxy', + connection: 'connection', + proxy: 'network.proxy', + routePlanner: 'network.routePlanner', + maxSearchResults: 'search.maxResults', + defaultSearchSource: 'search.defaultSource', + unifiedSearchSources: 'search.unifiedSources', + resolveExternalLinks: 'search.resolveExternalLinks', + fetchChannelInfo: 'search.fetchChannelInfo', + maxAlbumPlaylistLength: 'playback.maxPlaylistLength', + playerUpdateInterval: 'playback.playerUpdateInterval', + statsUpdateInterval: 'playback.statsUpdateInterval', + trackStuckThresholdMs: 'playback.trackStuckThresholdMs', + eventTimeoutMs: 'playback.eventTimeoutMs', + zombieThresholdMs: 'playback.zombieThresholdMs', + sponsorblock: 'playback.sponsorblock', + filters: 'playback.filters', + audio: 'playback.audio', + voiceReceive: 'playback.voiceReceive', + mix: 'playback.mix', + enableTrackStreamEndpoint: 'api.enableTrackStreamEndpoint', + enableLoadStreamEndpoint: 'api.enableLoadStreamEndpoint', + dosProtection: 'dosProtection', + rateLimit: 'rateLimit', + metrics: 'metrics', + enableHoloTracks: 'experimental.enableHoloTracks', + commandTimeout: 'cluster.timeouts.heavyMs', + fastCommandTimeout: 'cluster.timeouts.fastMs' + } + + for (const [oldKey, newPath] of Object.entries(migrationMap)) { + if (Object.hasOwn(oldConfig, oldKey)) { + const value: unknown | undefined = oldConfig[oldKey] + if (value === undefined) continue + + // Do not overwrite already-migrated or explicit hierarchical values. + if (getDeepValue(newConfig, newPath) !== undefined) { + continue + } + + setDeepValue(newConfig, newPath, value) + } + } + + const cluster = newConfig.cluster as Record | undefined + const network = newConfig.network as Record | undefined + const clusterTimeouts = cluster?.timeouts as + | Record + | undefined + + const connection = getDeepValue(newConfig, 'connection') + if (connection) { + setDeepValue(newConfig, 'network.connection', connection) + } + + const metrics = getDeepValue(newConfig, 'metrics') + if (metrics) { + setDeepValue(newConfig, 'api.metrics', metrics) + } + + if ( + typeof cluster?.commandTimeout === 'number' && + typeof clusterTimeouts?.heavyMs !== 'number' + ) { + setDeepValue( + newConfig, + 'cluster.timeouts.heavyMs', + cluster.commandTimeout as JsonValue + ) + } + + if ( + typeof cluster?.fastCommandTimeout === 'number' && + typeof clusterTimeouts?.fastMs !== 'number' + ) { + setDeepValue( + newConfig, + 'cluster.timeouts.fastMs', + cluster.fastCommandTimeout as JsonValue + ) + } + + if (!network?.proxy || typeof network.proxy !== 'object') { + setDeepValue(newConfig, 'network.proxy', { + enabled: false, + strategy: 'RoundRobin', + retries: 3, + timeout: 10000, + shuffleOnStart: true, + list: [] + }) + } + + return newConfig +} + +function setDeepValue( + obj: Record, + path: string, + value: unknown +): void { + const parts = path.split('.') + if (parts.length === 0) return + let current = obj + for (let i = 0; i < parts.length - 1; i++) { + const part = parts[i] + if (!part) continue + if (!current[part] || typeof current[part] !== 'object') { + current[part] = {} + } + current = current[part] as Record + } + const leaf = parts[parts.length - 1] + if (!leaf) return + current[leaf] = value +} + +function getDeepValue( + obj: Record, + path: string +): unknown | undefined { + const parts = path.split('.') + let current: unknown = obj + for (const part of parts) { + if ( + !current || + typeof current !== 'object' || + Array.isArray(current) || + !(part in current) + ) { + return undefined + } + const next: unknown | undefined = (current as Record)[part] + if (next === undefined) return undefined + current = next + } + return current +} + +/** + * Converts a JavaScript object to a TypeScript literal string. + * Uses single quotes and avoids quoting keys when possible. + * + * @param obj - The object to convert. + * @param indent - Current indentation level. + * @returns A formatted string representation of the object. + * @internal + */ +export function toTsLiteral(obj: unknown, indent = 0): string { + const spaces = ' '.repeat(indent) + const nextSpaces = ' '.repeat(indent + 2) + + if (obj === null) return 'null' + if (typeof obj === 'string') return `'${obj.replace(/'/g, "\\'")}'` + if (typeof obj !== 'object') return String(obj) + + if (Array.isArray(obj)) { + if (obj.length === 0) return '[]' + const items = obj + .map((v) => toTsLiteral(v, indent + 2)) + .join(`,\n${nextSpaces}`) + return `[\n${nextSpaces}${items}\n${spaces}]` + } + + const keys = Object.keys(obj) + if (keys.length === 0) return '{}' + + const props = keys + .map((key) => { + const val: unknown | undefined = (obj as Record)[key] + if (val === undefined) return null + const value = toTsLiteral(val, indent + 2) + const validKey = /^[a-z_$][a-z0-9_$]*$/i.test(key) ? key : `'${key}'` + return `${validKey}: ${value}` + }) + .filter((v) => v !== null) + .join(`,\n${nextSpaces}`) + + return `{\n${nextSpaces}${props}\n${spaces}}` +} + +/** + * Persists a configuration object to config.ts if it was loaded from a legacy + * source or the default template. + * + * @param config - The migrated configuration object. + * @param fileName - The name of the source file. + */ +export async function persistConfig( + config: Record, + fileName: string +): Promise { + const isLegacy = fileName.endsWith('.js') + const isDefault = fileName.startsWith('config.default') + + if (!isLegacy && !isDefault) return + + try { + const configTsPath = path.resolve(process.cwd(), 'config.ts') + const literal = toTsLiteral(config) + const content = `import type { NodelinkConfig } from './src/typings/config/config.types.ts'\n\nexport const config: NodelinkConfig = ${literal}\n\nexport default config\n` + + await fs.writeFile(configTsPath, content, 'utf-8') + console.log( + `[INFO] Config: Automatically updated local config.ts from ${fileName}` + ) + } catch (err) { + console.warn( + `[WARN] Config: Failed to persist updated configuration: ${err instanceof Error ? err.message : String(err)}` + ) + } +} diff --git a/src/modules/spotifyAuth.ts b/src/modules/spotifyAuth.ts index 03971962..0d7d5f7d 100644 --- a/src/modules/spotifyAuth.ts +++ b/src/modules/spotifyAuth.ts @@ -158,7 +158,9 @@ async function getServerTime(spDc?: string | null): Promise { ? (JSON.parse(res.body) as SpotifyServerTimeResponse) : (res.body as SpotifyServerTimeResponse) - return typeof data.serverTime === 'number' ? data.serverTime : Date.now() + return typeof data.serverTime === 'number' + ? data.serverTime * 1000 + : Date.now() } catch { return Date.now() } @@ -212,10 +214,9 @@ async function performTokenRequest( productType: string ): Promise { const isWebPlayer = productType === 'web-player' - const serverTimeMs = isWebPlayer ? Date.now() : await getServerTime(spDc) - const localTimeMs = Date.now() + const serverTimeMs = await getServerTime(spDc) - const totpLocal = generateTOTP(secret, localTimeMs, 30) + const totpLocal = generateTOTP(secret, serverTimeMs, 30) const totpServer = generateTOTP(secret, serverTimeMs, 900) const url = new URL('https://open.spotify.com/api/token') diff --git a/src/playback/dash/DASHHandler.ts b/src/playback/dash/DASHHandler.ts index 346da3e6..7542448a 100644 --- a/src/playback/dash/DASHHandler.ts +++ b/src/playback/dash/DASHHandler.ts @@ -19,6 +19,7 @@ export class DASHHandler extends Transform { private readonly options: DASHHandlerOptions private stopped = false private abortController: AbortController | null = null + private readonly readWaiters: Array<() => void> = [] constructor(mpdUrl: string, options: DASHHandlerOptions = {}) { super() @@ -34,6 +35,24 @@ export class DASHHandler extends Transform { callback() } + override _read(size: number): void { + super._read(size) + this._resolveReadWaiters() + } + + override _destroy( + err: Error | null, + callback: (error?: Error | null) => void + ): void { + this.stop() + callback(err) + } + + private _resolveReadWaiters(): void { + const waiters = this.readWaiters.splice(0) + for (const resolve of waiters) resolve() + } + /** * Fetch the MPD, parse representations, select AACLC, and stream segments. * Uses a bounded prefetch queue with backpressure to keep memory minimal. @@ -99,9 +118,7 @@ export class DASHHandler extends Transform { return } - if (!this.push(initRes.body)) { - await this._waitForDrain() - } + await this._pushChunk(initRes.body) const totalSegments = this._countSegments(selected) const segmentUrlGen = this._generateSegmentUrls(selected) @@ -133,7 +150,8 @@ export class DASHHandler extends Transform { const fetchSegment = async (url: string): Promise => { try { const res = await fetch(url, { - headers: this.options.headers as Record + headers: this.options.headers as Record, + signal }) if (!res.ok || !res.body) { logger( @@ -173,7 +191,7 @@ export class DASHHandler extends Transform { const data = await pending if (data && !this.stopped && !signal.aborted) { - this.push(data) + await this._pushChunk(data) } if (fetchIndex < totalSegments) { @@ -212,6 +230,7 @@ export class DASHHandler extends Transform { stop(): void { this.stopped = true this.abortController?.abort() + this._resolveReadWaiters() } private _sleepOrStop(ms: number): Promise { @@ -232,18 +251,25 @@ export class DASHHandler extends Transform { private async _waitForBuffer(): Promise { while (this.readableLength > MAX_BUFFERED && !this.stopped) { - await this._waitForDrain() + await this._waitForRead() } } - private _waitForDrain(): Promise { + private _pushChunk(chunk: Buffer): Promise { + if (this.stopped || this.destroyed) return Promise.resolve() + if (this.push(chunk)) return Promise.resolve() + return this._waitForRead() + } + + private _waitForRead(): Promise { return new Promise((resolve) => { if (this.readableLength <= MAX_BUFFERED) { resolve() return } const cleanup = () => { - this.off('data', onData) + const index = this.readWaiters.indexOf(onRead) + if (index !== -1) this.readWaiters.splice(index, 1) this.off('end', onEnd) this.off('close', onEnd) } @@ -251,13 +277,13 @@ export class DASHHandler extends Transform { cleanup() resolve() } - const onData = () => { + const onRead = () => { if (this.readableLength <= MAX_BUFFERED) { cleanup() resolve() } } - this.on('data', onData) + this.readWaiters.push(onRead) this.once('end', onEnd) this.once('close', onEnd) }) diff --git a/src/playback/demuxers/WebmOpus.ts b/src/playback/demuxers/WebmOpus.ts index 7cd215c0..45f62d34 100644 --- a/src/playback/demuxers/WebmOpus.ts +++ b/src/playback/demuxers/WebmOpus.ts @@ -20,7 +20,7 @@ const parsePositiveIntEnv = (key: string, fallback: number): number => { } const BUFFER_SIZE = parsePositiveIntEnv( 'NODELINK_WEBM_DEMUX_RING_BYTES', - 2 * 1024 * 1024 + 512 * 1024 ) const TAGS: Readonly> = Object.freeze({ diff --git a/src/playback/filters/chorus.ts b/src/playback/filters/chorus.ts index a8fa83cf..8ab3dfa1 100644 --- a/src/playback/filters/chorus.ts +++ b/src/playback/filters/chorus.ts @@ -179,4 +179,10 @@ export default class Chorus extends AnimatableFilter { return Buffer.alloc(0) } + + public destroy(): void { + for (const delay of this.delays) { + delay.destroy() + } + } } diff --git a/src/playback/filters/dsp/delay.ts b/src/playback/filters/dsp/delay.ts index a80f2b58..c78f1cdb 100644 --- a/src/playback/filters/dsp/delay.ts +++ b/src/playback/filters/dsp/delay.ts @@ -3,7 +3,7 @@ * @public */ export default class DelayLine { - private buffer: Buffer + private buffer: Buffer | null private size: number private writeIndex: number @@ -22,7 +22,7 @@ export default class DelayLine { * @param sample - The PCM sample to write. */ public write(sample: number): void { - this.buffer.writeInt16LE(sample, this.writeIndex * 2) + this.buffer?.writeInt16LE(sample, this.writeIndex * 2) this.writeIndex = (this.writeIndex + 1) % this.size } @@ -38,13 +38,17 @@ export default class DelayLine { ) const readIndex = (this.writeIndex - safeDelay + this.size) % this.size - return this.buffer.readInt16LE(readIndex * 2) + return this.buffer?.readInt16LE(readIndex * 2) ?? 0 } /** * Clears the delay line buffer. */ public clear(): void { - this.buffer.fill(0) + this.buffer?.fill(0) + } + + public destroy(): void { + this.buffer = null } } diff --git a/src/playback/filters/dsp/float64Delay.ts b/src/playback/filters/dsp/float64Delay.ts index d59831b7..974889f4 100644 --- a/src/playback/filters/dsp/float64Delay.ts +++ b/src/playback/filters/dsp/float64Delay.ts @@ -14,7 +14,7 @@ * @public */ export class Float64DelayLine { - private readonly buffer: Float64Array + private buffer: Float64Array | null private readonly size: number private writeIndex: number @@ -29,7 +29,9 @@ export class Float64DelayLine { * no clamping or truncation. */ public write(sample: number): void { - this.buffer[this.writeIndex] = sample + const buf = this.buffer + if (!buf) return + buf[this.writeIndex] = sample this.writeIndex = (this.writeIndex + 1) % this.size } @@ -46,7 +48,7 @@ export class Float64DelayLine { if (delayInSamples <= 0) { // Reading current write position (most recent sample) const idx = (this.writeIndex - 1 + this.size) % this.size - return this.buffer[idx] ?? 0 + return this.buffer?.[idx] ?? 0 } const clamped = Math.min(delayInSamples, this.size - 1) @@ -56,8 +58,8 @@ export class Float64DelayLine { const idx0 = (this.writeIndex - intDelay - 1 + this.size * 2) % this.size const idx1 = (idx0 - 1 + this.size) % this.size - const s0 = this.buffer[idx0] ?? 0 - const s1 = this.buffer[idx1] ?? 0 + const s0 = this.buffer?.[idx0] ?? 0 + const s1 = this.buffer?.[idx1] ?? 0 // Linear interpolation: (1-frac)×s0 + frac×s1 return s0 + frac * (s1 - s0) @@ -67,6 +69,10 @@ export class Float64DelayLine { * Clears the delay line (zero-fill). */ public clear(): void { - this.buffer.fill(0) + this.buffer?.fill(0) + } + + public destroy(): void { + this.buffer = null } } diff --git a/src/playback/filters/echo.ts b/src/playback/filters/echo.ts index e5801b20..795c1657 100644 --- a/src/playback/filters/echo.ts +++ b/src/playback/filters/echo.ts @@ -149,4 +149,9 @@ export default class Echo extends AnimatableFilter { this.delayLineR.clear() return Buffer.alloc(0) } + + public destroy(): void { + this.delayLineL.destroy() + this.delayLineR.destroy() + } } diff --git a/src/playback/filters/flanger.ts b/src/playback/filters/flanger.ts index c0061375..f3e94eae 100644 --- a/src/playback/filters/flanger.ts +++ b/src/playback/filters/flanger.ts @@ -110,4 +110,8 @@ export default class Flanger extends AnimatableFilter { this.lfo.phase = 0 return Buffer.alloc(0) } + + public destroy(): void { + this.delayLine.destroy() + } } diff --git a/src/playback/filters/karaoke.ts b/src/playback/filters/karaoke.ts index 31436705..6466f6f4 100644 --- a/src/playback/filters/karaoke.ts +++ b/src/playback/filters/karaoke.ts @@ -377,4 +377,9 @@ export default class Karaoke extends AnimatableFilter { this._prevGain = MAX_OUTPUT_GAIN return Buffer.alloc(0) } + + public destroy(): void { + this._bufL = null + this._bufR = null + } } diff --git a/src/playback/filters/phonograph.ts b/src/playback/filters/phonograph.ts index 11b84b43..94d73103 100644 --- a/src/playback/filters/phonograph.ts +++ b/src/playback/filters/phonograph.ts @@ -35,21 +35,28 @@ class XorShift32 { } class InterpDelayLine { - private buf: Float32Array + private buf: Float32Array | null private w = 0 constructor(size: number) { this.buf = new Float32Array(size) } clear() { - this.buf.fill(0) + this.buf?.fill(0) this.w = 0 } + destroy() { + this.buf = null + } write(x: number) { - this.buf[this.w] = x - this.w = (this.w + 1) % this.buf.length + const buf = this.buf + if (!buf) return + buf[this.w] = x + this.w = (this.w + 1) % buf.length } read(delaySamples: number): number { - const n = this.buf.length + const buf = this.buf + if (!buf) return 0 + const n = buf.length let r = this.w - delaySamples while (r < 0) r += n while (r >= n) r -= n @@ -57,7 +64,7 @@ class InterpDelayLine { const i0 = r | 0 const i1 = (i0 + 1) % n const frac = r - i0 - return (this.buf[i0] ?? 0) * (1 - frac) + (this.buf[i1] ?? 0) * frac + return (buf[i0] ?? 0) * (1 - frac) + (buf[i1] ?? 0) * frac } } @@ -403,4 +410,11 @@ export default class Phonograph extends AnimatableFilter { this.agcGain = 1 return Buffer.alloc(0) } + + public destroy(): void { + this.delay.destroy() + this.r1.destroy() + this.r2.destroy() + this.r3.destroy() + } } diff --git a/src/playback/filters/reverb.ts b/src/playback/filters/reverb.ts index 0f773428..eaffb6e9 100644 --- a/src/playback/filters/reverb.ts +++ b/src/playback/filters/reverb.ts @@ -20,7 +20,7 @@ const OFFSET_ROOM = 0.7 * (which happens at feedback > ~0.75 on loud material). */ class CombFilter { - private readonly buffer: Float64Array + private buffer: Float64Array | null private readonly size: number private writeIndex = 0 private filterStore = 0 @@ -47,18 +47,25 @@ class CombFilter { * No clamping inside the loop — full Float64 precision. */ public process(input: number): number { - const output = this.buffer[this.writeIndex] ?? 0 + const buf = this.buffer + if (!buf) return 0 + const output = buf[this.writeIndex] ?? 0 this.filterStore = output * this.damp2 + this.filterStore * this.damp1 - this.buffer[this.writeIndex] = input + this.filterStore * this.feedback + buf[this.writeIndex] = input + this.filterStore * this.feedback this.writeIndex = (this.writeIndex + 1) % this.size return output } public clear(): void { - this.buffer.fill(0) + this.buffer?.fill(0) this.filterStore = 0 this.writeIndex = 0 } + + public destroy(): void { + this.buffer = null + this.filterStore = 0 + } } /** @@ -365,4 +372,21 @@ export default class Reverb extends AnimatableFilter { return Buffer.alloc(0) } + + public destroy(): void { + for (const comb of [ + ...this.combFiltersL, + ...this.combFiltersR, + ...this.customCombsL, + ...this.customCombsR + ]) { + comb.destroy() + } + this.combFiltersL = [] + this.combFiltersR = [] + this.customCombsL = [] + this.customCombsR = [] + this.allpassBuffersL = [] + this.allpassBuffersR = [] + } } diff --git a/src/playback/filters/spatial.ts b/src/playback/filters/spatial.ts index 5a9f247f..ef5d888e 100644 --- a/src/playback/filters/spatial.ts +++ b/src/playback/filters/spatial.ts @@ -120,4 +120,9 @@ export default class Spatial extends AnimatableFilter { return Buffer.alloc(0) } + + public destroy(): void { + this.leftDelay.destroy() + this.rightDelay.destroy() + } } diff --git a/src/playback/filters/tesseract.ts b/src/playback/filters/tesseract.ts new file mode 100644 index 00000000..137a60b2 --- /dev/null +++ b/src/playback/filters/tesseract.ts @@ -0,0 +1,114 @@ +import { SAMPLE_RATE } from '../../constants.ts' +import type { FilterSettings } from '../../typings/playback/filters.types.ts' +import { AnimatableFilter } from './AnimatableFilter.ts' +import { clamp16Bit } from './dsp/clamp16Bit.ts' +import LFO from './dsp/lfo.ts' + +const CHANNELS = 2 + +export default class Tesseract extends AnimatableFilter { + public priority = 11 + private lfoTheta: LFO + private lfoPhi: LFO + private lfoGamma: LFO + private rotationHz = 0 + private alpha = 0 + + private delaySamples = Math.floor(SAMPLE_RATE * 0.015) + private delayBufferL = new Int16Array(this.delaySamples) + private delayBufferR = new Int16Array(this.delaySamples) + private delayIndex = 0 + + constructor() { + super() + this.lfoTheta = new LFO('SINE') + this.lfoPhi = new LFO('SINE') + this.lfoGamma = new LFO('SINE') + } + + public override update(settings: FilterSettings): void { + const r = settings?.tesseract || {} + const isDisabled = (r as Record)._disabled === true + + this.rotationHz = r.rotationHz ?? 0 + if (this.rotationHz > 0.001) { + this.lfoTheta.update(this.rotationHz, 1) + this.lfoPhi.update(this.rotationHz * 1.33, 1) + this.lfoGamma.update(this.rotationHz * 0.77, 1) + } + + const targetAlpha = isDisabled ? 0.0 : this.rotationHz > 0.001 ? 1.0 : 0.0 + + super.applyAnimatedUpdate( + { tesseract: { alpha: targetAlpha } }, + 'tesseract', + { alpha: 0.0 } + ) + } + + protected override onConfigChanged(config: Record): void { + this.alpha = config.alpha ?? 0 + } + + protected override isConfigActive(config?: Record): boolean { + const a = config ? config.alpha : this.alpha + return (a ?? 0) > 0.001 + } + + public override process(chunk: Buffer): Buffer { + super.processAnimation(SAMPLE_RATE, chunk.length, CHANNELS) + + if (this.alpha <= 0.001) { + return chunk + } + + const alpha = this.alpha + + for (let i = 0; i < chunk.length; i += 4) { + const thetaVal = this.lfoTheta.getValue() * Math.PI + const phiVal = this.lfoPhi.getValue() * Math.PI + const gammaVal = this.lfoGamma.getValue() * Math.PI + + const sinTheta = Math.sin(thetaVal) + const cosTheta = Math.cos(thetaVal) + const sinPhi = Math.sin(phiVal) + const cosPhi = Math.cos(phiVal) + const sinGamma = Math.sin(gammaVal) + const cosGamma = Math.cos(gammaVal) + + const L = chunk.readInt16LE(i) + const R = chunk.readInt16LE(i + 2) + + const Y = this.delayBufferL[this.delayIndex] ?? 0 + const Z = this.delayBufferR[this.delayIndex] ?? 0 + + this.delayBufferL[this.delayIndex] = L + this.delayBufferR[this.delayIndex] = R + this.delayIndex = (this.delayIndex + 1) % this.delaySamples + + const L_rot = L * cosTheta - Y * sinTheta + const R_rot = R * cosPhi - Z * sinPhi + + const newLeft = L_rot * cosGamma - R_rot * sinGamma + const newRight = L_rot * sinGamma + R_rot * cosGamma + + const finalLeft = L * (1 - alpha) + newLeft * alpha + const finalRight = R * (1 - alpha) + newRight * alpha + + chunk.writeInt16LE(clamp16Bit(finalLeft), i) + chunk.writeInt16LE(clamp16Bit(finalRight), i + 2) + } + + return chunk + } + + public override flush(): Buffer { + this.lfoTheta.phase = 0 + this.lfoPhi.phase = 0 + this.lfoGamma.phase = 0 + this.delayBufferL.fill(0) + this.delayBufferR.fill(0) + this.delayIndex = 0 + return Buffer.alloc(0) + } +} diff --git a/src/playback/filters/timescale.ts b/src/playback/filters/timescale.ts index 395af51e..98463e42 100644 --- a/src/playback/filters/timescale.ts +++ b/src/playback/filters/timescale.ts @@ -256,4 +256,8 @@ export default class Timescale extends AnimatableFilter { this._reset() return floatToInt16Buffer(combined) } + + public destroy(): void { + this._timeStretch.destroy() + } } diff --git a/src/playback/filters/timescale/floatFifoBuffer.ts b/src/playback/filters/timescale/floatFifoBuffer.ts index 4a1bf4e4..71127232 100644 --- a/src/playback/filters/timescale/floatFifoBuffer.ts +++ b/src/playback/filters/timescale/floatFifoBuffer.ts @@ -56,6 +56,12 @@ export default class FloatFifoBuffer { this._frames = 0 } + public destroy(): void { + // biome-ignore lint/suspicious/noExplicitAny: intentional null to release buffer + ;(this as any)._buffer = null + this._frames = 0 + } + /** * Calculates the starting sample index. */ diff --git a/src/playback/filters/timescale/timeStretch.ts b/src/playback/filters/timescale/timeStretch.ts index 5ccb0881..fe56b9c0 100644 --- a/src/playback/filters/timescale/timeStretch.ts +++ b/src/playback/filters/timescale/timeStretch.ts @@ -84,6 +84,11 @@ export default class TimeStretch { this._prevOverlap = null } + public destroy(): void { + this._buffer.destroy() + this._prevOverlap = null + } + /** * Processes new audio samples. * @param samples - The input Float32Array of samples. diff --git a/src/playback/filters/vibrato.ts b/src/playback/filters/vibrato.ts index be4656ee..eae99f3b 100644 --- a/src/playback/filters/vibrato.ts +++ b/src/playback/filters/vibrato.ts @@ -118,4 +118,9 @@ export default class Vibrato extends AnimatableFilter { this.lfo.phase = 0 return Buffer.alloc(0) } + + public destroy(): void { + this.leftDelay.destroy() + this.rightDelay.destroy() + } } diff --git a/src/playback/hls/HLSHandler.ts b/src/playback/hls/HLSHandler.ts index 1c1b5812..84cf527f 100644 --- a/src/playback/hls/HLSHandler.ts +++ b/src/playback/hls/HLSHandler.ts @@ -71,7 +71,7 @@ export default class HLSHandler extends PassThrough { this.currentUrl = url this.headers = options.headers ?? {} this.localAddress = options.localAddress ?? null - this.proxy = options.proxy ?? null + this.proxy = options.network?.proxy ?? options.proxy ?? null this.onResolveUrl = options.onResolveUrl ?? null this.strategy = options.strategy ?? diff --git a/src/playback/hls/PlaylistParser.ts b/src/playback/hls/PlaylistParser.ts index 5bb723d0..7b63236f 100644 --- a/src/playback/hls/PlaylistParser.ts +++ b/src/playback/hls/PlaylistParser.ts @@ -69,7 +69,14 @@ export function parse(content: string, baseUrl: string): HLSPlaylist { } else if (line.startsWith('#EXT-X-KEY:')) { currentKey = parseAttributes(line, baseUrl) as unknown as HLSSegmentKey } else if (line.startsWith('#EXT-X-MAP:')) { - currentMap = parseAttributes(line, baseUrl) as unknown as HLSSegmentMap + const attrs = parseAttributes(line, baseUrl) + currentMap = { + uri: typeof attrs.uri === 'string' ? attrs.uri : undefined, + byteRange: + typeof attrs.byterange === 'string' + ? parseByteRange(attrs.byterange, null) + : null + } } else if (line.startsWith('#EXTINF:')) { const parts = line.split(':') const part1 = parts[1] diff --git a/src/playback/hls/SegmentFetcher.ts b/src/playback/hls/SegmentFetcher.ts index 73777ac0..0fe47c59 100644 --- a/src/playback/hls/SegmentFetcher.ts +++ b/src/playback/hls/SegmentFetcher.ts @@ -75,7 +75,7 @@ export default class SegmentFetcher { constructor(options: SegmentFetcherOptions = {}) { this.headers = options.headers || {} this.localAddress = options.localAddress || null - this.proxy = options.proxy || null + this.proxy = options.network?.proxy || options.proxy || null this.onResolveUrl = options.onResolveUrl || null this.keyMap = new Map() } @@ -136,14 +136,22 @@ export default class SegmentFetcher { ): Promise { if (!mapInfo?.uri) return null + const headers: Record & { Range?: string } = { + ...this.headers + } + if (mapInfo.byteRange) { + const end = mapInfo.byteRange.offset + mapInfo.byteRange.length - 1 + headers.Range = `bytes=${mapInfo.byteRange.offset}-${end}` + } + const { body, error, statusCode } = await http1makeRequest(mapInfo.uri, { - headers: this.headers, + headers, responseType: 'buffer', localAddress: this.localAddress ?? undefined, proxy: this.proxy ?? undefined }) - if (error || statusCode !== 200) { + if (error || (statusCode !== 200 && statusCode !== 206)) { throw new Error(`Map fetch failed: ${statusCode}`) } diff --git a/src/playback/opus/Opus.ts b/src/playback/opus/Opus.ts index 3de6aee9..814b13b8 100644 --- a/src/playback/opus/Opus.ts +++ b/src/playback/opus/Opus.ts @@ -1,4 +1,4 @@ -import type { Buffer } from 'node:buffer' +import { Buffer } from 'node:buffer' import { createRequire } from 'node:module' import { Transform } from 'node:stream' import type { @@ -12,6 +12,12 @@ import { bufferPool } from '../structs/BufferPool.ts' const require = createRequire(import.meta.url) +const OPUS_MAX_PACKET_SIZE = 4000 +const OPUS_MAX_PACKET_DURATION_MS = 120 +const PCM_SAMPLE_BYTES = 2 + +// ^^ @toddynnn/voice-opus related, the encodeInto() functions does not check for MAX_PACKET_SIZE, unlike the encode(). + const OPUS_CTL = { BITRATE: 4002, FEC: 4012, @@ -19,17 +25,6 @@ const OPUS_CTL = { DTX: 4016 } -const parsePositiveIntEnv = (key: string, fallback: number): number => { - const raw = process.env[key] - if (!raw) return fallback - const parsed = Number.parseInt(raw, 10) - return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback -} - -const RING_SIZE = parsePositiveIntEnv( - 'NODELINK_OPUS_ENCODER_RING_BYTES', - 512 * 1024 -) let ACTIVE_LIB: OpusLibrary | null = null const _getLib = (): OpusLibrary => { @@ -109,10 +104,9 @@ export class Encoder extends Transform { private lib: OpusLibrary private frameSize: number private frameBytes: number - private ring: Buffer | null - private swap: Buffer | null - private writePos: number - private readPos: number + private leftover: Buffer | null + private leftoverStorage: Buffer | null + private encodedScratch: Buffer | null constructor({ rate = 48000, @@ -131,11 +125,10 @@ export class Encoder extends Transform { this.enc = instance as OpusEncoderInstance this.lib = lib this.frameSize = frameSize - this.frameBytes = frameSize * channels * 2 - this.ring = bufferPool.acquire(RING_SIZE) - this.swap = bufferPool.acquire(this.frameBytes) - this.writePos = 0 - this.readPos = 0 + this.frameBytes = frameSize * channels * PCM_SAMPLE_BYTES + this.leftover = null + this.leftoverStorage = null + this.encodedScratch = Buffer.allocUnsafe(OPUS_MAX_PACKET_SIZE) } override _transform( @@ -147,68 +140,74 @@ export class Encoder extends Transform { cb() return } - if (!this.ring || !this.swap) { + if (!this.enc) { cb(new Error('Encoder destroyed.')) return } - let wp = this.writePos - let rp = this.readPos - const total = chunk.length - let remaining = total - - while (remaining > 0) { - const space = RING_SIZE - wp - const canWrite = remaining < space ? remaining : space - chunk.copy(this.ring, wp, total - remaining, total - remaining + canWrite) - remaining -= canWrite - wp += canWrite - if (wp === RING_SIZE) wp = 0 + let buf: Buffer + let pooledBuf: Buffer | null = null + + if (this.leftover?.length) { + const totalLen = this.leftover.length + chunk.length + pooledBuf = bufferPool.acquire(totalLen) + this.leftover.copy(pooledBuf, 0) + chunk.copy(pooledBuf, this.leftover.length) + if (this.leftoverStorage) bufferPool.release(this.leftoverStorage) + this.leftover = null + this.leftoverStorage = null + buf = pooledBuf.subarray(0, totalLen) + } else { + buf = chunk } - while (true) { - const available = wp >= rp ? wp - rp : RING_SIZE - rp + wp - if (available < this.frameBytes) break + const frames = Math.floor(buf.length / this.frameBytes) + const consumed = frames * this.frameBytes - let frame: Buffer - const end = rp + this.frameBytes - - if (end <= RING_SIZE) { - frame = this.ring.subarray(rp, end) - } else { - const first = RING_SIZE - rp - this.ring.copy(this.swap, 0, rp, RING_SIZE) - this.ring.copy(this.swap, first, 0, this.frameBytes - first) - frame = this.swap.subarray(0, this.frameBytes) - } + for (let i = 0; i < frames; i++) { + const off = i * this.frameBytes + const frame = buf.subarray(off, off + this.frameBytes) try { - if (!this.enc) throw new Error('Encoder not ready.') - - if (this.lib.name === 'opusscript') { - this.push(this.enc.encode(frame, this.frameSize)) + let encoded: Buffer + if (this.enc.encodeInto && this.encodedScratch) { + const written = this.enc.encodeInto(frame, this.encodedScratch) + encoded = Buffer.from(this.encodedScratch.subarray(0, written)) } else { - this.push(this.enc.encode(frame)) + encoded = + this.lib.name === 'opusscript' + ? this.enc.encode(frame, this.frameSize) + : this.enc.encode(frame) } + + this.push(encoded) } catch (e) { - this.writePos = wp - this.readPos = rp + this.leftover = null + this.leftoverStorage = null + if (pooledBuf) bufferPool.release(pooledBuf) cb(e instanceof Error ? e : new Error(String(e))) return } + } - rp += this.frameBytes - if (rp >= RING_SIZE) rp -= RING_SIZE + if (consumed < buf.length) { + const remaining = buf.subarray(consumed) + this.leftoverStorage = bufferPool.acquire(remaining.length) + remaining.copy(this.leftoverStorage, 0, 0, remaining.length) + this.leftover = this.leftoverStorage.subarray(0, remaining.length) } - this.writePos = wp - this.readPos = rp + // Release the temporary concatenation buffer back to the pool + if (pooledBuf) bufferPool.release(pooledBuf) cb() } override _flush(cb: (err?: Error) => void): void { - this.writePos = 0 - this.readPos = 0 + if (this.leftover) { + if (this.leftoverStorage) bufferPool.release(this.leftoverStorage) + this.leftover = null + this.leftoverStorage = null + } cb() } @@ -217,13 +216,11 @@ export class Encoder extends Transform { this.enc.delete() } this.enc = null - if (this.ring) { - bufferPool.release(this.ring) - this.ring = null - } - if (this.swap) { - bufferPool.release(this.swap) - this.swap = null + this.encodedScratch = null + if (this.leftover) { + if (this.leftoverStorage) bufferPool.release(this.leftoverStorage) + this.leftover = null + this.leftoverStorage = null } cb(err) } @@ -253,6 +250,7 @@ export class Encoder extends Transform { export class Decoder extends Transform { private dec: OpusDecoderInstance | null private lib: OpusLibrary + private pcmScratch: Buffer | null constructor({ rate = 48000, @@ -262,6 +260,12 @@ export class Decoder extends Transform { const { instance, lib } = _createInstance(rate, channels, 'voip') this.dec = instance as OpusDecoderInstance this.lib = lib + const maxSamplesPerChannel = Math.ceil( + (rate * OPUS_MAX_PACKET_DURATION_MS) / 1000 + ) + this.pcmScratch = Buffer.allocUnsafe( + maxSamplesPerChannel * channels * PCM_SAMPLE_BYTES + ) } override _transform( @@ -271,7 +275,16 @@ export class Decoder extends Transform { ): void { try { if (!this.dec) throw new Error('Decoder not ready.') - this.push(this.dec.decode(chunk)) + if (this.dec.decodeInto && this.pcmScratch) { + const written = this.dec.decodeInto(chunk, this.pcmScratch) + // Copy because stream consumers may retain the chunk after this call. + // pushing it to scratch would result: + // the scratch subarray would allow the next frame to overwrite queued audio, causing corruption. + // and its also required by ownership boundary btw. + this.push(Buffer.from(this.pcmScratch.subarray(0, written))) + } else { + this.push(this.dec.decode(chunk)) + } cb() } catch (e) { cb(e instanceof Error ? e : new Error(String(e))) @@ -283,6 +296,7 @@ export class Decoder extends Transform { this.dec.delete() } this.dec = null + this.pcmScratch = null cb(err) } } diff --git a/src/playback/player.ts b/src/playback/player.ts index 5b43fa40..edc62019 100644 --- a/src/playback/player.ts +++ b/src/playback/player.ts @@ -1,13 +1,14 @@ import type { Readable } from 'node:stream' import { PassThrough } from 'node:stream' +import { setTimeout as sleep } from 'node:timers/promises' import { SeekError } from '@ecliptia/seekable-stream' import discordVoice, { type VoiceAudioStream, - type VoiceConnection, type VoiceConnectionState, type VoicePlayerState } from '@performanc/voice' import { EndReasons, GatewayEvents } from '../constants.ts' +import type { DuckingConfig } from '../typings/playback/ducking.types.ts' import type { AudioMixer, AudioOptionsWithTransitions, @@ -15,6 +16,7 @@ import type { CreateAudioResource, CreateSeekeableAudioResource, ExtendedAudioStream, + ExtendedVoiceConnection, FadeTimers, FadingConfig, FadingSection, @@ -38,6 +40,7 @@ import type { } from '../typings/playback/player.types.ts' import type { TrackUrlResult } from '../typings/sources/source.types.ts' import { logger } from '../utils.ts' +import { DuckingController } from './processing/DuckingController.ts' export type GatewayEventName = (typeof GatewayEvents)[keyof typeof GatewayEvents] @@ -45,14 +48,8 @@ export type EndReason = (typeof EndReasons)[keyof typeof EndReasons] let createAudioResource: CreateAudioResource | null = null let createSeekeableAudioResource: CreateSeekeableAudioResource | null = null -const env = process.env as NodeJS.ProcessEnv & { - NODELINK_TRACK_FINISH_MEMORY_TRACE?: string - NODELINK_TRACK_FINISH_FORCE_GC?: string -} const trackFinishMemoryTraceEnabled = - env.NODELINK_TRACK_FINISH_MEMORY_TRACE?.toLowerCase() === 'true' -const trackFinishForceGcEnabled = - env.NODELINK_TRACK_FINISH_FORCE_GC?.toLowerCase() === 'true' + process.env.NODELINK_TRACK_FINISH_MEMORY_TRACE?.toLowerCase() === 'true' async function getStreamProcessor(): Promise { if (createAudioResource && createSeekeableAudioResource) return @@ -87,13 +84,14 @@ export class Player { private holoTrack: PlayerTrack | null = null private nextTrack: PlayerTrack | null = null private nextResource: AudioResource | null = null + private _currentResource: AudioResource | null = null private nextStreamInfo: StreamInfo = null public isPaused = false public volumePercent: number public filters: FiltersState = {} public position = 0 public connStatus: VoiceConnectionState['status'] = 'disconnected' - public connection: VoiceConnection | null = null + public connection: ExtendedVoiceConnection | null = null public voice: PlayerVoiceState = { sessionId: null, token: null, @@ -115,6 +113,7 @@ export class Player { public audioMixer: AudioMixer | null = null public fading?: FadingConfig public loudnessNormalizer: boolean + public duckingController: DuckingController | null = null private _fadeTimers: FadeTimers = { trackEnd: null, pause: null, stop: null } private _isResuming = false private _pendingTrackStartFade = false @@ -150,8 +149,22 @@ export class Player { private _isStopping = false private _pausedAtPosition: number | undefined = undefined public stuckRecoveryCount = 0 + private _positionAtRecoveryStart = 0 private static MAX_STUCK_RECOVERY_ATTEMPTS = 3 + private _connStateHandler: ( + _: VoiceConnectionState | null, + s: VoiceConnectionState + ) => void = () => {} + private _connPlayHandler: ( + _: VoicePlayerState | null, + s: VoicePlayerState & { reason?: string } + ) => void = () => {} + private _connErrorHandler: (err: Error) => void = () => {} + private _connStuckHandler: () => void = () => {} + private _connSpeakStartHandler: (userId: string, ssrc: number) => void = + () => {} + constructor(options: PlayerOptions) { if ( !options.nodelink || @@ -166,13 +179,19 @@ export class Player { this.session = options.session this.guildId = options.guildId this.volumePercent = this.nodelink.options?.defaultVolume ?? 100 - this.fading = this.nodelink.options?.audio?.fading + this.fading = this.nodelink.options?.playback.audio?.fading this.loudnessNormalizer = - this.nodelink.options?.audio?.loudnessNormalizer ?? false + this.nodelink.options?.playback.audio?.loudnessNormalizer ?? false + + // Initialize ducking controller from config + const duckingCfg = this._resolveDuckingConfig() + if (duckingCfg.enabled) { + this.duckingController = new DuckingController(this.guildId, duckingCfg) + } this.sponsorBlock = { - enabled: this.nodelink.options.sponsorblock?.enabled ?? false, - categories: this.nodelink.options.sponsorblock?.categories ?? [ + enabled: this.nodelink.options.playback.sponsorblock?.enabled ?? false, + categories: this.nodelink.options.playback.sponsorblock?.categories ?? [ 'sponsor', 'selfpromo', 'interaction', @@ -182,10 +201,13 @@ export class Player { 'music_offtopic', 'filler' ], - actionTypes: this.nodelink.options.sponsorblock?.actionTypes ?? ['skip'], + actionTypes: this.nodelink.options.playback.sponsorblock?.actionTypes ?? [ + 'skip' + ], segments: [], lastSkippedUuid: null, - skipMarginMs: this.nodelink.options.sponsorblock?.skipMarginMs ?? 150 + skipMarginMs: + this.nodelink.options.playback.sponsorblock?.skipMarginMs ?? 150 } logger( @@ -226,20 +248,45 @@ export class Player { this.waitEvent = ( event, filter, - timeout = this.nodelink.options.eventTimeoutMs ?? 15000 + timeout = this.nodelink.options.playback.eventTimeoutMs ?? 15000 ) => new Promise((resolve, reject) => { + logger( + 'debug', + 'Player', + `waitEvent: Started waiting for '${event}' on guild ${this.guildId} (timeout: ${timeout}ms)` + ) + const conn = this.connection + if (!conn) { + logger( + 'warn', + 'Player', + `waitEvent: Aborted waiting for '${event}' on guild ${this.guildId} (no connection)` + ) + return reject(new Error('No connection available for waitEvent')) + } + const handler = (_: unknown, payload: unknown) => { const typedPayload = payload as unknown as Record if (!filter || filter(typedPayload as never)) { clearTimeout(timeoutId) - this.connection?.off(event, handler) + conn.off(event, handler) + logger( + 'debug', + 'Player', + `waitEvent: Resolved '${event}' for guild ${this.guildId}` + ) resolve(typedPayload as never) } } const timeoutId = setTimeout(() => { - this.connection?.off(event, handler) + conn.off(event, handler) + logger( + 'warn', + 'Player', + `waitEvent: Timeout waiting for '${event}' on guild ${this.guildId}` + ) reject( new Error( `Event ${event} timed out after ${timeout}ms for guild ${this.guildId}` @@ -247,12 +294,12 @@ export class Player { ) }, timeout) - this.connection?.on(event, handler) + conn.on(event, handler) }) } private _getAudioOptions(): AudioOptionsWithTransitions | undefined { - return this.nodelink.options.audio as + return this.nodelink.options.playback.audio as | AudioOptionsWithTransitions | undefined } @@ -273,7 +320,7 @@ export class Player { const { AudioMixer: Mixer } = await import('./processing/AudioMixer.ts') this.audioMixer = new Mixer( - this.nodelink.options?.mix ?? { + this.nodelink.options?.playback.mix ?? { enabled: true, defaultVolume: 0.8, maxLayersMix: 5, @@ -320,61 +367,105 @@ export class Player { await this._audioMixerInitPromise } + private _destroyAudioMixer(): void { + if (this.audioMixer) { + this.audioMixer.destroy() + this.audioMixer = null + } + this._audioMixerInitPromise = null + } + /** * Establishes the voice connection and attaches event listeners. */ private _initConnection(): void { if (this.connection || this.destroying) return + logger( + 'debug', + 'Player', + `[Connection] Initializing voice connection for guild ${this.guildId} (Session: ${this.session.id})` + ) this.connection = discordVoice.joinVoiceChannel({ guildId: this.guildId, userId: this.session.userId, channelId: this.voice.channelId || this.guildId, - encryption: this.nodelink.options?.audio?.encryption ?? null + encryption: this.nodelink.options?.playback.audio?.encryption ?? null }) - this.connection.on( - 'stateChange', - (_: VoiceConnectionState | null, s: VoiceConnectionState) => { - logger( - 'debug', - 'Player', - `Voice connection state change for guild ${this.guildId} in session ${this.session.id}: ${s.status}` - ) - this._onConn(s) - } - ) - this.connection.on( - 'playerStateChange', - (_: VoicePlayerState | null, s: VoicePlayerState & { reason?: string }) => - this._onPlay(s) - ) - this.connection.on('error', (err) => { + this.connection.stuckTimeout = + Math.max( + this.nodelink.options.playback.trackStuckThresholdMs ?? 10000, + 30000 + ) + 5000 + this._connStateHandler = ( + _: VoiceConnectionState | null, + s: VoiceConnectionState + ) => { + logger( + 'debug', + 'Player', + `Voice connection state change for guild ${this.guildId} in session ${this.session.id}: ${s.status}` + ) + this._onConn(s) + } + this.connection.on('stateChange', this._connStateHandler) + this._connPlayHandler = ( + _: VoicePlayerState | null, + s: VoicePlayerState & { reason?: string } + ) => this._onPlay(s) + this.connection.on('playerStateChange', this._connPlayHandler) + this._connErrorHandler = (err: Error) => { logger( 'error', 'Player', `Voice connection error for guild ${this.guildId} in session ${this.session.id}:`, err ) - this._onError(err) - }) - this.connection.on('audioStream', (audioStream: VoiceAudioStream) => { - const dataHandler = () => { - this._lastStreamDataTime = Date.now() - if (this.isLyricsSubscribed && !this.isPaused && this.track) { - this._syncLyrics() + + process.nextTick(() => { + if (this.destroying) return + + const playerReason = this.connection?.playerState?.reason + if (playerReason === 'reconnecting') { + logger( + 'warn', + 'Player', + `Voice connection error for guild ${this.guildId} is a recoverable reconnection (playerState.reason=${playerReason}). Deferring to library.` + ) + return } - } - audioStream.on('data', dataHandler) - audioStream.once('close', () => { - audioStream.off('data', dataHandler) - }) - audioStream.once('end', () => { - audioStream.off('data', dataHandler) + + this._onError(err) }) - }) + } + this.connection.on('error', this._connErrorHandler) + this._connStuckHandler = () => { + if (this.destroying) return + logger( + 'warn', + 'Player', + `Voice library detected stuck stream for guild ${this.guildId}` + ) + } + this.connection.on('stuck', this._connStuckHandler) + + // Automatically drain incoming voice streams to prevent memory leaks + this._connSpeakStartHandler = (_userId: string, ssrc: number) => { + if (this.destroying || !this.connection) return + const stream = this.connection.getSpeakStream?.(ssrc) + if (stream && !stream.destroyed) { + stream.resume() + } + } + this.connection.on('speakStart', this._connSpeakStartHandler) if (this.nodelink.voiceRelay?.attach) { this.nodelink.voiceRelay.attach(this.connection, this.guildId) } + + // Attach ducking controller to the voice connection + if (this.duckingController && this.connection) { + this.duckingController.attach(this.connection) + } } /** @@ -382,6 +473,7 @@ export class Player { */ private _onConn(state: VoiceConnectionState): void { if (this.destroying) return + const previousStatus = this.connStatus this.connStatus = state.status if (state.status === 'connected') { logger( @@ -391,7 +483,7 @@ export class Player { ) this.emitEvent(GatewayEvents.PLAYER_CONNECTED, { guildId: this.guildId, - voice: { ...this.voice } + voice: structuredClone(this.voice) }) if (this.track && this.isPaused && this.connection?.audioStream) { this.isPaused = false @@ -402,20 +494,38 @@ export class Player { `Unpaused track on reconnection for guild ${this.guildId}` ) } - } else if (state.status === 'reconnecting') { - logger( - 'info', - 'Player', - `Voice connection is reconnecting for guild ${this.guildId}` - ) - this.emitEvent(GatewayEvents.PLAYER_RECONNECTING, { - guildId: this.guildId, - voice: { ...this.voice } - }) + } else if (state.status === 'connecting') { + if (previousStatus !== 'disconnected' || this.connection?.audioStream) { + logger( + 'info', + 'Player', + `Voice connection is reconnecting for guild ${this.guildId}` + ) + this.emitEvent(GatewayEvents.PLAYER_RECONNECTING, { + guildId: this.guildId, + voice: structuredClone(this.voice) + }) + } } else if (state.status === 'disconnected') { + const reason = state.reason + if (reason === 'reconnect_circuit_breaker') { + logger( + 'error', + 'Player', + `Voice connection circuit breaker triggered for guild ${this.guildId}. Too many reconnection attempts.` + ) + this.emitEvent(GatewayEvents.TRACK_EXCEPTION, { + track: this.track, + exception: { + message: 'Voice reconnection circuit breaker triggered', + severity: 'fault', + cause: 'RECONNECT_CIRCUIT_BREAKER' + } + }) + } this.emitEvent(GatewayEvents.WEBSOCKET_CLOSED, { code: state.code, - reason: state.closeReason, + reason: state.closeReason ?? state.reason, byRemote: true }) } else if (state.status === 'destroyed') { @@ -466,7 +576,8 @@ export class Player { 'Player', `Track became stuck for guild ${this.guildId}. Triggering immediate recovery.` ) - this._stuckTime = this.nodelink.options.trackStuckThresholdMs + 1 + this._stuckTime = + (this.nodelink.options.playback.trackStuckThresholdMs ?? 0) + 1 this._sendUpdate() return } @@ -517,7 +628,22 @@ export class Player { this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0 - this.connection?.play(resource as unknown) + const oldStream = this.connection?.play(resource as unknown) + if (oldStream) oldStream.destroy() + if (this._currentResource && this._currentResource !== resource) { + try { + this._currentResource.destroy() + } catch {} + } + this._currentResource = resource + + if (this.duckingController && this.connection && resource.fadeTo) { + this.duckingController.attach(this.connection) + this.duckingController.setStreamControl({ + fadeTo: (volume: number, durationMs: number, curve?: string) => + resource.fadeTo?.(volume, durationMs, curve) + }) + } return } @@ -545,21 +671,19 @@ export class Player { this._emitTrackEnd(endReason) this._resetTrack() this._traceTrackFinishMemory('after-reset') - this._scheduleTrackFinishGcProbe() } else if ( state.status === 'playing' && this.track && !this._isSeeking && - (['requested', 'reconnected', 'seamless_bridge'].includes( - state.reason ?? '' - ) || + (['requested', 'reconnected', 'unpaused'].includes(state.reason ?? '') || this._pendingTrackStartFade) ) { const wasResuming = this._isResuming this._isResuming = false this.isPaused = false + this._lastStreamDataTime = Date.now() - if (wasResuming && state.reason !== 'seamless_bridge') { + if (wasResuming) { this._fading('trackEndSchedule', { startPosition: this._pausedAtPosition ?? this._realPosition() }) @@ -570,8 +694,21 @@ export class Player { this._fading('trackStart') this._emitTrackStart().catch((err) => this._onError(err)) } - } else if (state.status === 'paused') { + } else if ( + state.status === 'idle' && + (state.reason === 'paused' || state.reason === 'requested') + ) { this.isPaused = true + } else if (state.status === 'idle' && state.reason === 'reconnecting') { + logger( + 'info', + 'Player', + `Voice library reports reconnecting for guild ${this.guildId}` + ) + this.emitEvent(GatewayEvents.PLAYER_RECONNECTING, { + guildId: this.guildId, + voice: structuredClone(this.voice) + }) } } @@ -688,9 +825,12 @@ export class Player { this.position = 0 this._pausedAtPosition = undefined this._lastStreamDataTime = 0 + this.streamInfo = null + this.sponsorBlock.segments = [] this.currentLyrics = null this.lyricsLineIndex = -1 this._fading('reset') + this._destroyAudioMixer() this._lyricsBasePosition = 0 this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0 if (this._lyricsMarkerTimer) { @@ -721,19 +861,44 @@ export class Player { * Destroys and dereferences current audio stream to avoid lingering references. */ private _cleanupCurrentAudioStream(context: string): void { - const conn = this.connection as - | (VoiceConnection & { audioStream?: VoiceAudioStream | null }) - | null - | undefined + logger( + 'debug', + 'Player', + `[Cleanup] Triggering stream cleanup for guild ${this.guildId}. Context: ${context}` + ) + const conn = this.connection + + const mls = this.connection?.mlsSession + if (mls?._pendingKeyPackage) mls._pendingKeyPackage = null + const audioStream = conn?.audioStream as - | (AudioResource & { - destroyed?: boolean - _cleanupListeners?: () => void - }) + | ExtendedAudioStream | undefined | null - if (!audioStream) return + if (this.duckingController) { + this.duckingController.setStreamControl(null) + this.duckingController.detach() + } + + if (this._currentResource) { + try { + this._currentResource.destroy() + } catch (err) { + logger( + 'debug', + 'Player', + `Resource destroy failed during ${context} for guild ${this.guildId}: ${ + (err as Error)?.message ?? String(err) + }` + ) + } + this._currentResource = null + } + + if (!audioStream) { + return + } try { audioStream._cleanupListeners?.() @@ -741,8 +906,21 @@ export class Player { // Ignore cleanup errors } + if (audioStream.destroyed) { + if (conn) conn.audioStream = null + return + } + try { audioStream.destroy?.() + + if (Array.isArray(audioStream.pipes)) { + for (const pipe of audioStream.pipes) { + pipe.destroy?.() + } + } + + conn?.udp?.flush?.() } catch (err) { logger( 'debug', @@ -751,27 +929,23 @@ export class Player { (err as Error)?.message ?? String(err) }` ) + } finally { + if (conn) conn.audioStream = null } - - if (conn) conn.audioStream = null } - /** - * Optionally runs forced GC after finish for leak diagnostics. - */ - private _scheduleTrackFinishGcProbe(): void { - if (!trackFinishForceGcEnabled) return - const gcFn = global.gc - if (typeof gcFn !== 'function') return - - const timer = setTimeout(() => { - try { - gcFn() - gcFn() - } catch {} - this._traceTrackFinishMemory('after-gc') - }, 0) - timer.unref?.() + private _cleanupSSRCStreams(conn: ExtendedVoiceConnection | null): void { + if (!conn?.ssrcs) return + for (const entry of conn.ssrcs.values()) { + const s = entry?.stream as import('node:stream').Readable & { + destroyed?: boolean + destroy?: () => void + } + if (s && !s.destroyed) { + s.resume() + s.destroy?.() + } + } } /** @@ -867,7 +1041,7 @@ export class Player { track: PlayerTrack | null ): Promise { if (!track) return null - if (!this.nodelink.options.enableHoloTracks) { + if (!this.nodelink.options.experimental.enableHoloTracks) { return track } @@ -886,8 +1060,9 @@ export class Player { )?.resolveHoloTrack if (typeof resolveHoloTrack === 'function') { const holoTrack = await resolveHoloTrack.call(source, track, { - fetchChannelInfo: this.nodelink.options.fetchChannelInfo, - resolveExternalLinks: this.nodelink.options.resolveExternalLinks + fetchChannelInfo: this.nodelink.options.search.fetchChannelInfo, + resolveExternalLinks: + this.nodelink.options.search.resolveExternalLinks }) return holoTrack || track } @@ -951,7 +1126,7 @@ export class Player { urlData: TrackUrlResult & { protocol?: string; format?: TrackFormat }, startTime?: number ): Promise<{ stream: AudioResource } | { exception: { message: string } }> { - if (this.nodelink.options?.mix?.enabled !== false) { + if (this.nodelink.options?.playback.mix?.enabled !== false) { await this._ensureAudioMixer() } @@ -961,40 +1136,61 @@ export class Player { return { exception: { message: 'Stream processor not initialized' } } } - const additionalData: Record & { - startTime?: number - position?: number - positionCallback?: (positionMs: number) => void - } = { - ...urlData.additionalData - } - if (startTime !== undefined) { - additionalData.startTime = startTime - // Keep both keys for source compatibility while seek handling is unified. - additionalData.position = startTime - } - additionalData.guildId = this.guildId - additionalData.positionCallback = (positionMs: number) => { - if (!Number.isFinite(positionMs) || positionMs < 0) return - this.position = positionMs + const additionalData = { + ...urlData.additionalData, + ...(startTime !== undefined ? { startTime, position: startTime } : {}), + guildId: this.guildId, + positionCallback: (positionMs: number) => { + if (!Number.isFinite(positionMs) || positionMs < 0) return + this.position = positionMs + }, + // specific to sabr protocol for now + playbackPaused: () => this.isPaused } - urlData.additionalData = additionalData + const resolvedUrlData = { + ...urlData, + additionalData + } - const track = urlData?.newTrack - ? (urlData?.newTrack?.info as TrackInfoExtended) + const track = resolvedUrlData?.newTrack + ? (resolvedUrlData?.newTrack?.info as TrackInfoExtended) : info + + logger( + 'debug', + 'Player', + `Fetching stream resource from source for guild ${this.guildId}`, + { + source: track.sourceName, + url: resolvedUrlData.url + } + ) + const fetched = await this.nodelink.sources.getTrackStream( track, - urlData.url as string, - urlData.protocol as string, + resolvedUrlData.url as string, + resolvedUrlData.protocol as string, additionalData ) - if (fetched.exception) return fetched as { exception: { message: string } } + if (fetched.exception) { + logger( + 'error', + 'Player', + `Stream resource fetch failed for guild ${this.guildId}`, + fetched.exception + ) + return fetched as { exception: { message: string } } + } + logger( + 'debug', + 'Player', + `Successfully fetched stream resource for guild ${this.guildId}` + ) const fetchedStream = fetched.stream as NonNullable const totalBytesRaw = ( - urlData.additionalData as + resolvedUrlData.additionalData as | { contentLength?: number | string } | null | undefined @@ -1026,6 +1222,25 @@ export class Player { ;(profilerTap as unknown as Record)._sourceStream = fetchedStream + const seekControl = fetchedStream as unknown as { + beginSeekHandoff?: () => Promise + cancelSeekHandoff?: () => void + } + const beginSeekHandoff = seekControl.beginSeekHandoff + if (beginSeekHandoff) { + ;( + profilerTap as unknown as { + beginSeekHandoff?: () => Promise + } + ).beginSeekHandoff = () => beginSeekHandoff() + } + const cancelSeekHandoff = seekControl.cancelSeekHandoff + if (cancelSeekHandoff) { + ;( + profilerTap as unknown as { cancelSeekHandoff?: () => void } + ).cancelSeekHandoff = () => cancelSeekHandoff() + } + const eternalboxHandler = (data: unknown) => { this.emitEvent(GatewayEvents.ETERNALBOX_JUMP, { track: this.holoTrack || this.track, @@ -1041,15 +1256,34 @@ export class Player { eventStream.on?.('eternalboxJump', eternalboxHandler) eventStream.on?.('icyMetadata', icyHandler) + let listenersCleaned = false const cleanupListeners = () => { + if (listenersCleaned) return + listenersCleaned = true eventStream.off?.('eternalboxJump', eternalboxHandler) eventStream.off?.('icyMetadata', icyHandler) profilerTap.off('data', profilerHandler) - profilerTap.destroy() + streamForResource.off('close', cleanupListeners) + streamForResource.off('error', cleanupListeners) + streamForResource.off('end', cleanupListeners) + const src = (profilerTap as unknown as { _sourceStream?: Readable }) + ._sourceStream + if (src && !src.destroyed) { + try { + src.destroy() + } catch {} + } + delete (profilerTap as unknown as Record)._sourceStream + if (!profilerTap.destroyed) { + try { + profilerTap.destroy() + } catch {} + } } streamForResource.on('close', cleanupListeners) streamForResource.on('error', cleanupListeners) + streamForResource.on('end', cleanupListeners) ;( streamForResource as unknown as { _cleanupListeners?: () => void @@ -1059,7 +1293,7 @@ export class Player { const resource = audioResourceFactory( this.guildId, streamForResource, - fetched.type || urlData.format, + fetched.type || resolvedUrlData.format, this.nodelink, this.filters, this.volumePercent / 100, @@ -1086,12 +1320,19 @@ export class Player { if (this.sponsorBlock.enabled && this.track) { // Periodic log to verify position and sb state - if (Math.abs(position - this._lastPosition) > 1000 || this._lastPosition === 0) { - logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Current position: ${Math.round(position)}ms, Segments: ${this.sponsorBlock.segments.length}, LastSkipped: ${this.sponsorBlock.lastSkippedUuid}`) + if ( + Math.abs(position - this._lastPosition) > 1000 || + this._lastPosition === 0 + ) { + logger( + 'debug', + 'Player', + `[SponsorBlock][${this.guildId}] Current position: ${Math.round(position)}ms, Segments: ${this.sponsorBlock.segments.length}, LastSkipped: ${this.sponsorBlock.lastSkippedUuid}` + ) } } - const threshold = this.nodelink.options.trackStuckThresholdMs + const threshold = this.nodelink.options.playback.trackStuckThresholdMs ?? 0 if ( threshold > 0 && !this.isUpdatingTrack && @@ -1101,7 +1342,8 @@ export class Player { !this.isPaused ) { if (this._lastPosition === position) { - this._stuckTime += this.nodelink.options.playerUpdateInterval + this._stuckTime += + this.nodelink.options.playback.playerUpdateInterval ?? 0 if ( this._stuckTime >= threshold && !this._isRecovering && @@ -1110,6 +1352,17 @@ export class Player { const stuckTime = this._stuckTime this._stuckTime = 0 + const pipelineStream = this._getAudioStream() + if (pipelineStream?.isPipelineFinished?.()) { + logger( + 'debug', + 'Player', + `Player for guild ${this.guildId} is starving but the network stream has finished. Treating as natural trackEnd.` + ) + this.connection.stop(EndReasons.FINISHED) + return false + } + if (this.streamInfo?.format === 'mp4') { logger( 'error', @@ -1173,15 +1426,11 @@ export class Player { 'Player', `Player for guild ${this.guildId} is near track end (${position}/${trackLength}ms). Treating as natural finish instead of stuck.` ) - this._emitTrackEnd(EndReasons.FINISHED) - this._resetTrack() + this.connection.stop(EndReasons.FINISHED) return false } - if ( - this.stuckRecoveryCount >= - Player.MAX_STUCK_RECOVERY_ATTEMPTS - ) { + if (this.stuckRecoveryCount >= Player.MAX_STUCK_RECOVERY_ATTEMPTS) { logger( 'error', 'Player', @@ -1216,8 +1465,19 @@ export class Player { ) this._isRecovering = true this.stuckRecoveryCount++ + this._positionAtRecoveryStart = position + + if (this.track.info.identifier && this.track.info.sourceName) { + this.nodelink.trackCacheManager?.delete( + this.track.info.sourceName, + this.track.info.identifier + ) + } - this.seek(this._lastPosition, this.track.endTime, true) + const isStream = this.track.info.isStream + const recoveryPosition = isStream ? 0 : this._lastPosition + + this.seek(recoveryPosition, this.track.endTime, true) .then((success) => { if (success) { logger( @@ -1263,10 +1523,15 @@ export class Player { } } - if (position !== this._lastPosition) { - this._lastStreamDataTime = Date.now() - if (this.stuckRecoveryCount > 0) this.stuckRecoveryCount = 0 - } + if (position !== this._lastPosition) { + this._lastStreamDataTime = Date.now() + if (this.stuckRecoveryCount > 0) { + const meaningfulAdvance = 2000 + if (position - this._positionAtRecoveryStart >= meaningfulAdvance) { + this.stuckRecoveryCount = 0 + } + } + } this._lastPosition = position this._syncLyrics() @@ -1299,17 +1564,33 @@ export class Player { this.seek(segment.end) .then((success) => { if (success) { - logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Successfully jumped to ${segment.end}ms`) + logger( + 'debug', + 'Player', + `[SponsorBlock][${this.guildId}] Successfully jumped to ${segment.end}ms` + ) this.emitEvent(GatewayEvents.SPONSORBLOCK_SEGMENT_SKIPPED, { - segment, - skippedMs + track: this.track, + segment }) } else { - logger('warn', 'Player', `[SponsorBlock][${this.guildId}] Failed to jump to ${segment.end}ms for segment ${segment.uuid}`) + logger( + 'warn', + 'Player', + `[SponsorBlock][${this.guildId}] Failed to jump to ${segment.end}ms for segment ${segment.uuid}` + ) + // fallback: temporarily mute or un-stick if it fails + this.sponsorBlock.lastSkippedUuid = null } }) .catch((err) => { - logger('error', 'Player', `[SponsorBlock][${this.guildId}] Error while seeking to segment end:`, err) + logger( + 'error', + 'Player', + `[SponsorBlock][${this.guildId}] Error while seeking to segment end:`, + err + ) + this.sponsorBlock.lastSkippedUuid = null }) return true } @@ -1325,7 +1606,10 @@ export class Player { time: Date.now(), position, connected: this.connStatus === 'connected', - ping: this.connection.ping ?? 0 + ping: + this.connection && this.connection.ping >= 0 + ? this.connection.ping + : 0 } }) ) @@ -1335,38 +1619,14 @@ export class Player { /** * Starts playback for the current track. */ - private async _startPlayback(startTime = 0): Promise { - if (!this.track) return false - - const trackInfo: TrackInfoExtended = { - ...this.track.info, - audioTrackId: this.track.audioTrackId - } - - const urlData = await this.nodelink.sources.getTrackUrl( - trackInfo, - undefined, - this._isRecovering - ) - const urlDataWithFormats = urlData as TrackUrlResult & { - formats?: unknown[] - } + private async _connectAndPlayStream( + urlData: TrackUrlResult, + position: number, + cleanupReason: string, + fadingAction: 'trackStartArm' | 'seekPrepare', + playLogMessage: string + ): Promise { if (!this.track) return false - this.streamInfo = { ...urlData, trackInfo: this.track.info } - logger('debug', 'Player', `Got track URL for guild ${this.guildId}`, { - urlData: { - ...urlData, - formats: urlDataWithFormats.formats - ? `[${urlDataWithFormats.formats.length} format(s) omitted]` - : undefined - } - }) - - if (urlData.exception) { - const err = new Error(urlData.exception.message) - this._onError(err) - return false - } if (!this.connection) { this._initConnection() @@ -1378,28 +1638,33 @@ export class Player { 'Player', `Waiting for voice connection to be ready for guild ${this.guildId}` ) - - await this.waitEvent( - 'stateChange', - (s: VoiceConnectionState) => - s.status === 'connected' && !!this.connection?.udpInfo?.secretKey - ) + try { + await this.waitEvent( + 'stateChange', + (s: VoiceConnectionState) => + s.status === 'connected' && !!this.connection?.udpInfo?.secretKey + ) + } catch (err) { + logger( + 'warn', + 'Player', + `Timeout or error while waiting for voice connection on guild ${this.guildId}:`, + err + ) + } } if (!this.connection?.udpInfo?.secretKey) { - logger( - 'error', - 'Player', - `Voice connection for guild ${this.guildId} is not ready, cannot start playback.` - ) - this._onError(new Error('Voice connection is not ready.')) + const errorMessage = `Voice connection for guild ${this.guildId} is not ready (missing UDP info). Aborting playback.` + logger('error', 'Player', errorMessage) + this._onError(new Error(errorMessage)) return false } const fetched = await this._fetchResource( this.track.info, urlData, - startTime + position ) if ('exception' in fetched) { const err = new Error(fetched.exception.message) @@ -1407,28 +1672,76 @@ export class Player { return false } - this._cleanupCurrentAudioStream('start-playback') + this._cleanupCurrentAudioStream(cleanupReason) const resource = fetched.stream if (this.volumePercent !== 100) { resource.setVolume(this.volumePercent / 100) } - this._fading('trackStartArm', { resource }) - this._fading('trackEndSchedule', { startPosition: startTime || 0 }) + this._fading(fadingAction, { resource }) this.setFilters(this.filters) - logger('debug', 'Player', `Playing resource for guild ${this.guildId}`) - this._stuckTime = 0 + logger('debug', 'Player', playLogMessage) + this._currentResource = resource this.connection.play(resource as unknown) + + // Connect ducking controller to the new audio stream + if (this.duckingController && resource.fadeTo) { + this.duckingController.attach(this.connection) + this.duckingController.setStreamControl({ + fadeTo: (volume: number, durationMs: number, curve?: string) => + resource.fadeTo?.(volume, durationMs, curve) + }) + } + await this.waitEvent( 'playerStateChange', (s: VoicePlayerState) => s.status === 'playing' ) - this._lyricsBasePosition = startTime || 0 + this._lyricsBasePosition = position this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0 + return true + } + + private async _startPlayback(startTime = 0): Promise { + if (!this.track) return false + + const trackInfo: TrackInfoExtended = { + ...this.track.info, + audioTrackId: this.track.audioTrackId + } + + const urlData = await this.nodelink.sources.getTrackUrl( + trackInfo, + undefined, + this._isRecovering + ) + if (!this.track) return false + this.streamInfo = { ...urlData, trackInfo: this.track.info } + logger('debug', 'Player', `Got track URL for guild ${this.guildId}`, { + urlData + }) + + if (urlData.exception) { + const err = new Error(urlData.exception.message) + this._onError(err) + return false + } + + const result = await this._connectAndPlayStream( + urlData, + startTime, + 'start-playback', + 'trackStartArm', + `Playing resource for guild ${this.guildId}` + ) + if (!result) return false + + this._fading('trackEndSchedule', { startPosition: startTime || 0 }) + this._stuckTime = 0 if ( this.track.info.sourceName === 'youtube' || this.track.info.sourceName === 'ytmusic' @@ -1437,10 +1750,14 @@ export class Player { this.sponsorBlock.lastSkippedUuid = null const videoId = this.track.info.identifier - const sbConfig = this.nodelink.options.sponsorblock + const sbConfig = this.nodelink.options.playback.sponsorblock if (this.sponsorBlock.enabled) { - logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Initiating segment fetch for video ${videoId}`) + logger( + 'debug', + 'Player', + `[SponsorBlock][${this.guildId}] Initiating segment fetch for video ${videoId}` + ) const { fetchSponsorBlockSegments } = await import('../utils.ts') fetchSponsorBlockSegments( videoId, @@ -1449,12 +1766,24 @@ export class Player { sbConfig?.api ) .then((segments) => { - if (this.destroying || !this.track || this.track.info.identifier !== videoId) { - logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Ignoring fetched segments for ${videoId} (track changed or player destroyed)`) + if ( + this.destroying || + !this.track || + this.track.info.identifier !== videoId + ) { + logger( + 'debug', + 'Player', + `[SponsorBlock][${this.guildId}] Ignoring fetched segments for ${videoId} (track changed or player destroyed)` + ) return } this.sponsorBlock.segments = segments - logger('info', 'Player', `[SponsorBlock][${this.guildId}] Applied ${segments.length} segments for video ${videoId}`) + logger( + 'info', + 'Player', + `[SponsorBlock][${this.guildId}] Applied ${segments.length} segments for video ${videoId}` + ) if (segments.length > 0) { this.emitEvent(GatewayEvents.SPONSORBLOCK_SEGMENTS_LOADED, { segments @@ -1465,10 +1794,19 @@ export class Player { } }) .catch((err) => { - logger('error', 'Player', `[SponsorBlock][${this.guildId}] Error fetching segments for ${videoId}:`, err) + logger( + 'error', + 'Player', + `[SponsorBlock][${this.guildId}] Error fetching segments for ${videoId}:`, + err + ) }) } else { - logger('debug', 'Player', `[SponsorBlock][${this.guildId}] Auto-skip disabled, skipping segment fetch for ${videoId}`) + logger( + 'debug', + 'Player', + `[SponsorBlock][${this.guildId}] Auto-skip disabled, skipping segment fetch for ${videoId}` + ) } } @@ -1493,6 +1831,11 @@ export class Player { startTime, endTime = 0 }: PlayPayload): Promise { + logger( + 'debug', + 'Player', + `[Action: play] Method invoked for guild ${this.guildId} with track ${info.identifier}` + ) return new Promise((resolve) => { this.isUpdatingTrack = true @@ -1589,9 +1932,34 @@ export class Player { endTime?: number, forceLegacy = false ): Promise { - if (this.destroying || !this.track) return false + logger( + 'debug', + 'Player', + `[Action: seek] Method invoked for guild ${this.guildId} with target position: ${position}ms` + ) + if (this.destroying || !this.track) { + logger( + 'debug', + 'Player', + `[Action: seek] Aborted for guild ${this.guildId}: destroying=${this.destroying}, hasTrack=${!!this.track}` + ) + return false + } if (!this.track.info.isSeekable && !this.track.info.isStream) return false + const streamFormat = + typeof this.streamInfo?.format === 'string' + ? this.streamInfo.format.toLowerCase() + : '' + if (streamFormat.includes('flac')) { + logger( + 'warn', + 'Player', + `Seeking not supported for FLAC stream on guild ${this.guildId}` + ) + return false + } + const seekPosition = position ?? this._realPosition() if ( @@ -1624,8 +1992,6 @@ export class Player { 'Player', 'No stream info URL available for seek. awaiting getTrackUrl.' ) - const sleep = (ms: number) => - new Promise((resolve) => setTimeout(resolve, ms)) await sleep(1600) if (!this.streamInfo?.url) { logger( @@ -1656,7 +2022,7 @@ export class Player { } } - const source = this.nodelink.sources.getSource(sourceName) + const source = this.nodelink.sources.getSource(resolvedSourceName) const hasSourceLoader = source && typeof source.loadStream === 'function' const canNativeSeek = !!hasSourceLoader && @@ -1707,6 +2073,10 @@ export class Player { this._fading('trackEndSchedule', { startPosition: this.position }) } return result + } catch (e) { + logger('error', 'Player', `Seek failed for guild ${this.guildId}`, e) + this._onError(e as Error) + return false } finally { this._isSeeking = false } @@ -1729,43 +2099,52 @@ export class Player { this.position = position this.track.endTime = endTime - let previousSession: unknown = null let reuseUrlData: TrackUrlResult | null = null + let seekHandoff: { cancelSeekHandoff: () => void } | null = null if (this.streamInfo?.protocol === 'sabr' && this.connection?.audioStream) { - const inputStream = (this.connection.audioStream as { pipes?: unknown[] }) - ?.pipes?.[0] as { getSessionState?: () => unknown } | undefined - if (inputStream && typeof inputStream.getSessionState === 'function') { - previousSession = inputStream.getSessionState() - if (previousSession) { - logger( - 'debug', - 'Player', - `Extracted SABR session state: rn=${ - (previousSession as { requestNumber?: number }).requestNumber - }, hasCookie=${!!( - previousSession as { - nextRequestPolicy?: { playbackCookie?: unknown } - } - ).nextRequestPolicy?.playbackCookie}` - ) + const inputStream = ( + this.connection.audioStream as { + pipes?: Array<{ + beginSeekHandoff?: () => Promise + cancelSeekHandoff?: () => void + }> + } + )?.pipes?.[0] - reuseUrlData = { - protocol: this.streamInfo.protocol, - url: this.streamInfo.url, - additionalData: { - ...this.streamInfo.additionalData, - previousSession, - startTime: position + const previousSession = await inputStream?.beginSeekHandoff?.() + if (previousSession) { + seekHandoff = inputStream?.cancelSeekHandoff + ? { cancelSeekHandoff: inputStream.cancelSeekHandoff } + : null + logger( + 'debug', + 'Player', + `Extracted SABR session state: rn=${ + (previousSession as { requestNumber?: number }).requestNumber + }, hasCookie=${!!( + previousSession as { + nextRequestPolicy?: { playbackCookie?: unknown } } - } as TrackUrlResult + ).nextRequestPolicy?.playbackCookie}` + ) - logger( - 'debug', - 'Player', - `Reusing existing SABR streaming URL for seek to maintain session` - ) - } + reuseUrlData = { + newTrack: this.streamInfo.newTrack, + protocol: this.streamInfo.protocol, + url: this.streamInfo.url, + additionalData: { + ...this.streamInfo.additionalData, + previousSession, + startTime: position + } + } as TrackUrlResult + + logger( + 'debug', + 'Player', + `Reusing existing SABR streaming URL for seek to maintain session` + ) } } @@ -1779,66 +2158,26 @@ export class Player { this.streamInfo = { ...urlData, trackInfo: this.track.info } if (urlData.exception) { + seekHandoff?.cancelSeekHandoff() const err = new Error(urlData.exception.message) this._onError(err) return false } - if (!this.connection) { - this._initConnection() - } - - if (!this.connection?.udpInfo?.secretKey) { - await this.waitEvent( - 'stateChange', - (s: VoiceConnectionState) => - s.status === 'connected' && !!this.connection?.udpInfo?.secretKey + try { + const result = await this._connectAndPlayStream( + urlData, + position, + 'source-seek', + 'seekPrepare', + `Playing resource for guild ${this.guildId} after source seek` ) + if (!result) seekHandoff?.cancelSeekHandoff() + return result + } catch (error) { + seekHandoff?.cancelSeekHandoff() + throw error } - - if (!this.connection?.udpInfo?.secretKey) { - const errorMessage = `Voice connection for guild ${this.guildId} is not ready (missing UDP info). Aborting playback.` - logger('error', 'Player', errorMessage) - this._onError(new Error(errorMessage)) - return false - } - - const fetched = await this._fetchResource( - this.track.info, - urlData, - position - ) - if ('exception' in fetched) { - const err = new Error(fetched.exception.message) - this._onError(err) - return false - } - - this._cleanupCurrentAudioStream('source-seek') - - const resource = fetched.stream - if (this.volumePercent !== 100) { - resource.setVolume(this.volumePercent / 100) - } - this._fading('seekPrepare', { resource }) - - this.setFilters(this.filters) - - logger( - 'debug', - 'Player', - `Playing resource for guild ${this.guildId} after source seek` - ) - this.connection.play(resource as unknown) - await this.waitEvent( - 'playerStateChange', - (s: VoicePlayerState) => s.status === 'playing' - ) - - this._lyricsBasePosition = position - this._lyricsBasePackets = this.connection?.statistics?.packetsExpected ?? 0 - - return true } /** @@ -1848,7 +2187,7 @@ export class Player { position: number, endTime?: number ): Promise { - if (this.nodelink.options?.mix?.enabled !== false) { + if (this.nodelink.options?.playback.mix?.enabled !== false) { await this._ensureAudioMixer() } @@ -1922,6 +2261,12 @@ export class Player { if (oldStream) { oldStream.destroy() } + if (this._currentResource && this._currentResource !== resource) { + try { + this._currentResource.destroy() + } catch {} + } + this._currentResource = resource this._lyricsBasePosition = position this._lyricsBasePackets = @@ -2040,7 +2385,17 @@ export class Player { 'Player', `Playing resource for guild ${this.guildId} after legacy seek` ) + this._currentResource = resource this.connection.play(resource as unknown) + + // Connect ducking controller to the new audio stream + if (this.duckingController && resource.fadeTo) { + this.duckingController.attach(this.connection) + this.duckingController.setStreamControl({ + fadeTo: (volume: number, durationMs: number, curve?: string) => + resource.fadeTo?.(volume, durationMs, curve) + }) + } await this.waitEvent( 'playerStateChange', (s: VoicePlayerState) => s.status === 'playing' @@ -2058,9 +2413,21 @@ export class Player { * @returns True when stop was executed; false when no active track. */ public stop(): boolean { + logger( + 'debug', + 'Player', + `[Action: stop] Executing stop for guild ${this.guildId}` + ) this.isUpdatingTrack = true try { - if (this.destroying || !this.track) return false + if (this.destroying || !this.track) { + logger( + 'debug', + 'Player', + `[Action: stop] Aborted for guild ${this.guildId}: destroying=${this.destroying}, hasTrack=${!!this.track}` + ) + return false + } if (this.nextResource) { this.nextResource.destroy() @@ -2096,7 +2463,19 @@ export class Player { * @returns True when preload succeeded. */ public async preload(payload: PlayerTrack): Promise { - if (this.destroying) return false + logger( + 'debug', + 'Player', + `[Action: preload] Method invoked for guild ${this.guildId} with track ${payload.info.identifier}` + ) + if (this.destroying) { + logger( + 'debug', + 'Player', + `[Action: preload] Aborted for guild ${this.guildId}: player is destroying` + ) + return false + } const sameEncoded = !!payload.encoded && @@ -2169,6 +2548,11 @@ export class Player { * @returns True when state was cleared. */ public clearNextTrack(): boolean { + logger( + 'debug', + 'Player', + `[Action: clearNextTrack] Method invoked for guild ${this.guildId}` + ) if (this.destroying) return false if (this.nextResource) { @@ -2189,7 +2573,19 @@ export class Player { * @returns True when state changed; false otherwise. */ public pause(shouldPause: boolean): boolean { - if (this.destroying || this.isPaused === shouldPause) return false + logger( + 'debug', + 'Player', + `[Action: pause] Method invoked for guild ${this.guildId} with target: ${shouldPause}` + ) + if (this.destroying || this.isPaused === shouldPause) { + logger( + 'debug', + 'Player', + `[Action: pause] Aborted for guild ${this.guildId}: destroying=${this.destroying}, alreadyPaused=${this.isPaused === shouldPause}` + ) + return false + } logger( 'debug', 'Player', @@ -2230,7 +2626,19 @@ export class Player { * @returns True when volume was updated. */ public volume(level: number): boolean { - if (this.destroying) return false + logger( + 'debug', + 'Player', + `[Action: volume] Method invoked for guild ${this.guildId} with target: ${level}` + ) + if (this.destroying) { + logger( + 'debug', + 'Player', + `[Action: volume] Aborted for guild ${this.guildId}: player is destroying` + ) + return false + } logger( 'debug', 'Player', @@ -2250,6 +2658,11 @@ export class Player { * @returns Always true. */ public setFading(config?: FadingConfig): boolean { + logger( + 'debug', + 'Player', + `[Action: setFading] Method invoked for guild ${this.guildId}` + ) this.fading = config return true } @@ -2261,6 +2674,11 @@ export class Player { * @returns True when updated. */ public setLoudnessNormalizer(enabled: boolean): boolean { + logger( + 'debug', + 'Player', + `[Action: setLoudnessNormalizer] Method invoked for guild ${this.guildId} to ${enabled}` + ) this.loudnessNormalizer = !!enabled if (this.connection?.audioStream) { this.connection.audioStream.setLoudnessNormalizer?.( @@ -2270,6 +2688,73 @@ export class Player { return true } + /** + * Resolves the ducking configuration from the fading config or global config. + * + * @returns Resolved ducking configuration. + */ + private _resolveDuckingConfig(): DuckingConfig { + const fadingDucking = this.fading?.ducking + const configDucking = + this.nodelink.options?.playback?.audio?.fading?.ducking + + const source = fadingDucking ?? configDucking + + return { + enabled: source?.enabled ?? false, + duration: source?.duration ?? 500, + targetVolume: source?.targetVolume ?? 0.15, + curve: source?.curve ?? 'linear' + } + } + + /** + * Toggles auto-ducking (lowers music volume when users speak). + * + * @param enabled - Whether to enable auto-ducking. + * @returns True when updated. + */ + public setDucking(enabled: boolean): boolean { + logger( + 'debug', + 'Player', + `[Action: setDucking] Method invoked for guild ${this.guildId} to ${enabled}` + ) + + if (enabled) { + const duckingCfg = this._resolveDuckingConfig() + duckingCfg.enabled = true + + if (!this.duckingController) { + this.duckingController = new DuckingController(this.guildId, duckingCfg) + } else { + this.duckingController.updateConfig(duckingCfg) + } + + // Attach to current connection if available + if (this.connection) { + this.duckingController.attach(this.connection) + } + + // Connect to current audio stream if available + if (this.connection?.audioStream?.fadeTo) { + const stream = this.connection.audioStream + this.duckingController.setStreamControl({ + fadeTo: (volume: number, durationMs: number, curve?: string) => + stream.fadeTo?.(volume, durationMs, curve) + }) + } + } else { + if (this.duckingController) { + this.duckingController.detach() + this.duckingController.destroy() + this.duckingController = null + } + } + + return true + } + /** * Applies audio filters to the active stream. * @@ -2277,7 +2762,19 @@ export class Player { * @returns True when filters applied; false if player inactive. */ public setFilters(filters: FiltersState): boolean { - if (this.destroying || !this.track) return false + logger( + 'debug', + 'Player', + `[Action: setFilters] Method invoked for guild ${this.guildId}` + ) + if (this.destroying || !this.track) { + logger( + 'debug', + 'Player', + `[Action: setFilters] Aborted for guild ${this.guildId}: destroying=${this.destroying}, hasTrack=${!!this.track}` + ) + return false + } logger( 'debug', 'Player', @@ -2440,6 +2937,11 @@ export class Player { voicePayload: Partial = {}, force = false ): void { + logger( + 'debug', + 'Player', + `[Action: updateVoice] Method invoked for guild ${this.guildId} with force=${force}` + ) if (this.destroying) return const { sessionId, token, endpoint, channelId } = voicePayload @@ -2478,13 +2980,17 @@ export class Player { `Updating voice state for guild ${this.guildId}` ) if (!this.connection) this._initConnection() - if (this.voice.channelId && this.connection) { - this.connection.channelId = this.voice.channelId + this.connection?.voiceStateUpdate({ + session_id: this.voice.sessionId, + channel_id: this.voice.channelId ?? undefined + }) + if (force && this.connection?.voiceServer) { + this.connection.voiceServer = null } - this.connection?.voiceStateUpdate({ session_id: this.voice.sessionId }) this.connection?.voiceServerUpdate({ token: this.voice.token, - endpoint: this.voice.endpoint + endpoint: this.voice.endpoint, + channel_id: this.voice.channelId ?? undefined }) this.connection?.connect(async () => { if (this.destroying) return @@ -2502,7 +3008,14 @@ export class Player { 'Player', `Voice state updated for guild ${this.guildId}, starting pending track.` ) - await this._startPlayback() + await this._startPlayback().catch((err) => { + logger( + 'error', + 'Player', + `Failed to start pending track during voice update for guild ${this.guildId}:`, + err + ) + }) } }) } else { @@ -2520,17 +3033,41 @@ export class Player { * @param emitClose - Whether to emit WEBSOCKET_CLOSED to the client. */ public destroy(emitClose = true): void { + logger( + 'debug', + 'Player', + `[Action: destroy] Method invoked for guild ${this.guildId} with emitClose=${emitClose}` + ) if (this.destroying) return this.destroying = true - - logger('debug', 'Player', `Destroying player for guild ${this.guildId}`) if (this.connection) { try { + this.connection.removeListener('stateChange', this._connStateHandler) + this.connection.removeListener( + 'playerStateChange', + this._connPlayHandler + ) + this.connection.removeListener('error', this._connErrorHandler) + this.connection.removeListener('stuck', this._connStuckHandler) + this.connection.removeListener( + 'speakStart', + this._connSpeakStartHandler + ) + if (this.nodelink.voiceRelay?.detach) { + this.nodelink.voiceRelay.detach(this.connection) + } if (this.connection.audioStream) { this.connection.stop(EndReasons.CLEANUP) this._cleanupCurrentAudioStream('destroy') } + this._cleanupSSRCStreams(this.connection) this.connection.destroy() + + if (this.duckingController) { + this.duckingController.destroy() + this.duckingController = null + } + this.connection = null } catch (err) { const error = err as Error @@ -2551,6 +3088,16 @@ export class Player { this.emitEvent(GatewayEvents.PLAYER_DESTROYED, { guildId: this.guildId }) + + this._destroyAudioMixer() + + if (this._currentResource) { + try { + this._currentResource.destroy() + } catch {} + this._currentResource = null + } + this._resetTrack() this.connStatus = 'destroyed' this.volumePercent = this.nodelink.options?.defaultVolume ?? 100 @@ -2571,6 +3118,11 @@ export class Player { track: PlayerTrack volume: number }> { + logger( + 'debug', + 'Player', + `[Action: addMix] Method invoked for guild ${this.guildId}` + ) if (!this.track || this.isPaused) { throw new Error('Cannot add mix without an active stream') } @@ -2578,7 +3130,7 @@ export class Player { await this._ensureAudioMixer() if (!this.audioMixer) throw new Error('AudioMixer not initialized') - const mixConfig = this.nodelink?.options?.mix ?? { + const mixConfig = this.nodelink?.options?.playback.mix ?? { enabled: true, defaultVolume: 0.8, maxLayersMix: 5 @@ -2643,6 +3195,11 @@ export class Player { * @returns True when removed. */ public removeMix(mixId: string): boolean { + logger( + 'debug', + 'Player', + `[Action: removeMix] Method invoked for guild ${this.guildId} mixId=${mixId}` + ) if (!this.audioMixer) { return false } @@ -2657,6 +3214,11 @@ export class Player { * @returns True when updated; false if layer missing. */ public updateMix(mixId: string, volume: number): boolean { + logger( + 'debug', + 'Player', + `[Action: updateMix] Method invoked for guild ${this.guildId} mixId=${mixId} volume=${volume}` + ) if (!this.audioMixer) { return false } @@ -2675,6 +3237,11 @@ export class Player { position: number startTime: number }> { + logger( + 'debug', + 'Player', + `[Action: getMixes] Method invoked for guild ${this.guildId}` + ) if (!this.audioMixer) { return [] } @@ -2689,6 +3256,11 @@ export class Player { public async subscribeLyrics( skipTrackSource: boolean | string | undefined ): Promise { + logger( + 'debug', + 'Player', + `[Action: subscribeLyrics] Method invoked for guild ${this.guildId}` + ) return new Promise((resolve) => { if (this.isLyricsSubscribed) { return resolve() @@ -2718,6 +3290,11 @@ export class Player { * Unsubscribes from lyrics events. */ public unsubscribeLyrics(): Promise { + logger( + 'debug', + 'Player', + `[Action: unsubscribeLyrics] Method invoked for guild ${this.guildId}` + ) return new Promise((resolve) => { this.isLyricsSubscribed = false this.skipTrackSource = false @@ -2737,6 +3314,11 @@ export class Player { * @returns Current segments and configuration. */ public getSponsorBlock(): PlayerSponsorBlockState { + logger( + 'debug', + 'Player', + `[Action: getSponsorBlock] Method invoked for guild ${this.guildId}` + ) return this.sponsorBlock } @@ -2750,7 +3332,13 @@ export class Player { Omit > ): void { - if (updates.enabled !== undefined) this.sponsorBlock.enabled = updates.enabled + logger( + 'debug', + 'Player', + `[Action: updateSponsorBlock] Method invoked for guild ${this.guildId}` + ) + if (updates.enabled !== undefined) + this.sponsorBlock.enabled = updates.enabled if (updates.categories !== undefined) this.sponsorBlock.categories = updates.categories if (updates.actionTypes !== undefined) @@ -2763,6 +3351,11 @@ export class Player { * @param segments - Array of segments to apply. */ public setSponsorBlockSegments(segments: SponsorBlockSegment[]): void { + logger( + 'debug', + 'Player', + `[Action: setSponsorBlockSegments] Method invoked for guild ${this.guildId}` + ) this.sponsorBlock.segments = segments this.sponsorBlock.lastSkippedUuid = null } @@ -2771,6 +3364,11 @@ export class Player { * Clears SponsorBlock state for the player. */ public clearSponsorBlock(): void { + logger( + 'debug', + 'Player', + `[Action: clearSponsorBlock] Method invoked for guild ${this.guildId}` + ) this.sponsorBlock.segments = [] this.sponsorBlock.lastSkippedUuid = null } @@ -2944,6 +3542,11 @@ export class Player { * Serializes player state to JSON-safe object. */ public toJSON(): PlayerStateJSON { + logger( + 'debug', + 'Player', + `[Action: toJSON] Method invoked for guild ${this.guildId}` + ) return { guildId: this.guildId, track: this.track, @@ -2956,9 +3559,12 @@ export class Player { time: Date.now(), position: this._realPosition(), connected: this.connStatus === 'connected', - ping: this.connection?.ping ?? 0 + ping: + this.connection && this.connection.ping >= 0 + ? this.connection.ping + : 0 }, - voice: { ...this.voice } + voice: structuredClone(this.voice) } } @@ -2978,6 +3584,11 @@ export class Player { | 'resume', payload: { resource?: AudioResource; startPosition?: number } = {} ): boolean { + logger( + 'debug', + 'Player', + `[Fading] Executing fading action '${action}' for guild ${this.guildId}` + ) const timers = this._fadeTimers if (!timers) return false @@ -3112,7 +3723,7 @@ export class Player { return true } - if (!this.fading || this.fading.enabled !== true) return false + if (this.fading?.enabled !== true) return false let section: FadingSection | undefined | null = null if (action === 'trackStart' || action === 'trackStartArm') @@ -3161,8 +3772,13 @@ export class Player { this._pendingTrackStartFade = false if (fadeType === 'volume' || fadeType === 'both') { + const targetVol = this.duckingController?.getTargetVolume(1) ?? 1 if ((stream as AudioResource).fadeTo) - (stream as AudioResource).fadeTo?.(1, section.duration, section.curve) + (stream as AudioResource).fadeTo?.( + targetVol, + section.duration, + section.curve + ) } if (fadeType === 'tape' || fadeType === 'both') { if ((stream as AudioResource).tapeTo) @@ -3199,8 +3815,9 @@ export class Player { if (!stream) return false if (fadeType === 'volume' || fadeType === 'both') { + const targetVol = this.duckingController?.getTargetVolume(1) ?? 1 if (stream.setFadeVolume) stream.setFadeVolume(0) - stream.fadeTo?.(1, section.duration, section.curve) + stream.fadeTo?.(targetVol, section.duration, section.curve) } if (fadeType === 'tape' || fadeType === 'both') { stream.tapeTo?.(section.duration, 'start', section.curve) diff --git a/src/playback/processing/AudioMixer.ts b/src/playback/processing/AudioMixer.ts index ef6b0eb6..1234c0a8 100644 --- a/src/playback/processing/AudioMixer.ts +++ b/src/playback/processing/AudioMixer.ts @@ -14,6 +14,13 @@ interface ExtendedVoiceStream extends VoiceAudioStream { destroyed: boolean } +interface AudioMixerLayerListeners { + data: (chunk: Buffer) => void + end: () => void + close: () => void + error: (error: Error) => void +} + const LAYER_BUFFER_SIZE = 1024 * 1024 const EMPTY_BUFFER = Buffer.alloc(0) const FRAME_SIZE = 3840 @@ -29,6 +36,7 @@ export class AudioMixer extends Readable { private defaultVolume: number public autoCleanup: boolean public enabled: boolean + private readonly layerListeners: Map /** * Creates a new AudioMixer. @@ -42,6 +50,7 @@ export class AudioMixer extends Readable { this.defaultVolume = config.defaultVolume || 0.8 this.autoCleanup = config.autoCleanup !== false this.enabled = config.enabled !== false + this.layerListeners = new Map() } override _read(_size: number): void { @@ -166,7 +175,7 @@ export class AudioMixer extends Readable { this.mixLayers.set(id, layer) - stream.on('data', (chunk: Buffer) => { + const onData = (chunk: Buffer): void => { if (!layer.active) return if (layer.ringBuffer.length > LAYER_BUFFER_SIZE * 0.8) { @@ -193,21 +202,33 @@ export class AudioMixer extends Readable { layer.receivedBytes += data.length layer.ringBuffer.write(data) } - }) + } - stream.once('end', () => { + const onEnd = (): void => { layer.finishedFeeding = true - }) + } - stream.once('close', () => { + const onClose = (): void => { layer.finishedFeeding = true - }) + } - stream.once('error', (error: Error) => { + const onError = (error: Error): void => { this.emit('mixError', { id, error }) this.removeLayer(id, 'ERROR') + } + + this.layerListeners.set(id, { + data: onData, + end: onEnd, + close: onClose, + error: onError }) + stream.on('data', onData) + stream.once('end', onEnd) + stream.once('close', onClose) + stream.once('error', onError) + this.emit('mixStarted', { id, track, volume: layer.volume }) return id @@ -268,8 +289,16 @@ export class AudioMixer extends Readable { if (!layer) return false layer.active = false + const listeners = this.layerListeners.get(id) + if (listeners) { + layer.stream.off('data', listeners.data) + layer.stream.off('end', listeners.end) + layer.stream.off('close', listeners.close) + layer.stream.off('error', listeners.error) + this.layerListeners.delete(id) + } + if (layer.stream && !(layer.stream as ExtendedVoiceStream).destroyed) { - layer.stream.removeAllListeners('data') layer.stream.destroy() } layer.ringBuffer.dispose() @@ -332,4 +361,15 @@ export class AudioMixer extends Readable { for (const id of ids) this.removeLayer(id, reason) return ids.length } + + /** + * Destroys the mixer: clears all layers, removes all listeners, + * and ends the Readable stream. + */ + public override destroy(): this { + this.clearLayers('DESTROYED') + this.removeAllListeners() + super.destroy() + return this + } } diff --git a/src/playback/processing/DuckingController.ts b/src/playback/processing/DuckingController.ts new file mode 100644 index 00000000..c6d97af4 --- /dev/null +++ b/src/playback/processing/DuckingController.ts @@ -0,0 +1,297 @@ +import type { Buffer } from 'node:buffer' +import type { Readable } from 'node:stream' +import type { VoiceConnection } from '@performanc/voice' +import { Decoder as OpusDecoder } from '../../playback/opus/Opus.ts' +import type { + DuckingConfig, + DuckingStreamControl +} from '../../typings/playback/ducking.types.ts' +import { logger } from '../../utils.ts' + +/** + * Controls auto-ducking behavior: lowers music volume when users speak + * and restores it when they stop. + */ +export class DuckingController { + private config: DuckingConfig + private streamControl: DuckingStreamControl | null = null + private activeSpeakers = new Map() + private isDucked = false + private destroyed = false + private hookedStreams = new Set() + private activeStreams = new Map< + number, + { + stream: Readable + decoder: OpusDecoder | null + onData: (chunk: Buffer) => void + onEnd: () => void + } + >() + + private static readonly HOLD_MS = 600 + private static readonly RMS_THRESHOLD = 3500 + + private readonly _onSpeakStart = (_userId: string, ssrc: number): void => { + if (this.destroyed || !this.config.enabled || !this.streamControl) return + if (this.hookedStreams.has(ssrc)) return + + const stream = this.connection?.getSpeakStream?.(ssrc) as + | Readable + | undefined + if (!stream) return + + this.hookedStreams.add(ssrc) + + let decoder: OpusDecoder | null = null + try { + decoder = new OpusDecoder({ rate: 48000, channels: 2 }) + } catch (err) { + logger( + 'warn', + 'Ducking', + `Failed to create Opus decoder for RMS ducking: ${(err as Error).message}` + ) + const onData = (chunk: Buffer) => { + if (this.destroyed || !this.config.enabled) return + if (chunk.length < 40) return + + this._registerSpeech(ssrc) + } + const onEnd = () => this._cleanupStream(ssrc) + this.activeStreams.set(ssrc, { + stream, + decoder: null, + onData, + onEnd + }) + stream.on('data', onData) + stream.once('end', onEnd) + stream.once('close', onEnd) + return + } + + let lastLogTime = 0 + + const onData = (pcm: Buffer) => { + if (this.destroyed || !this.config.enabled) return + + let sumSquare = 0 + for (let i = 0; i < pcm.length; i += 2) { + const sample = pcm.readInt16LE(i) + sumSquare += sample * sample + } + const rms = Math.sqrt(sumSquare / (pcm.length / 2)) + + const now = Date.now() + if (now - lastLogTime > 1000) { + logger( + 'debug', + 'Ducking', + `[RMS Debug] SSRC ${ssrc} - Current RMS: ${Math.round(rms)} (Threshold: ${DuckingController.RMS_THRESHOLD})` + ) + lastLogTime = now + } + + if (rms >= DuckingController.RMS_THRESHOLD) { + this._registerSpeech(ssrc, rms) + } + } + const onEnd = () => this._cleanupStream(ssrc) + this.activeStreams.set(ssrc, { stream, decoder, onData, onEnd }) + stream.pipe(decoder) + decoder.on('data', onData) + stream.once('end', onEnd) + stream.once('close', onEnd) + } + + private connection: VoiceConnection | null = null + private readonly guildId: string + + constructor(guildId: string, config: DuckingConfig) { + this.guildId = guildId + this.config = { ...config } + } + + public updateConfig(config: DuckingConfig): void { + this.config = { ...config } + if (!config.enabled && this.isDucked) this._restore(0) + } + + public getTargetVolume(defaultVolume = 1.0): number { + return this.isDucked ? this.currentTargetVolume : defaultVolume + } + + public setStreamControl(control: DuckingStreamControl | null): void { + this.streamControl = control + if (!control) { + for (const ssrc of this.activeStreams.keys()) this._cleanupStream(ssrc) + this._restore(0) + return + } + if (this.isDucked && this.streamControl) { + try { + this.streamControl.fadeTo( + this.config.targetVolume, + this.config.duration, + this.config.curve + ) + } catch (err) { + logger( + 'error', + 'Ducking', + `Failed to reapply ducked volume for guild ${this.guildId}: ${(err as Error).message}` + ) + } + } + } + + public attach(connection: VoiceConnection): void { + if (this.connection) return + this.connection = connection + this.connection.on('speakStart', this._onSpeakStart) + logger( + 'debug', + 'Ducking', + `Attached ducking listeners for guild ${this.guildId}` + ) + } + + public detach(): void { + if (this.connection) { + this.connection.removeListener('speakStart', this._onSpeakStart) + this.connection = null + logger( + 'debug', + 'Ducking', + `Detached ducking listeners for guild ${this.guildId}` + ) + } + for (const ssrc of this.activeStreams.keys()) this._cleanupStream(ssrc) + this.hookedStreams.clear() + this._restore(0) + } + + public destroy(): void { + this.destroyed = true + this.detach() + this.activeSpeakers.forEach(clearTimeout) + this.activeSpeakers.clear() + this.streamControl = null + } + + private currentTargetVolume = 1.0 + private lastFadeTime = 0 + + private _cleanupStream(ssrc: number): void { + const entry = this.activeStreams.get(ssrc) + if (!entry) return + this.activeStreams.delete(ssrc) + this.hookedStreams.delete(ssrc) + entry.stream.off('end', entry.onEnd) + entry.stream.off('close', entry.onEnd) + if (entry.decoder) { + entry.decoder.off('data', entry.onData) + entry.stream.unpipe(entry.decoder) + entry.decoder.destroy() + } else { + entry.stream.off('data', entry.onData) + } + + const existing = this.activeSpeakers.get(ssrc) + if (existing) { + clearTimeout(existing) + this.activeSpeakers.delete(ssrc) + if (this.activeSpeakers.size === 0) this._restore() + } + } + + private _registerSpeech(ssrc: number, rms = 0): void { + const existing = this.activeSpeakers.get(ssrc) + if (existing) clearTimeout(existing) + + this.activeSpeakers.set( + ssrc, + setTimeout(() => { + this.activeSpeakers.delete(ssrc) + logger( + 'debug', + 'Ducking', + `Speaker ${ssrc} timeout expired. Active speakers: ${this.activeSpeakers.size}` + ) + if (this.activeSpeakers.size === 0) this._restore() + }, DuckingController.HOLD_MS) + ) + + const intensity = Math.min( + 1.0, + Math.max( + 0, + (rms - DuckingController.RMS_THRESHOLD) / + (15000 - DuckingController.RMS_THRESHOLD) + ) + ) + const minVol = 0.03 + let dynamicVol = + this.config.targetVolume - intensity * (this.config.targetVolume - minVol) + dynamicVol = Number(Math.max(minVol, dynamicVol).toFixed(2)) + + const now = Date.now() + const wasDucked = this.isDucked + + const isAttacking = dynamicVol < this.currentTargetVolume + + const threshold = isAttacking ? 0.02 : 0.06 + const isSignificantChange = + Math.abs(this.currentTargetVolume - dynamicVol) >= threshold + + if (!wasDucked || (isSignificantChange && now - this.lastFadeTime > 100)) { + this.isDucked = true + + let fadeDur = 50 + if (!isAttacking && wasDucked) { + fadeDur = 400 + } + + this.currentTargetVolume = dynamicVol + this.lastFadeTime = now + + try { + this.streamControl?.fadeTo(dynamicVol, fadeDur, this.config.curve) + logger( + 'debug', + 'Ducking', + `Proportional Ducking -> Vol: ${dynamicVol} | Dur: ${fadeDur}ms | RMS: ${Math.round(rms)} | Guild: ${this.guildId}` + ) + } catch (err) { + logger( + 'error', + 'Ducking', + `Failed to dynamically duck volume for guild ${this.guildId}: ${(err as Error).message}` + ) + } + } + } + private _restore(overrideDuration?: number): void { + if (!this.isDucked) return + this.isDucked = false + this.currentTargetVolume = 1.0 + + const duration = overrideDuration ?? Math.max(this.config.duration, 600) + + try { + this.streamControl?.fadeTo(1.0, duration, this.config.curve) + logger( + 'debug', + 'Ducking', + `Volume restored to 1.0 over ${duration}ms for guild ${this.guildId}` + ) + } catch (err) { + logger( + 'error', + 'Ducking', + `Failed to restore volume for guild ${this.guildId}: ${(err as Error).message}` + ) + } + } +} diff --git a/src/playback/processing/FlowController.ts b/src/playback/processing/FlowController.ts index 28b77bde..9a5a793c 100644 --- a/src/playback/processing/FlowController.ts +++ b/src/playback/processing/FlowController.ts @@ -21,7 +21,7 @@ export class FlowController extends Transform { private readonly tape: ITapeTransformer private readonly scratch: IScratchTransformer private readonly audioMixer: AudioMixer | null - private pendingBuffer: Buffer + private pendingBuffer: Buffer | null private pendingLength: number /** @@ -136,6 +136,15 @@ export class FlowController extends Transform { return this.scratch.checkEffectCompleted() } + public setLoudnessNormalizer(enabled: boolean): void { + if ( + 'setAGCEnabled' in this.volume && + typeof this.volume.setAGCEnabled === 'function' + ) { + this.volume.setAGCEnabled(enabled) + } + } + /** * Updates filters in the pipeline via the FlowController. * Note: FlowController currently doesn't manage filters itself, @@ -153,6 +162,11 @@ export class FlowController extends Transform { _encoding: BufferEncoding, callback: TransformCallback ): void { + if (!this.pendingBuffer) { + callback() + return + } + let offset = 0 if (this.pendingLength > 0) { @@ -187,7 +201,7 @@ export class FlowController extends Transform { public override _flush(callback: TransformCallback): void { let remaining = this.pendingLength > 0 - ? this.pendingBuffer.subarray(0, this.pendingLength) + ? (this.pendingBuffer?.subarray(0, this.pendingLength) ?? EMPTY_BUFFER) : EMPTY_BUFFER this.pendingLength = 0 @@ -227,4 +241,12 @@ export class FlowController extends Transform { callback() } + + override _destroy( + _err: Error | null, + cb: (error?: Error | null) => void + ): void { + this.pendingBuffer = null + cb(null) + } } diff --git a/src/playback/processing/LoudnessNormalizer.ts b/src/playback/processing/LoudnessNormalizer.ts index 94fac554..05df4490 100644 --- a/src/playback/processing/LoudnessNormalizer.ts +++ b/src/playback/processing/LoudnessNormalizer.ts @@ -129,7 +129,7 @@ export class LoudnessNormalizer { private _attackAlpha = 0 private _releaseAlpha = 0 private _energyAlpha = 0 - private _channelBuffer: Float32Array + private _channelBuffer: Float32Array | null /** * Creates a new LoudnessNormalizer. @@ -187,6 +187,7 @@ export class LoudnessNormalizer { */ public process(inputView: Int16Array): void { if (inputView.length === 0) return + if (!this._channelBuffer) return const frameCount = inputView.length / this.channels const channelBuffer = this._channelBuffer @@ -274,4 +275,9 @@ export class LoudnessNormalizer { this._releaseAlpha = fround(Math.exp(-1 / (releaseTime * sr))) this._energyAlpha = fround(Math.exp(-1 / (shortTermTime * sr))) } + + public destroy(): void { + this._channelBuffer = null + this.filters = [] + } } diff --git a/src/playback/processing/ScratchTransformer.ts b/src/playback/processing/ScratchTransformer.ts index 49397d90..35dbd0f9 100644 --- a/src/playback/processing/ScratchTransformer.ts +++ b/src/playback/processing/ScratchTransformer.ts @@ -44,7 +44,7 @@ export class ScratchTransformer extends Transform { * Internal circular buffer for storing PCM samples. * Storing as floats (0.0 to 1.0) simplifies resampling math. */ - private inputBuffer: Float32Array + private inputBuffer: Float32Array | null = null private inputReadPos = 0 private inputWritePos = 0 private readonly maxBufferSize: number @@ -59,7 +59,6 @@ export class ScratchTransformer extends Transform { this.channels = options.channels ?? 2 this.maxBufferSize = this.sampleRate * this.channels * 5 - this.inputBuffer = new Float32Array(this.maxBufferSize) } /** @@ -71,6 +70,8 @@ export class ScratchTransformer extends Transform { const duration = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 500 this._lastEffectCompleted = false + if (duration > 0) this._ensureInputBuffer() + if (style === 'start' && this.inputWritePos > 0) { const latencySamples = 1024 * this.channels this.inputReadPos = Math.max( @@ -123,6 +124,16 @@ export class ScratchTransformer extends Transform { return this.currentRate } + private _ensureInputBuffer(): Float32Array { + if (!this.inputBuffer) { + this.inputBuffer = new Float32Array(this.maxBufferSize) + this.inputReadPos = 0 + this.inputWritePos = 0 + } + + return this.inputBuffer + } + /** * Core math for rate modulation. Simulates the physics of a DJ's hand. * @param t - Progress of the effect (0.0 to 1.0). @@ -186,9 +197,17 @@ export class ScratchTransformer extends Transform { */ public process(chunk: Buffer): Buffer { if (chunk.length === 0) return chunk + if ( + !this.state && + Math.abs(this.currentRate - 1.0) <= 0.001 && + this.inputWritePos <= this.inputReadPos + this.channels + ) { + return chunk + } const incomingSamples = chunk.length / 2 const incomingFrames = incomingSamples / this.channels + const inputBuffer = this._ensureInputBuffer() if (this.inputWritePos + incomingSamples > this.maxBufferSize) { this._compact() @@ -201,7 +220,7 @@ export class ScratchTransformer extends Transform { } for (let i = 0; i < incomingSamples; i++) { - this.inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767 + inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767 } const outI16 = new Int16Array(incomingSamples) @@ -240,10 +259,10 @@ export class ScratchTransformer extends Transform { const frac = (this.inputReadPos - iPos) / this.channels for (let c = 0; c < this.channels; c++) { - const p0 = this.inputBuffer[safeIPos - this.channels + c] || 0 - const p1 = this.inputBuffer[safeIPos + c] || 0 - const p2 = this.inputBuffer[safeIPos + this.channels + c] || 0 - const p3 = this.inputBuffer[safeIPos + this.channels * 2 + c] || 0 + const p0 = inputBuffer[safeIPos - this.channels + c] || 0 + const p1 = inputBuffer[safeIPos + c] || 0 + const p2 = inputBuffer[safeIPos + this.channels + c] || 0 + const p3 = inputBuffer[safeIPos + this.channels * 2 + c] || 0 const val = 0.5 * @@ -273,6 +292,8 @@ export class ScratchTransformer extends Transform { * This allows the "disk" to be pulled backwards immediately even at the start of a chunk. */ private _compact(): void { + if (!this.inputBuffer) return + const historyFrames = this.sampleRate * 1 const keepSamples = historyFrames * this.channels @@ -288,4 +309,13 @@ export class ScratchTransformer extends Transform { this.inputReadPos -= copyStart this.inputWritePos = remaining } + + override _destroy( + _err: Error | null, + cb: (error?: Error | null) => void + ): void { + this.inputBuffer = null + this.state = null + cb(null) + } } diff --git a/src/playback/processing/TapeTransformer.ts b/src/playback/processing/TapeTransformer.ts index 39d20750..9e1b181d 100644 --- a/src/playback/processing/TapeTransformer.ts +++ b/src/playback/processing/TapeTransformer.ts @@ -30,7 +30,7 @@ export class TapeTransformer extends Transform { private tape: TapeState | null = null private _lastRampCompleted = false - private inputBuffer: Float32Array + private inputBuffer: Float32Array | null = null private inputReadPos = 0 private inputWritePos = 0 private readonly maxBufferSize: number @@ -41,7 +41,6 @@ export class TapeTransformer extends Transform { this.channels = options.channels ?? 2 this.maxBufferSize = this.sampleRate * this.channels * 10 - this.inputBuffer = new Float32Array(this.maxBufferSize) } public setRate(rate: number): void { @@ -58,6 +57,8 @@ export class TapeTransformer extends Transform { const duration = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0 this._lastRampCompleted = false + if (duration > 0) this._ensureInputBuffer() + if (type === 'start' && this.inputWritePos > 0) { const latencySamples = 1024 * this.channels this.inputReadPos = Math.max(0, this.inputWritePos - latencySamples) @@ -100,6 +101,16 @@ export class TapeTransformer extends Transform { return this.currentRate } + private _ensureInputBuffer(): Float32Array { + if (!this.inputBuffer) { + this.inputBuffer = new Float32Array(this.maxBufferSize) + this.inputReadPos = 0 + this.inputWritePos = 0 + } + + return this.inputBuffer + } + private _getCurveValue(t: number, curve: FadeCurve): number { switch (curve) { case 'linear': @@ -130,9 +141,17 @@ export class TapeTransformer extends Transform { public process(chunk: Buffer): Buffer { if (chunk.length === 0) return chunk + if ( + !this.tape && + Math.abs(this.currentRate - 1.0) <= 0.001 && + this.inputWritePos <= this.inputReadPos + this.channels + ) { + return chunk + } const incomingSamples = chunk.length / 2 const incomingFrames = incomingSamples / this.channels + const inputBuffer = this._ensureInputBuffer() if (this.inputWritePos + incomingSamples > this.maxBufferSize) { this._compact() @@ -145,7 +164,7 @@ export class TapeTransformer extends Transform { } for (let i = 0; i < incomingSamples; i++) { - this.inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767 + inputBuffer[this.inputWritePos++] = chunk.readInt16LE(i * 2) / 32767 } const outI16 = new Int16Array(incomingSamples) @@ -174,12 +193,10 @@ export class TapeTransformer extends Transform { for (let c = 0; c < this.channels; c++) { const p0 = - this.inputBuffer[iPos - this.channels + c] ?? - this.inputBuffer[iPos + c] ?? - 0 - const p1 = this.inputBuffer[iPos + c] ?? 0 - const p2 = this.inputBuffer[iPos + this.channels + c] ?? 0 - const p3 = this.inputBuffer[iPos + this.channels * 2 + c] ?? 0 + inputBuffer[iPos - this.channels + c] ?? inputBuffer[iPos + c] ?? 0 + const p1 = inputBuffer[iPos + c] ?? 0 + const p2 = inputBuffer[iPos + this.channels + c] ?? 0 + const p3 = inputBuffer[iPos + this.channels * 2 + c] ?? 0 const val = 0.5 * @@ -204,7 +221,18 @@ export class TapeTransformer extends Transform { return Buffer.from(outI16.buffer, outI16.byteOffset, outI16.byteLength) } + override _destroy( + _err: Error | null, + cb: (error?: Error | null) => void + ): void { + this.inputBuffer = null + this.tape = null + cb(null) + } + private _compact(): void { + if (!this.inputBuffer) return + const integralReadPos = Math.floor(this.inputReadPos / this.channels) * this.channels const fractionalReadPos = this.inputReadPos - integralReadPos diff --git a/src/playback/processing/VolumeTransformer.ts b/src/playback/processing/VolumeTransformer.ts index ca4eedc2..e4d97f6f 100644 --- a/src/playback/processing/VolumeTransformer.ts +++ b/src/playback/processing/VolumeTransformer.ts @@ -26,7 +26,7 @@ export class VolumeTransformer extends Transform implements IVolumeTransformer { public readonly sampleRate: number public readonly channels: number private readonly lookaheadSamples: number - private readonly lookaheadBuffer: Int16Array + private lookaheadBuffer: Int16Array | null private lookaheadIndex: number public lookaheadFull: boolean private currentVolume: number @@ -41,7 +41,7 @@ export class VolumeTransformer extends Transform implements IVolumeTransformer { public readonly limiterSoftness: number private readonly _thresholdValue: number private readonly _limitHeadroom: number - private readonly agc: LoudnessNormalizer | null + private agc: LoudnessNormalizer | null /** * Creates a new VolumeTransformer. @@ -124,6 +124,18 @@ export class VolumeTransformer extends Transform implements IVolumeTransformer { : null } + public setAGCEnabled(enabled: boolean): void { + if (enabled && !this.agc) { + this.agc = new LoudnessNormalizer({ + sampleRate: this.sampleRate, + channels: this.channels, + targetLoudness: -14 + }) + } else if (!enabled && this.agc) { + this.agc = null + } + } + private _getFadeCurveValue(progress: number): number { const clamped = Math.min(1, Math.max(0, progress)) switch (this.fadeCurve) { @@ -258,7 +270,7 @@ export class VolumeTransformer extends Transform implements IVolumeTransformer { usableSamples > 1 ? (gainEnd - gainStart) / (usableSamples - 1) : 0 let gain = gainStart - if (this.lookaheadSamples > 0) { + if (this.lookaheadSamples > 0 && this.lookaheadBuffer) { const outputBuffer = alignedBufferIfRequired(chunk.length) const outputView = new Int16Array( outputBuffer.buffer, @@ -345,4 +357,16 @@ export class VolumeTransformer extends Transform implements IVolumeTransformer { callback(error as Error) } } + + override _destroy( + _err: Error | null, + cb: (error?: Error | null) => void + ): void { + this.lookaheadBuffer = null + if (this.agc && typeof this.agc.destroy === 'function') { + this.agc.destroy() + } + this.agc = null + cb(null) + } } diff --git a/src/playback/processing/filtersManager.ts b/src/playback/processing/filtersManager.ts index 6514f102..bbcba69d 100644 --- a/src/playback/processing/filtersManager.ts +++ b/src/playback/processing/filtersManager.ts @@ -30,6 +30,7 @@ import Spatial from '../filters/spatial.ts' import Timescale from '../filters/timescale.ts' import Tremolo from '../filters/tremolo.ts' import Vibrato from '../filters/vibrato.ts' +import Tesseract from '../filters/tesseract.ts' const FILTER_CLASSES: Record = { tremolo: Tremolo, @@ -49,7 +50,8 @@ const FILTER_CLASSES: Record = { spatial: Spatial, reverb: Reverb, flanger: Flanger, - phonograph: Phonograph + phonograph: Phonograph, + tesseract: Tesseract } const CANONICAL_KEY_MAP: Record = {} for (const key in FILTER_CLASSES) { @@ -283,10 +285,28 @@ export class FiltersManager extends Transform implements IFiltersManager { private _normalizeFilters( filters: FiltersState | FilterSettings ): FilterSettings { - if (!filters || typeof filters !== 'object') return {} - if ('filters' in filters) { - return (filters as FiltersState).filters ?? {} + let normalized: FilterSettings = {} + if (filters && typeof filters === 'object') { + if ('filters' in filters) { + normalized = (filters as FiltersState).filters ?? {} + } else { + normalized = filters as FilterSettings + } + } + + return normalized + } + + override _destroy( + _err: Error | null, + cb: (error?: Error | null) => void + ): void { + for (const name in this.filterInstances) { + const instance = this.filterInstances[name] + instance?.destroy?.() + delete this.filterInstances[name] } - return filters as FilterSettings + this.activeFilters = [] + cb(null) } } diff --git a/src/playback/processing/streamProcessor.ts b/src/playback/processing/streamProcessor.ts index 7e948bf4..324b5daf 100644 --- a/src/playback/processing/streamProcessor.ts +++ b/src/playback/processing/streamProcessor.ts @@ -46,7 +46,8 @@ import type { ResamplingQuality, RingBufferLike, SeekableStreamMeta, - SymphoniaDecoderLike + SymphoniaDecoderLike, + SymphoniaDecoderStreamOptions } from '../../typings/playback/streamProcessor.types.ts' import { http1makeRequest, logger } from '../../utils.ts' import FlvDemuxer from '../demuxers/Flv.ts' @@ -65,6 +66,11 @@ type LibSampleRateModule = typeof import('@alexanderolsen/libsamplerate-js') let libSampleRatePromise: Promise | null = null type MP4BoxModule = typeof import('mp4box') +type MP4Descriptor = { + tag?: number + data?: Uint8Array + descs?: MP4Descriptor[] +} let mp4BoxPromise: Promise | null = null const getMP4Box = async (): Promise => { @@ -77,7 +83,7 @@ const getMP4Box = async (): Promise => { const getLibSampleRate = async (): Promise => { if (!libSampleRatePromise) { libSampleRatePromise = import('@alexanderolsen/libsamplerate-js').then( - (module) => module as unknown as LibSampleRateModule + (module) => (module.default || module) as unknown as LibSampleRateModule ) } @@ -105,7 +111,7 @@ const parsePositiveIntEnv = (key: string, fallback: number): number => { const AAC_BUFFER_SIZE: number = parsePositiveIntEnv( 'NODELINK_AAC_RING_BYTES', - 2 * 1024 * 1024 + 512 * 1024 ) const AUDIO_CONSTANTS: AudioConstants = Object.freeze({ @@ -137,14 +143,46 @@ const SAMPLE_RATES: readonly number[] = Object.freeze([ 8000, 7350 ]) +const _parseAacSampleRate = (data: Uint8Array): number | null => { + let bitOffset = 0 + const readBits = (count: number): number | null => { + if (bitOffset + count > data.byteLength * 8) return null + + let value = 0 + for (let i = 0; i < count; i++) { + const byte = data[bitOffset >> 3] + if (byte === undefined) return null + value = (value << 1) | ((byte >> (7 - (bitOffset & 7))) & 1) + bitOffset++ + } + return value + } + + const objectType = readBits(5) + if (objectType === null) return null + if (objectType === 31 && readBits(6) === null) return null + + const samplingIndex = readBits(4) + if (samplingIndex === null) return null + + if (samplingIndex === 15) { + const explicitSampleRate = readBits(24) + return explicitSampleRate && explicitSampleRate > 0 + ? explicitSampleRate + : null + } + + return SAMPLE_RATES[samplingIndex] ?? null +} + const EMPTY_BUFFER: Buffer = Buffer.alloc(0) const _getResamplerConverterType = ( quality: ResamplingQuality, libSampleRate: LibSampleRateModule -): number => { +): LibSampleRateModule['ConverterType'][keyof LibSampleRateModule['ConverterType']] => { const types = libSampleRate.ConverterType - const qualityMap: Record = { + const qualityMap: Record = { best: types.SRC_SINC_BEST_QUALITY, medium: types.SRC_SINC_MEDIUM_QUALITY, fastest: types.SRC_SINC_FASTEST, @@ -263,6 +301,21 @@ const _isWebmFormat = (type: string): boolean => type.includes('webm') || type.includes('weba') const _isFlvFormat = (type: string): boolean => type.indexOf('flv') !== -1 + +const _getSymphoniaCodecHint = (type: string): string | null => { + const lowerType = type.toLowerCase() + if (lowerType.includes('flac')) return 'flac' + if (lowerType.includes('mp3') || lowerType.includes('mpeg')) return 'mp3' + if (lowerType.includes('ogg') || lowerType.includes('vorbis')) return 'ogg' + if (lowerType.includes('wav') || lowerType.includes('wave')) return 'wav' + if ( + lowerType.includes('alac') || + lowerType.includes('mp4') || + lowerType.includes('m4a') + ) + return 'm4a' + return null +} const _tightBuffer = (buf: Buffer): Buffer => buf.byteOffset === 0 && buf.byteLength === buf.buffer.byteLength ? buf @@ -581,19 +634,26 @@ class PCMFrameCounter extends Transform { class BaseAudioResource { pipes: (Readable | Transform)[] | null stream: (VoiceAudioStream & Transform) | null + canStop?: boolean protected _destroyed: boolean protected guildId: string + protected _forwardFinishBuffering: ((...args: unknown[]) => void) | null = + null + protected _finishBufferingEmitted: boolean constructor(guildId?: string) { this.guildId = guildId || 'api-stream' this.pipes = [] this.stream = null + this.canStop = false this._destroyed = false + this._finishBufferingEmitted = false } protected _assignStream(stream: Transform): void { const voiceStream = stream as unknown as VoiceAudioStream & Transform & { + canStop?: boolean checkTapeRampCompleted?: () => boolean scratchTo?: ( durationMs: number, @@ -603,6 +663,15 @@ class BaseAudioResource { getEffectiveRate?: () => number getRMS?: () => number isSilent?: () => boolean + setFadeVolume?: (volume: number) => void + fadeTo?: (volume: number, durationMs: number, curve?: string) => void + tapeTo?: ( + durationMs: number, + type: 'start' | 'stop', + curve?: string + ) => void + setLoudnessNormalizer?: (enabled: boolean) => void + isPipelineFinished?: () => boolean } voiceStream.setVolume = (volume: number) => this.setVolume(volume) voiceStream.setFilters = (filters: FiltersState) => this.setFilters(filters) @@ -616,6 +685,35 @@ class BaseAudioResource { voiceStream.getEffectiveRate = () => this.getEffectiveRate() voiceStream.getRMS = () => this.getRMS() voiceStream.isSilent = () => this.isSilent() + voiceStream.setFadeVolume = (volume: number) => this.setFadeVolume(volume) + voiceStream.fadeTo = (volume: number, durationMs: number, curve?: string) => + this.fadeTo(volume, durationMs, curve) + voiceStream.tapeTo = ( + durationMs: number, + type: 'start' | 'stop', + curve?: string + ) => this.tapeTo(durationMs, type, curve) + voiceStream.setLoudnessNormalizer = (enabled: boolean) => + this.setLoudnessNormalizer(enabled) + voiceStream.isPipelineFinished = () => this.isPipelineFinished() + + /* + * This will prevent a race condition where fast CDN/network streams finish buffering and emit + * 'finishBuffering' before the voice connection finishes starting and subscribes to the event. + * Using 'newListener' event, if the voice player subscribes after the stream has + * already buffered, we will re-emit 'finishBuffering' immediately, allowing the track to be stoppable + * and transition to trackEnd naturally. + * + * ... i hate nodejs sometimes... + */ + voiceStream.on('newListener', (event) => { + if (event === 'finishBuffering' && this._finishBufferingEmitted) { + setImmediate(() => { + voiceStream.emit('finishBuffering') + }) + } + }) + this.stream = voiceStream } @@ -626,6 +724,27 @@ class BaseAudioResource { const firstPipe = this.pipes[0] as Readable & { stopHls?: () => void responseStream?: { destroyed: boolean; destroy: () => void } + _sourceStream?: Readable & { + off?: (event: string, handler: (...args: unknown[]) => void) => void + destroyed?: boolean + destroy?: (err?: Error) => void + } + _cleanupListeners?: () => void + } + + if (typeof firstPipe?._cleanupListeners === 'function') { + try { + firstPipe._cleanupListeners() + } catch {} + } + + if (this._forwardFinishBuffering && firstPipe?._sourceStream) { + try { + firstPipe._sourceStream.off?.( + 'finishBuffering', + this._forwardFinishBuffering + ) + } catch {} } if (firstPipe?.stopHls) { @@ -636,14 +755,13 @@ class BaseAudioResource { firstPipe.responseStream.destroy() } - const src = firstPipe as Readable & { - _sourceStream?: Readable & { - destroyed?: boolean - destroy?: (err?: Error) => void - } - } - if (src._sourceStream && !src._sourceStream.destroyed) { - src._sourceStream.destroy() + if (firstPipe?._sourceStream && !firstPipe._sourceStream.destroyed) { + try { + firstPipe._sourceStream.destroy() + } catch {} + try { + delete (firstPipe as unknown as Record)._sourceStream + } catch {} } for (let i = this.pipes.length - 1; i >= 0; i--) { @@ -651,14 +769,13 @@ class BaseAudioResource { abort?: () => void unpipe?: () => void destroy?: () => void - removeAllListeners?: () => void } pipe.abort?.() pipe.unpipe?.() pipe.destroy?.() - pipe.removeAllListeners?.() } + this.pipes.length = 0 this.stream = null this.pipes = null } @@ -704,6 +821,23 @@ class BaseAudioResource { return false } + tapeTo(_durationMs: number, _type: 'start' | 'stop', _curve?: string): void {} + + setLoudnessNormalizer(_enabled: boolean): void {} + + isPipelineFinished(): boolean { + if (this._destroyed || !this.pipes) return true + for (const pipe of this.pipes) { + if ( + (pipe as unknown as { isFinished?: boolean }).isFinished || + pipe.readableEnded + ) { + return true + } + } + return false + } + setVolume(volume: number): void { if (!this.pipes) return @@ -822,43 +956,33 @@ class BaseAudioResource { class SymphoniaDecoderStream extends Transform { private decoder: SymphoniaDecoderLike | null - private resumeInput: ((error?: Error | null) => void) | null + private readonly codecRegistryHint: string | null + private flushCallback: TransformCallback | null + private inputClosed: boolean private isFinished: boolean private _aborted: boolean - private _loopScheduled: boolean private _isDecoding: boolean private _timeoutId: ReturnType | null private _immediateId: ReturnType | null - private readonly _onResume: () => void - constructor( - options: { - highWaterMark?: number - objectMode?: boolean - } = {} - ) { + constructor(options: SymphoniaDecoderStreamOptions = {}) { + const { codecRegistryHint, ...streamOptions } = options + super({ - ...options, - highWaterMark: AUDIO_CONFIG.highWaterMark, + ...streamOptions, + highWaterMark: options.highWaterMark ?? AUDIO_CONFIG.highWaterMark, objectMode: false }) this.decoder = new SymphoniaDecoder() as SymphoniaDecoderLike - this.resumeInput = null + this.codecRegistryHint = codecRegistryHint ?? null + this.flushCallback = null + this.inputClosed = false this.isFinished = false this._aborted = false - this._loopScheduled = false this._isDecoding = false this._timeoutId = null this._immediateId = null - - this._onResume = () => { - if (!this.isFinished && !this._aborted && this.decoder) { - this._scheduleDecode() - } - } - - this.on('resume', this._onResume) } abort(): void { @@ -875,7 +999,6 @@ class SymphoniaDecoderStream extends Transform { clearImmediate(this._immediateId) this._immediateId = null } - this._loopScheduled = false } _isDecoderValid(): boolean { @@ -892,132 +1015,119 @@ class SymphoniaDecoderStream extends Transform { return } - this.decoder.push(chunk) - this._scheduleDecode() - - const bufferedBytes = this.decoder?.bufferedBytes ?? 0 - if (bufferedBytes > BUFFER_THRESHOLDS.maxCompressed) { - this.resumeInput = callback - } else { + try { + this.decoder.push(chunk) + if (!this.decoder.isProbed) { + this.decoder.initialize(this.codecRegistryHint) + } + this._scheduleDecode() callback() + } catch (err) { + callback(err as Error) } } - _scheduleDecode(): void { - if ( - this._loopScheduled || - this._isDecoding || - !this._isDecoderValid() || - this.readableFlowing === false - ) - return + override _read(_size: number): void { + super._read(_size) - if (this.readableLength >= this.readableHighWaterMark) { - this._loopScheduled = true + if (this._isDecoderValid()) { + this._scheduleDecode() + } + } + + _scheduleDecode(delayMs = 0): void { + if (this._immediateId || this._timeoutId || !this._isDecoderValid()) return + + if (delayMs > 0) { this._timeoutId = setTimeout(() => { this._timeoutId = null - this._loopScheduled = false - if (this._isDecoderValid()) this._scheduleDecode() - }, AUDIO_CONSTANTS.decodeIntervalMs) + this._decodeLoop() + }, delayMs) return } - this._loopScheduled = true - - this._timeoutId = setTimeout(() => { - this._timeoutId = null - this._loopScheduled = false - if (this._isDecoderValid()) this._decodeLoop() - }, AUDIO_CONSTANTS.decodeIntervalMs) + this._immediateId = setImmediate(() => { + this._immediateId = null + this._decodeLoop() + }) } - async _decodeLoop(): Promise { - if (!this._isDecoderValid() || (this.readableFlowing as boolean) === false) + _decodeLoop(): void { + if (this._isDecoding || !this._isDecoderValid()) return + + if (!this.decoder?.isProbed) { + try { + if (!this.decoder?.initialize(this.codecRegistryHint)) { + if (this.inputClosed) this._finishDecode() + return + } + } catch (err) { + this._failDecode(err) + return + } + } + + if (this.readableLength >= this.readableHighWaterMark) { + this._scheduleDecode(AUDIO_CONSTANTS.decodeIntervalMs) return + } + this._isDecoding = true try { - let hasMoreData = true + let decodeCount = 0 while ( - hasMoreData && + decodeCount < AUDIO_CONSTANTS.maxDecodesPerTick && this._isDecoderValid() && - (this.readableFlowing as boolean) !== false && this.readableLength < this.readableHighWaterMark ) { - hasMoreData = this._processAudio() + const result = this.decoder?.decode() + if (!result) { + if (this.inputClosed) this._finishDecode() + return + } - if (hasMoreData && this._isDecoderValid()) { - await new Promise((resolve) => { - this._immediateId = setImmediate(() => { - this._immediateId = null - resolve() - }) - }) + decodeCount++ + if (result.samples.length === 0) continue + if (!this.push(result.samples)) { + this._scheduleDecode(AUDIO_CONSTANTS.decodeIntervalMs) + return } } + + this._scheduleDecode() } catch (err) { - if (!this._aborted) this.emit('error', err) + this._failDecode(err) } finally { this._isDecoding = false } - - const bufferedBytes = this.decoder?.bufferedBytes ?? 0 - if ( - bufferedBytes > 0 && - this._isDecoderValid() && - (this.readableFlowing as boolean) !== false && - this.readableLength < this.readableHighWaterMark - ) { - this._scheduleDecode() - } } - _processAudio(): boolean { - if (!this._isDecoderValid()) return false - if (this.readableLength >= this.readableHighWaterMark) return true - - if (!this.decoder?.isProbed) { - try { - if (!this.decoder?.initialize()) return false - } catch (err) { - throw new Error(`Symphonia init failed: ${(err as Error).message}`) - } - } - - let decodeCount = 0 - let hasOutput = false + _finishDecode(): void { + const callback = this.flushCallback + this.flushCallback = null + this.isFinished = true + this._cleanup() + callback?.() + } - while ( - decodeCount < AUDIO_CONSTANTS.maxDecodesPerTick && - this._isDecoderValid() && - this.readableLength < this.readableHighWaterMark - ) { - const result = this.decoder?.decode() - if (!result) break - - const canPush = this.push(result.samples) - hasOutput = true - decodeCount++ - - if (this.resumeInput) { - const afterBytes = this.decoder?.bufferedBytes ?? 0 - if (afterBytes < BUFFER_THRESHOLDS.minCompressed) { - const cb = this.resumeInput - this.resumeInput = null - cb() - } - } + _failDecode(err: unknown): void { + const callback = this.flushCallback + this.flushCallback = null + this.isFinished = true + this._cleanup() - if (!canPush) break + const error = + err instanceof Error ? err : new Error(`Symphonia decode failed: ${err}`) + if (callback) { + callback(error) + } else { + this.emit('error', error) } - - const remainingBytes = this.decoder?.bufferedBytes ?? 0 - return hasOutput || remainingBytes > 0 } override _flush(callback: TransformCallback): void { - this.isFinished = true this._cancelTimers() if (this._aborted || !this.decoder) { @@ -1028,18 +1138,24 @@ class SymphoniaDecoderStream extends Transform { try { this.decoder.closeInput() - - let count = 0 - while (count < 1000) { - const result = this.decoder?.decode() - if (!result) break - this.push(result.samples) - count++ + this.inputClosed = true + this.flushCallback = callback + + if (!this.decoder.initialize(this.codecRegistryHint)) { + if ((this.decoder.bufferedBytes ?? 0) === 0) { + this._cleanup() + callback() + return + } + throw new Error('Symphonia init failed: not enough input data') } - } catch {} - this._cleanup() - callback() + this._decodeLoop() + } catch (err) { + this.flushCallback = null + this._cleanup() + callback(err as Error) + } } override _destroy( @@ -1050,10 +1166,10 @@ class SymphoniaDecoderStream extends Transform { this.isFinished = true this._cancelTimers() - if (this.resumeInput) { - const cb = this.resumeInput - this.resumeInput = null - cb() + if (this.flushCallback) { + const cb = this.flushCallback + this.flushCallback = null + cb(err) } this._cleanup() @@ -1062,20 +1178,8 @@ class SymphoniaDecoderStream extends Transform { _cleanup(): void { this._cancelTimers() - this.removeListener('resume', this._onResume) - - if (this.resumeInput) { - const cb = this.resumeInput - this.resumeInput = null - try { - cb() - } catch {} - } if (this.decoder) { - try { - this.decoder.flush() - } catch {} try { this.decoder.free() } catch {} @@ -1175,7 +1279,7 @@ class MPEGTSDemuxer extends Transform { offset += (packet[offset] || 0) + 1 if (offset + 11 < MPEGTS_CONFIG.packetSize) { this.patPmtId = - ((packet[offset + 10] || 0 & 0x1f) << 8) | (packet[offset + 11] || 0) + (((packet[offset + 10] || 0) & 0x1f) << 8) | (packet[offset + 11] || 0) } } @@ -1274,11 +1378,14 @@ class AACDecoderStream extends Transform { private resamplerCreationPromise: Promise | null private static readonly MAX_PENDING_CHUNKS = 200 + private state: { isAlac: boolean } | null + constructor(options: AACDecoderStreamOptions) { super({ ...options, highWaterMark: AUDIO_CONFIG.highWaterMark }) + this.state = options.state ?? null this.decoder = new FAAD2NodeDecoder() as unknown as FAAD2DecoderLike this.resampler = null this.isDecoderReady = false @@ -1305,7 +1412,10 @@ class AACDecoderStream extends Transform { this.ringBuffer.dispose() this.pendingChunks.length = 0 if (this.decoder) this.decoder.free?.() - if (this.resampler) this.resampler.destroy?.() + if (this.resampler) { + this.resampler.destroy?.() + this.resampler = null + } super._destroy(err, cb) } @@ -1432,6 +1542,12 @@ class AACDecoderStream extends Transform { encoding: BufferEncoding, callback: TransformCallback ): void { + if (this.state?.isAlac) { + this.push(chunk) + callback() + return + } + if (!this.isDecoderReady || this.pendingChunks.length > 0) { if (this.pendingChunks.length >= AACDecoderStream.MAX_PENDING_CHUNKS) { this.pendingChunks.shift() @@ -1493,8 +1609,7 @@ class AACDecoderStream extends Transform { converterType: _getResamplerConverterType( this.resamplingQuality as ResamplingQuality, libSampleRate - // biome-ignore lint/suspicious/noExplicitAny: library type mismatch - ) as any + ) }) ) .then((resampler: ResamplerLike) => { @@ -1533,6 +1648,11 @@ class AACDecoderStream extends Transform { } override _flush(callback: TransformCallback): void { + if (this.state?.isAlac) { + callback() + return + } + if (this.ringBuffer.length > 0 && this.isConfigured) { try { const frameInfo = this._findADTSFrame() @@ -1550,13 +1670,96 @@ class AACDecoderStream extends Transform { } catch (_err) {} } - if (this.resampler) this.resampler.destroy?.() + if (this.resampler) { + this.resampler.destroy?.() + this.resampler = null + } if (this.decoder) this.decoder.destroy?.() callback() } } type MP4PrefetchChunk = { fileStart: number; data: ArrayBuffer } +function patchMoovOffsets(moovBuffer: Buffer, shift: number): void { + let idx = 0 + while (true) { + idx = moovBuffer.indexOf('stco', idx) + if (idx === -1) break + const boxStart = idx - 4 + if (boxStart >= 0) { + const boxSize = moovBuffer.readUInt32BE(boxStart) + const entryCount = moovBuffer.readUInt32BE(idx + 8) + if (boxSize === 16 + entryCount * 4) { + for (let i = 0; i < entryCount; i++) { + const offsetPos = idx + 12 + i * 4 + const originalOffset = moovBuffer.readUInt32BE(offsetPos) + moovBuffer.writeUInt32BE(originalOffset + shift, offsetPos) + } + } + } + idx += 4 + } + + idx = 0 + while (true) { + idx = moovBuffer.indexOf('co64', idx) + if (idx === -1) break + const boxStart = idx - 4 + if (boxStart >= 0) { + const boxSize = moovBuffer.readUInt32BE(boxStart) + const entryCount = moovBuffer.readUInt32BE(idx + 8) + if (boxSize === 16 + entryCount * 8) { + for (let i = 0; i < entryCount; i++) { + const offsetPos = idx + 12 + i * 8 + const high = moovBuffer.readUInt32BE(offsetPos) + const low = moovBuffer.readUInt32BE(offsetPos + 4) + const originalOffset = high * 0x100000000 + low + const newOffset = originalOffset + shift + const newHigh = Math.floor(newOffset / 0x100000000) + const newLow = newOffset % 0x100000000 + moovBuffer.writeUInt32BE(newHigh, offsetPos) + moovBuffer.writeUInt32BE(newLow, offsetPos + 4) + } + } + } + idx += 4 + } +} + +/* INFO: for context of why i did this: https://github.com/pdeljanov/Symphonia/issues/289, still seems to be broken. */ +function reorderMp4Boxes(originalBuffer: Buffer): Buffer { + const topBoxes = _parseBoxes(originalBuffer) + const ftyp = topBoxes.find((b) => b.type === 'ftyp') + const moov = topBoxes.find((b) => b.type === 'moov') + const mdat = topBoxes.find((b) => b.type === 'mdat') + + if (!ftyp || !moov || !mdat) { + return originalBuffer + } + + if (moov.offset < mdat.offset) { + return originalBuffer + } + + const ftypBuffer = originalBuffer.subarray( + ftyp.offset, + ftyp.offset + ftyp.size + ) + const moovBuffer = Buffer.from( + originalBuffer.subarray(moov.offset, moov.offset + moov.size) + ) + + patchMoovOffsets(moovBuffer, moov.size) + + const beforeMoov = originalBuffer.subarray( + ftyp.offset + ftyp.size, + moov.offset + ) + const afterMoov = originalBuffer.subarray(moov.offset + moov.size) + + return Buffer.concat([ftypBuffer, moovBuffer, beforeMoov, afterMoov]) +} + type MP4ToAACStreamOptions = TransformOptions & { prefetch?: MP4PrefetchChunk[] baseFileStart?: number @@ -1571,8 +1774,13 @@ class MP4ToAACStream extends Transform { private _prefetchDone: boolean private _opts: MP4ToAACStreamOptions private _initPromise: Promise | null + private state: { isAlac: boolean } | null + private symphoniaDecoder: SymphoniaDecoderStream | null + private headerChunks: Buffer[] - constructor(options: MP4ToAACStreamOptions = {}) { + constructor( + options: MP4ToAACStreamOptions & { state?: { isAlac: boolean } } = {} + ) { super({ ...options, highWaterMark: AUDIO_CONFIG.highWaterMark }) this._opts = options @@ -1582,6 +1790,9 @@ class MP4ToAACStream extends Transform { this._aborted = false this._prefetchDone = false this._initPromise = null + this.state = options.state ?? null + this.symphoniaDecoder = null + this.headerChunks = [] } private async _initMp4Box(): Promise { @@ -1593,7 +1804,7 @@ class MP4ToAACStream extends Transform { this._initPromise = (async () => { const mp4Box = await getMP4Box() - this.mp4boxFile = mp4Box.createFile(true) as unknown as MP4BoxFile + this.mp4boxFile = mp4Box.createFile(false) as unknown as MP4BoxFile this._setupMP4BoxHandlers() })() @@ -1603,6 +1814,9 @@ class MP4ToAACStream extends Transform { abort(): void { this._aborted = true this._cleanupMp4Box() + if (this.symphoniaDecoder) { + this.symphoniaDecoder.abort?.() + } } private _appendPrefetchIfNeeded(): void { @@ -1610,6 +1824,7 @@ class MP4ToAACStream extends Transform { this._prefetchDone = true const prefetch = this._opts.prefetch ?? [] + this._opts.prefetch = undefined for (const chunk of prefetch) { const ab = chunk.data as ArrayBuffer & { fileStart?: number } ab.fileStart = chunk.fileStart @@ -1627,44 +1842,66 @@ class MP4ToAACStream extends Transform { this.mp4boxFile.onReady = (info: MP4BoxInfo): void => { if (this._aborted || !this.mp4boxFile) return - const audioTrack = info.tracks.find((t: MP4BoxTrack) => - t.codec?.startsWith('mp4a') + const audioTrack = info.tracks.find( + (t: MP4BoxTrack) => + t.codec?.startsWith('mp4a') || t.codec?.startsWith('alac') ) - if (!audioTrack) throw new Error('No AAC track found in MP4') + if (!audioTrack) { + throw new Error('No supported track found in MP4') + } - this.audioConfig = this._getAudioConfig(audioTrack) + if (audioTrack.codec?.startsWith('alac')) { + if (this.state) this.state.isAlac = true + this._cleanupMp4Box() + this.symphoniaDecoder = new SymphoniaDecoderStream({ + codecRegistryHint: 'm4a' + }) + this.symphoniaDecoder.on('data', (pcm: Buffer) => { + this.push(pcm) + }) + this.symphoniaDecoder.on('error', (err) => { + this.emit('error', err) + }) + const fullBuffer = Buffer.concat(this.headerChunks) + const reordered = reorderMp4Boxes(fullBuffer) + this.headerChunks = [] + this.symphoniaDecoder.write(reordered) + } else { + this.audioConfig = this._getAudioConfig(audioTrack) + this.headerChunks = [] - this.mp4boxFile.setExtractionOptions(audioTrack.id, null, { - nbSamples: 50 - }) + this.mp4boxFile.setExtractionOptions(audioTrack.id, null, { + nbSamples: 50 + }) - if (typeof this._opts.seekTimeSec === 'number') { - const mp4boxFile = this.mp4boxFile as unknown as { - seek: (time: number, async: boolean) => MP4BoxSeekResult - } - const seekRes = mp4boxFile.seek( - this._opts.seekTimeSec, - true - ) as MP4BoxSeekResult - const expectedOffset = _seekOffset(seekRes) - - if ( - typeof this._opts.baseFileStart === 'number' && - this._opts.baseFileStart !== expectedOffset - ) { - logger( - 'warn', - 'MP4ToAACStream', - `MP4 seek mismatch: stream starts at ${this._opts.baseFileStart} but MP4Box requested ${expectedOffset}` - ) - } + if (typeof this._opts.seekTimeSec === 'number') { + const mp4boxFile = this.mp4boxFile as unknown as { + seek: (time: number, async: boolean) => MP4BoxSeekResult + } + const seekRes = mp4boxFile.seek( + this._opts.seekTimeSec, + true + ) as MP4BoxSeekResult + const expectedOffset = _seekOffset(seekRes) + + if ( + typeof this._opts.baseFileStart === 'number' && + this._opts.baseFileStart !== expectedOffset + ) { + logger( + 'warn', + 'MP4ToAACStream', + `MP4 seek mismatch: stream starts at ${this._opts.baseFileStart} but MP4Box requested ${expectedOffset}` + ) + } - if (typeof this._opts.baseFileStart !== 'number') { - this.offset = expectedOffset + if (typeof this._opts.baseFileStart !== 'number') { + this.offset = expectedOffset + } } - } - this.mp4boxFile.start() + this.mp4boxFile.start() + } } this.mp4boxFile.onSamples = ( @@ -1709,7 +1946,34 @@ class MP4ToAACStream extends Transform { _getAudioConfig(track: MP4BoxTrack): AACConfig { let profile = 2 - let adtsSampleRate = track.audio.sample_rate + const file = this.mp4boxFile as unknown as { + getTrackById?: (id: number) => { + mdia?: { + minf?: { + stbl?: { + stsd?: { + entries?: Array<{ + esds?: { + esd?: { descs?: MP4Descriptor[] } + } + }> + } + } + } + } + } + } + const entry = file?.getTrackById?.(track.id)?.mdia?.minf?.stbl?.stsd + ?.entries?.[0] + const decoderConfig = entry?.esds?.esd?.descs?.find( + (descriptor) => descriptor.tag === 4 + ) + const decoderSpecificInfo = decoderConfig?.descs?.find( + (descriptor) => descriptor.tag === 5 + )?.data + const adtsSampleRate = + (decoderSpecificInfo && _parseAacSampleRate(decoderSpecificInfo)) || + track.audio.sample_rate if (track.codec) { const codecParts = (String(track.codec) || '').split('.') @@ -1718,13 +1982,9 @@ class MP4ToAACStream extends Transform { const objectType = Number.parseInt(codecParts[2] || '0', 10) if (objectType === 5 || objectType === 29) { - // HE-AAC/HE-AACv2 stores the output rate on the track, but ADTS must - // advertise the core AAC-LC rate (typically half of the output rate). + // ADTS carries the AAC-LC core profile. FAAD detects the SBR/PS + // extension from the payload and exposes the higher output rate. profile = 2 - adtsSampleRate = Math.max( - SAMPLE_RATES[SAMPLE_RATES.length - 1] ?? 7350, - Math.floor(track.audio.sample_rate / 2) - ) } else { profile = objectType } @@ -1755,6 +2015,14 @@ class MP4ToAACStream extends Transform { return } + if (this.symphoniaDecoder) { + this.symphoniaDecoder.write(chunk) + callback() + return + } + + if (!this.audioConfig) this.headerChunks.push(chunk) + try { await this._initMp4Box() if (!this.mp4boxFile) { @@ -1781,11 +2049,26 @@ class MP4ToAACStream extends Transform { } override _flush(callback: TransformCallback): void { + const decoderInstance = this + .symphoniaDecoder as SymphoniaDecoderStream | null + if (decoderInstance) { + decoderInstance.end(callback) + return + } + if (!this._aborted && this.mp4boxFile) { try { this.mp4boxFile.flush() } catch {} } + + const decoderInstanceAfter = this + .symphoniaDecoder as SymphoniaDecoderStream | null + if (decoderInstanceAfter) { + decoderInstanceAfter.end(callback) + return + } + this._cleanupMp4Box() callback() } @@ -1796,6 +2079,11 @@ class MP4ToAACStream extends Transform { ): void { this._aborted = true this._cleanupMp4Box() + this.headerChunks = [] + if (this.symphoniaDecoder) { + this.symphoniaDecoder.destroy() + this.symphoniaDecoder = null + } super._destroy(err, callback) } @@ -1803,6 +2091,7 @@ class MP4ToAACStream extends Transform { if (this.mp4boxFile) { try { this.mp4boxFile.stop() + this.mp4boxFile.flush() } catch {} this.mp4boxFile.onReady = null this.mp4boxFile.onSamples = null @@ -2370,7 +2659,7 @@ class StreamAudioResource extends BaseAudioResource { this._validateInputStream(stream) const resamplingQuality = - nodelink.options.audio?.resamplingQuality || 'fastest' + nodelink.options.playback.audio?.resamplingQuality || 'fastest' const normalizedType = normalizeFormat(type) this.pipes = [stream] @@ -2423,7 +2712,8 @@ class StreamAudioResource extends BaseAudioResource { case SupportedFormats.FLAC: case SupportedFormats.OGG_VORBIS: case SupportedFormats.WAV: - return this._createSymphoniaPipeline(stream) + case SupportedFormats.ALAC: + return this._createSymphoniaPipeline(stream, type) case SupportedFormats.OPUS: return this._createOpusPipeline(stream, type) @@ -2462,6 +2752,7 @@ class StreamAudioResource extends BaseAudioResource { const lowerType = type.toLowerCase() const _aacStream = stream const streams: (Readable | Transform)[] = [stream] + const state = { isAlac: false } if (_isFmp4Format(lowerType)) { const bufferMode = lowerType.includes('fmp4-buffered') @@ -2472,7 +2763,9 @@ class StreamAudioResource extends BaseAudioResource { streams.push(demuxer) if (lowerType.includes('mp3') || lowerType.includes('mpeg')) { - const decoder = new SymphoniaDecoderStream() + const decoder = new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(lowerType) + }) streams.push(decoder) this.pipes?.push(...streams.slice(1)) @@ -2497,15 +2790,17 @@ class StreamAudioResource extends BaseAudioResource { ? { prefetch: seekOpts.prefetch, baseFileStart: seekOpts.baseFileStart, - seekTimeSec: seekOpts.seekTimeSec + seekTimeSec: seekOpts.seekTimeSec, + state } - : {} + : { state } ) streams.push(demuxer) } const decoder = new AACDecoderStream({ - resamplingQuality: resamplingQuality as ResamplingQuality + resamplingQuality: resamplingQuality as ResamplingQuality, + state }) streams.push(decoder) @@ -2520,8 +2815,10 @@ class StreamAudioResource extends BaseAudioResource { return decoder } - _createSymphoniaPipeline(stream: Readable): Transform { - const decoder = new SymphoniaDecoderStream() + _createSymphoniaPipeline(stream: Readable, type: string): Transform { + const decoder = new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(type) + }) this.pipes?.push(decoder) pipeline(stream, decoder, (err: Error | null): void => { @@ -2578,8 +2875,8 @@ class StreamAudioResource extends BaseAudioResource { type: 's16le', volume, enableAGC, - lookaheadMs: nodelink.options.audio?.lookaheadMs, - gateThresholdLUFS: nodelink.options.audio?.gateThresholdLUFS + lookaheadMs: nodelink.options.playback.audio?.lookaheadMs, + gateThresholdLUFS: nodelink.options.playback.audio?.gateThresholdLUFS }) const fadeTransformer = new FadeTransformer({ type: 's16le', @@ -2599,7 +2896,8 @@ class StreamAudioResource extends BaseAudioResource { const silenceDetector = new SilenceDetector({ sampleRate: AUDIO_CONFIG.sampleRate, channels: AUDIO_CONFIG.channels, - thresholdDb: nodelink.options.audio?.automix?.silenceThresholdDb ?? -40 + thresholdDb: + nodelink.options.playback.audio?.automix?.silenceThresholdDb ?? -40 }) const flowController = new FlowController( @@ -2694,7 +2992,11 @@ class StreamAudioResource extends BaseAudioResource { return flowController?.checkScratchEffectCompleted() ?? false } - tapeTo(durationMs: number, type: 'start' | 'stop', curve?: string): void { + override tapeTo( + durationMs: number, + type: 'start' | 'stop', + curve?: string + ): void { if (!this.pipes) return const flowController = this.pipes.find( @@ -2719,6 +3021,25 @@ class StreamAudioResource extends BaseAudioResource { } } + override setLoudnessNormalizer(enabled: boolean): void { + if (!this.pipes) return + + const volumeTransformer = this.pipes.find( + (p) => p instanceof VolumeTransformer + ) as VolumeTransformer | undefined + if (volumeTransformer) { + volumeTransformer.setAGCEnabled(enabled) + return + } + + const flowController = this.pipes.find( + (p) => p instanceof FlowController + ) as FlowController | undefined + if (flowController) { + flowController.setLoudnessNormalizer(enabled) + } + } + _createPCMOutputPipeline( pcmStream: Transform, volume: number, @@ -2748,9 +3069,11 @@ class StreamAudioResource extends BaseAudioResource { _setupEventHandlers(inputStream: Readable): void { const forwardFinishBuffering = (): void => { if (!this._destroyed) { + this._finishBufferingEmitted = true this.stream?.emit('finishBuffering') } } + this._forwardFinishBuffering = forwardFinishBuffering inputStream.on('finishBuffering', forwardFinishBuffering) @@ -2943,7 +3266,7 @@ export const createPCMStream = ( filters: FiltersState = {} ): Transform => { const resamplingQuality = - nodelink.options.audio?.resamplingQuality || 'fastest' + nodelink.options.playback.audio?.resamplingQuality || 'fastest' const normalizedType = normalizeFormat(type) const streams: (Readable | Transform)[] = [stream] @@ -2951,6 +3274,7 @@ export const createPCMStream = ( switch (normalizedType) { case SupportedFormats.AAC: { const lowerType = type.toLowerCase() + const state = { isAlac: false } if (_isFmp4Format(lowerType)) { const bufferMode = lowerType.includes('fmp4-buffered') @@ -2959,14 +3283,20 @@ export const createPCMStream = ( streams.push(new MPEGTSDemuxer()) if (lowerType.includes('mp3') || lowerType.includes('mpeg')) { - streams.push(new SymphoniaDecoderStream()) + streams.push( + new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(lowerType) + }) + ) break } - } else if (_isMp4Format(lowerType)) streams.push(new MP4ToAACStream()) + } else if (_isMp4Format(lowerType)) + streams.push(new MP4ToAACStream({ state })) streams.push( new AACDecoderStream({ - resamplingQuality: resamplingQuality as ResamplingQuality + resamplingQuality: resamplingQuality as ResamplingQuality, + state }) ) break @@ -2985,8 +3315,13 @@ export const createPCMStream = ( case SupportedFormats.MPEG: case SupportedFormats.FLAC: case SupportedFormats.OGG_VORBIS: - case SupportedFormats.WAV: { - streams.push(new SymphoniaDecoderStream()) + case SupportedFormats.WAV: + case SupportedFormats.ALAC: { + streams.push( + new SymphoniaDecoderStream({ + codecRegistryHint: _getSymphoniaCodecHint(type) + }) + ) break } diff --git a/src/server/bunServer.ts b/src/server/bunServer.ts new file mode 100644 index 00000000..fbc8c9ff --- /dev/null +++ b/src/server/bunServer.ts @@ -0,0 +1,726 @@ +import { EventEmitter } from 'node:events' +import type { ServerWebSocket } from 'bun' +import type { NodelinkConfig } from '../typings/config/config.types.ts' +import type { + BunSocketData, + IBunSocketWrapper, + NodelinkSocketType, + RequestShim, + ResponseShim, + SessionSocket +} from '../typings/index.types.ts' +import type { ClientInfo, ReqShim } from '../typings/shared.types.ts' +import { logger, parseClient, verifyDiscordID } from '../utils.ts' + +const VOICE_PATH_RE = /^\/v4\/websocket\/voice\/([A-Za-z0-9]+)\/?$/ +const LIVE_PATH_RE = /^\/v4\/websocket\/youtube\/live\/([^/]+)\/?$/ + +type RequestHandler = ( + nodelink: import('../typings/api/api.types.ts').ApiNodelinkServer, + req: RequestShim, + res: ResponseShim +) => Promise + +/** + * Context required by the Bun server functions. + * Subset of NodelinkServer properties that the Bun code reads. + * @internal + */ +export interface BunServerContext { + options: NodelinkConfig + sessions: { + resumableSessions: Map + activeSessions: Map + } + socket: NodelinkSocketType +} + +/** + * Wrapper for Bun's ServerWebSocket that implements EventEmitter + * Provides compatibility with Node.js WebSocket implementations + */ +export class BunSocketWrapper + extends EventEmitter + implements IBunSocketWrapper +{ + ws: ServerWebSocket + remoteAddress: string + + /** + * Creates a new BunSocketWrapper + * @param ws - Bun ServerWebSocket instance + */ + constructor(ws: ServerWebSocket) { + super() + this.ws = ws + this.remoteAddress = ws?.data?.remoteAddress || 'unknown' + } + + /** + * Sends data through the WebSocket connection + * @param data - Data to send + * @returns True if sent successfully + * @public + */ + send(data: string | Buffer): boolean { + try { + const r = this.ws.send(data) + return r !== 0 + } catch { + return false + } + } + + /** + * Sends a WebSocket ping frame + * @param data - Optional ping data + * @returns True if sent successfully + * @public + */ + ping(data?: string | Buffer): boolean { + try { + this.ws.ping?.(data) + return true + } catch { + return false + } + } + + /** + * Closes the connection. + * + * - `1000` means "normal closure" **(default)** + * - `1009` means a message was too big and was rejected + * - `1011` means the server encountered an error + * - `1012` means the server is restarting + * - `1013` means the server is too busy or the client is rate-limited + * - `4000` through `4999` are reserved for applications (you can use it!) + * + * To close the connection abruptly, use `terminate()`. + * + * @param code The close code to send + * @param reason The close reason to send + * @public + */ + close(code?: number, reason?: string): void { + this.ws.close(code, reason) + } + + /** + * Terminates the connection immediately + * @public + */ + terminate(): void { + this.ws.close(1000, 'Terminated') + } + + /** + * Internal handler for received messages + * @param message - Message data + * @internal + */ + _handleMessage(message: string | Buffer): void { + this.emit('message', message) + } + + /** + * Internal handler for connection close events + * @param code - Close code + * @param reason - Close reason + * @internal + */ + _handleClose(code: number, reason: string): void { + this.emit('close', code, reason) + } +} + +/** + * Creates and configures Bun HTTP server with WebSocket support + * @param context - Server context (NodelinkServer subset) + * @param getRequestHandler - Lazy loader for the API request handler + * @returns The created Bun server instance + * @internal + */ +export function createBunServer( + context: BunServerContext, + getRequestHandler: () => Promise +): ReturnType { + const port = context.options.server.port + const host = context.options.server.host || '0.0.0.0' + const password = context.options.server.password + + logger( + 'warn', + 'Server', + 'Running with Bun.serve, remember this is experimental!' + ) + + const server = Bun.serve({ + port, + hostname: host, + maxRequestBodySize: 1024 * 1024 * 50, + idleTimeout: 60, + + error(error) { + logger( + 'error', + 'Server', + `HTTP server error: ${error instanceof Error ? error.message : String(error)}` + ) + return new Response('Internal Server Error', { status: 500 }) + }, + + async fetch(req, server) { + const url = new URL(req.url) + const pathname = url.pathname.endsWith('/') + ? url.pathname.slice(0, -1) + : url.pathname + + if (pathname === '/v4/profiler/socket') { + const remoteAddress = server.requestIP(req)?.address || 'unknown' + const isInternal = /^(::1|localhost|127\.0\.0\.1)/.test(remoteAddress) + const endpoint = context.options.cluster?.endpoint || {} + const patchEnabled = endpoint.patchEnabled === true + const allowExternalPatch = endpoint.allowExternalPatch === true + const expectedCode = + typeof endpoint.code === 'string' && endpoint.code.length > 0 + ? endpoint.code + : 'CAPYBARA' + const providedCode = + url.searchParams.get('code') || + req.headers.get('x-nodelink-code') || + req.headers.get('x-worker-code') + + if (!patchEnabled) { + return new Response('Profiler socket endpoint is disabled.', { + status: 403, + statusText: 'Forbidden' + }) + } + if (!allowExternalPatch && !isInternal) { + return new Response('External profiler socket access is blocked.', { + status: 403, + statusText: 'Forbidden' + }) + } + if (!providedCode || providedCode !== expectedCode) { + return new Response('Invalid or missing profiler code.', { + status: 403, + statusText: 'Forbidden' + }) + } + + const success = server.upgrade(req, { + data: { + clientInfo: { name: 'ProfilerUI', version: '1' }, + sessionId: null, + reqHeaders: Object.fromEntries(req.headers), + remoteAddress, + url: req.url, + pathname, + eventName: '/v4/profiler/socket', + routeId: null + } + }) + + if (success) return undefined + return new Response('WebSocket upgrade failed', { status: 400 }) + } + + const voiceMatch = pathname.match(VOICE_PATH_RE) + const liveMatch = pathname.match(LIVE_PATH_RE) + const isMainWs = pathname === '/v4/websocket' + + if (isMainWs || voiceMatch || liveMatch) { + const remoteAddress = server.requestIP(req)?.address || 'unknown' + const clientAddress = `[External] (${remoteAddress})` + + const clientName = req.headers.get('client-name') + const auth = req.headers.get('authorization') + const userId = req.headers.get('user-id') + let sessionId = req.headers.get('session-id') + + if (auth !== password) { + logger( + 'warn', + 'Server', + `Unauthorized connection attempt from ${clientAddress} - Invalid password provided: ${auth || 'None'}` + ) + return new Response('Invalid password provided.', { + status: 401, + statusText: 'Unauthorized', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }) + } + + if (!clientName) { + logger('warn', 'Server', `Missing client-name from ${clientAddress}`) + return new Response('Invalid or missing Client-Name header.', { + status: 400, + statusText: 'Bad Request', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }) + } + + if (!userId || !verifyDiscordID(userId)) { + logger('warn', 'Server', `Invalid user ID from ${clientAddress}`) + return new Response('Invalid or missing User-Id header.', { + status: 400, + statusText: 'Bad Request', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }) + } + + const clientInfo = parseClient(clientName) as ClientInfo | null + if (!clientInfo) { + logger('warn', 'Server', `Invalid client-name from ${clientAddress}`) + return new Response('Invalid or missing Client-Name header.', { + status: 400, + statusText: 'Bad Request', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }) + } + + let eventName = '/v4/websocket' + let routeId: string | null = null + if (voiceMatch) { + if (!context.options.playback.voiceReceive?.enabled) { + return new Response('Voice receive disabled.', { + status: 404, + statusText: 'Not Found', + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }) + } + eventName = '/v4/websocket/voice' + routeId = voiceMatch[1] ?? null + } else if (liveMatch) { + eventName = '/v4/websocket/youtube/live' + routeId = liveMatch[1] ?? null + } + + if (sessionId && !context.sessions.resumableSessions.has(sessionId)) { + logger( + 'warn', + 'Server', + `Session-ID provided by ${clientAddress} does not exist or is not resumable: ${sessionId}, creating a new session` + ) + sessionId = null + } + + const success = server.upgrade(req, { + data: { + clientInfo, + sessionId, + reqHeaders: Object.fromEntries(req.headers), + remoteAddress, + url: req.url, + pathname, + eventName, + routeId + } + }) + + if (success) return undefined + return new Response('WebSocket upgrade failed', { + status: 400, + headers: { + 'Nodelink-Api-Version': '4', + IamNodelink: 'true' + } + }) + } + + return new Promise((resolve) => { + const dataListeners: Array<(data: Buffer) => void> = [] + const endListeners: Array<() => void> = [] + const errorListeners: Array<(err: Error) => void> = [] + let bodyTriggered = false + + const triggerBodyRead = () => { + if (bodyTriggered) return + bodyTriggered = true + + const hasBody = + req.headers.get('content-length') || + req.headers.get('transfer-encoding') + if (!hasBody && (req.method === 'GET' || req.method === 'HEAD')) { + queueMicrotask(() => { + for (const cb of endListeners) { + try { + cb() + } catch (e) { + logger( + 'debug', + 'Server', + `Bun reqShim end listener threw: ${(e as Error).message}` + ) + } + } + }) + return + } + + req + .arrayBuffer() + .then((buf: ArrayBuffer) => { + const chunk = Buffer.from(buf) + if (chunk.length > 0) { + for (const cb of dataListeners) { + try { + cb(chunk) + } catch (e) { + logger( + 'debug', + 'Server', + `Bun reqShim data listener threw: ${(e as Error).message}` + ) + } + } + } + for (const cb of endListeners) { + try { + cb() + } catch (e) { + logger( + 'debug', + 'Server', + `Bun reqShim end listener threw: ${(e as Error).message}` + ) + } + } + }) + .catch((err: unknown) => { + const error = err instanceof Error ? err : new Error(String(err)) + if (errorListeners.length > 0) { + for (const cb of errorListeners) { + try { + cb(error) + } catch {} + } + } else { + logger( + 'debug', + 'Server', + `Bun request body read failed: ${error.message}` + ) + for (const cb of endListeners) { + try { + cb() + } catch {} + } + } + }) + } + + const reqShim: RequestShim = { + method: req.method, + url: url.pathname + url.search, + headers: Object.fromEntries(req.headers), + socket: { remoteAddress: server.requestIP(req)?.address }, + on: (event: string, cb: (data: Buffer) => void) => { + if (event === 'data') { + dataListeners.push(cb) + triggerBodyRead() + } else if (event === 'end') { + endListeners.push(cb as unknown as () => void) + triggerBodyRead() + } else if (event === 'error') { + errorListeners.push(cb as unknown as (err: Error) => void) + } + } + } + + const resShim: ResponseShim = { + _status: 200, + _headers: {}, + _body: [], + writeHead( + status: number, + headers?: Record + ) { + this._status = status + if (headers) Object.assign(this._headers, headers) + }, + setHeader(name: string, value: string | string[]) { + this._headers[name] = value + }, + getHeader(name: string) { + return this._headers[name] as string | string[] | undefined + }, + end(data?: string | Buffer) { + if (data) this._body.push(data) + let finalBody: Buffer | string + if (this._body.length === 0) { + finalBody = '' + } else if ( + this._body.length === 1 && + Buffer.isBuffer(this._body[0]) + ) { + finalBody = this._body[0] as Buffer + } else { + finalBody = Buffer.concat( + this._body.map((chunk) => + Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk) + ) + ) + } + + const headers = new Headers() + for (const [key, value] of Object.entries(this._headers)) { + if (Array.isArray(value)) { + for (const v of value) headers.append(key, v) + } else if (value !== undefined) { + headers.set(key, String(value)) + } + } + + const response = new Response(finalBody, { + status: this._status, + headers + }) + resolve(response) + }, + write(data: string | Buffer) { + if (data) this._body.push(data) + } + } + + void getRequestHandler() + .then((handler) => + handler( + context as unknown as import('../typings/api/api.types.ts').ApiNodelinkServer, + reqShim as unknown as RequestShim, + resShim + ) + ) + .catch((error: Error) => { + logger( + 'error', + 'Server', + `Failed to handle Bun request: ${error.message}` + ) + if (!resShim._status || resShim._status < 400) { + resShim.writeHead(500, { 'Content-Type': 'text/plain' }) + } + resShim.end('Internal Server Error') + }) + }) + }, + + websocket: { + sendPings: true, + idleTimeout: 120, + maxPayloadLength: 1024 * 1024 * 16, + data: {} as BunSocketData, + open(ws) { + if (!ws.data) { + try { + ws.close(1011, 'Missing socket data') + } catch {} + return + } + const wrapper = new BunSocketWrapper(ws) + ws.data.wrapper = wrapper + + const { + clientInfo, + sessionId, + reqHeaders, + pathname, + eventName, + routeId + } = ws.data + + const reqShim: ReqShim = { + headers: reqHeaders as Record, + url: ws.data.url, + socket: { remoteAddress: ws.data.remoteAddress } + } + + if (pathname === '/v4/profiler/socket') { + logger( + 'info', + 'ProfilerSocket', + `Profiler socket connected from [External] (${ws.data.remoteAddress})` + ) + context.socket?.emit( + '/v4/profiler/socket', + wrapper, + reqShim, + null, + null + ) + return + } + + logger( + 'info', + 'Server', + `\x1b[36m${clientInfo.name}\x1b[0m${ + clientInfo.version ? `/\x1b[32mv${clientInfo.version}\x1b[0m` : '' + } connected from [External] (${ws.data.remoteAddress}) | \x1b[33mURL:\x1b[0m ${ws.data.url}` + ) + + if (context.socket) { + context.socket.emit( + eventName ?? '/v4/websocket', + wrapper, + reqShim, + clientInfo, + sessionId, + routeId ?? null + ) + } + }, + message(ws: ServerWebSocket, message: string | Buffer) { + const wrapper = ws.data?.wrapper + if (!wrapper) { + logger( + 'debug', + 'WebSocket', + `Bun message received without wrapper (remote: ${ws.data?.remoteAddress || 'unknown'})` + ) + return + } + wrapper._handleMessage(message) + }, + close(ws: ServerWebSocket, code: number, reason: string) { + const wrapper = ws.data?.wrapper + if (!wrapper) { + logger( + 'debug', + 'WebSocket', + `Bun close received without wrapper (code: ${code}, remote: ${ws.data?.remoteAddress || 'unknown'})` + ) + return + } + wrapper._handleClose(code, reason) + }, + // `error` is documented in Bun.serve docs but missing from + // bun-types@1.3.14 typings; cast keeps runtime behaviour while + // satisfying the type checker. + ...({ + error(ws: ServerWebSocket, err: Error) { + logger( + 'error', + 'WebSocket', + `Bun WebSocket error from ${ws.data?.remoteAddress || 'unknown'}: ${err.message}` + ) + const wrapper = ws.data?.wrapper + if (wrapper && wrapper.listenerCount('error') > 0) { + try { + wrapper.emit('error', err) + } catch {} + } + } + } as Record) + } + }) + + logger( + 'started', + 'Server', + `Successfully listening on ${host}:${port} (Bun Native)` + ) + + return server +} + +/** + * Cleans up Bun WebSocket server resources + * @param context - Server context + * @param server - The Bun server instance to clean up + * @internal + */ +export async function cleanupBunServer( + context: BunServerContext, + server: { stop: (force?: boolean) => Promise; unref: () => void } +): Promise { + try { + logger('info', 'WebSocket', 'Stopping Bun server...') + + // Gracefully close every active session with the same code Node uses, + // so clients see a clean 1000 close frame and reconnect normally. + // Without this, Bun.stop(true) tears TCP connections down without + // sending close frames, surfacing as ECONNRESET on the client. + let closedCount = 0 + for (const session of context.sessions.activeSessions.values()) { + if (!session.socket) continue + try { + session.socket.close(1000, 'Server shutdown') + closedCount++ + } catch (_e) { + try { + ;(session.socket as SessionSocket).destroy?.() + } catch (_destroyErr) { + logger( + 'debug', + 'WebSocket', + `Failed to close/destroy socket for session ${session.id}` + ) + } + } + } + context.sessions.activeSessions.clear() + context.sessions.resumableSessions.clear() + logger( + 'info', + 'WebSocket', + `Signalled close to ${closedCount} WebSocket connection(s)` + ) + + // Prefer graceful stop so the close frames above flush. If clients + // don't drain within 1.5s (slow networks, half-open peers), fall + // back to force-stop so shutdown still completes promptly. + await new Promise((resolveStop) => { + let settled = false + const finish = () => { + if (settled) return + settled = true + resolveStop() + } + + const forceTimer = setTimeout(() => { + server.stop(true).then(finish, finish) + }, 1500) + + server.stop(false).then( + () => { + clearTimeout(forceTimer) + finish() + }, + () => { + clearTimeout(forceTimer) + server.stop(true).then(finish, finish) + } + ) + }) + + try { + server.unref() + } catch {} + logger('info', 'WebSocket', 'Bun server stopped successfully') + } catch (e) { + const error = e as Error + logger( + 'error', + 'WebSocket', + `Error stopping Bun server: ${error?.message ?? String(e)}` + ) + } +} diff --git a/src/sources/amazonmusic.ts b/src/sources/amazonmusic.ts index 87f61754..703e4adf 100644 --- a/src/sources/amazonmusic.ts +++ b/src/sources/amazonmusic.ts @@ -295,13 +295,15 @@ export default class AmazonMusicSource implements SourceInstance { 'x-amzn-device-language': 'en_US', 'x-amzn-currency-of-preference': 'USD', 'x-amzn-os-version': '1.0', - 'x-amzn-application-version': '1.0.9172.0', + 'x-amzn-application-version': '1.0.10905.0', 'x-amzn-device-time-zone': 'America/New_York', 'x-amzn-timestamp': String(Date.now()), 'x-amzn-csrf': this.buildCsrfHeader(cfg.csrf), 'x-amzn-music-domain': 'music.amazon.com', 'x-amzn-page-url': pageUrl, - 'x-amzn-feature-flags': 'hd-supported,uhd-supported' + 'x-amzn-feature-flags': 'hd-supported,uhd-supported', + 'x-amnz-age-band': 'ADULT', + 'x-amzn-has-profile-id': 'true', } } diff --git a/src/sources/applemusic.ts b/src/sources/applemusic.ts index a4fb68d0..a302a4d0 100644 --- a/src/sources/applemusic.ts +++ b/src/sources/applemusic.ts @@ -373,7 +373,7 @@ export default class AppleMusicSource implements SourceInstance { searchType = 'track' ): Promise { try { - const limit = (this.nodelink.options.maxSearchResults as number) || 10 + const limit = (this.nodelink.options.search.maxResults as number) || 10 const typeMap: Record = { track: 'songs', album: 'albums', diff --git a/src/sources/audius.ts b/src/sources/audius.ts index 5d24cbf1..0b1219b6 100644 --- a/src/sources/audius.ts +++ b/src/sources/audius.ts @@ -251,7 +251,7 @@ export default class AudiusSource implements SourceInstance { */ public async search(query: string): Promise { try { - const limit = this.nodelink.options.maxSearchResults || 10 + const limit = this.nodelink.options.search.maxResults || 10 const endpoint = `/v1/tracks/search?query=${encodeURIComponent(query)}&limit=${limit}` const data = await this._apiRequest(endpoint) diff --git a/src/sources/bandcamp.ts b/src/sources/bandcamp.ts index 77e295b8..5c9b220b 100644 --- a/src/sources/bandcamp.ts +++ b/src/sources/bandcamp.ts @@ -1,6 +1,15 @@ -import { PassThrough } from 'node:stream' +import { PassThrough, pipeline } from 'node:stream' import type { + BandcampApiSearchResponse, + BandcampJsonLdData, + BandcampTrackBuildInput, + BandcampTralbumData, + BandcampTralbumTrack +} from '../typings/sources/bandcamp.types.ts' +import type { + PlaylistData, SourceResult, + TrackData, TrackInfo, TrackStreamResult, TrackUrlResult, @@ -13,252 +22,13 @@ import type { import { encodeTrack, logger, makeRequest } from '../utils.ts' const BANDCAMP_BASE_URL = 'https://bandcamp.com' +const BANDCAMP_SEARCH_API_URL = `${BANDCAMP_BASE_URL}/api/bcsearch_public_api/1/autocomplete_elastic` const BANDCAMP_TRACK_PATTERN = /^https?:\/\/([^/]+)\.bandcamp\.com\/(track|album)\/([^/?]+)/ -const SEARCH_RESULT_REGEX = - /
  • /g -const SEARCH_URL_REGEX = // -const SEARCH_TITLE_REGEX = /
    \s*]*>\s*(.+?)\s*<\/a>/ -const SEARCH_SUBHEAD_REGEX = /
    ([\s\S]*?)<\/div>/ -const SEARCH_ARTWORK_REGEX = /
    \s* -} - -/** - * Playlist payload returned when an album resolves to multiple tracks. - */ -interface BandcampPlaylistData { - /** - * Playlist metadata shown to the client. - */ - info: { - /** - * Album title. - */ - name: string - - /** - * Index of the selected track. - */ - selectedTrack: number - } - - /** - * Source-specific playlist metadata. - */ - pluginInfo: Record - - /** - * Encoded tracks that belong to the album. - */ - tracks: BandcampTrackData[] -} - -/** - * Direct playback URL descriptor returned by Bandcamp. - */ -interface BandcampTrackUrlSuccess extends TrackUrlResult { - /** - * Final MP3 stream URL extracted from the page. - */ - url: string - - /** - * Bandcamp playback is resolved as HTTPS. - */ - protocol: 'https' - - /** - * Bandcamp stream format used by this extractor. - */ - format: 'mp3' -} +const _STREAM_URL_REGEX = /https?:\/\/t4\.bcbits\.com\/stream\/[^"'\\&\s]+/ +const TRALBUM_REGEX = /data-tralbum="([^"]*(?:"[^"]*)*?)"/ +const JSON_LD_REGEX = + /([\s\S]*?)<\/script>/ /** * Bandcamp source implementation. @@ -319,17 +89,28 @@ export default class BandcampSource { } /** - * Searches Bandcamp track results for a plain-text query. + * Searches Bandcamp track results using the internal JSON search API. + * + * The previous HTML-scraping approach broke because `bandcamp.com/search` + * now returns a client-challenge page that requires JavaScript. The + * internal autocomplete API used by the Bandcamp frontend returns + * structured JSON and does not require authentication. * * @param query Search string received from the API or unified search flow. * @returns Search results, an empty payload, or a structured exception. */ public async search(query: string): Promise { try { - const request = await makeRequest( - `${this.baseUrl}/search?q=${encodeURIComponent(query)}&item_type=t&from=results`, - { method: 'GET' } - ) + const request = await makeRequest(BANDCAMP_SEARCH_API_URL, { + method: 'POST', + disableBodyCompression: true, + body: { + search_text: query, + search_filter: 't', + full_page: true, + fan_id: null + } + }) if (request.error || request.statusCode !== 200) { return { @@ -337,25 +118,16 @@ export default class BandcampSource { exception: { message: request.error ?? - `BandCamp returned an invalid status: ${request.statusCode}`, + `BandCamp search API returned status ${request.statusCode}.`, severity: 'fault', cause: 'Request Failed' } } } - const body = this.getResponseText(request) - if (body === null) { - return this.createSourceException( - 'BandCamp search returned an unreadable response body.', - 'fault', - 'Invalid Response' - ) - } - - const resultBlocks = body.match(SEARCH_RESULT_REGEX) + const response = this.getJsonBody(request.body) - if (!resultBlocks || resultBlocks.length === 0) { + if (!response?.auto?.results || response.auto.results.length === 0) { logger( 'debug', 'Sources', @@ -364,16 +136,25 @@ export default class BandcampSource { return { loadType: 'empty', data: {} } } - const tracks: BandcampTrackData[] = [] + const tracks: TrackData[] = [] const maxResults = this.getMaxSearchResults() - for (const block of resultBlocks) { + for (const item of response.auto.results) { if (tracks.length >= maxResults) break - const result = this.parseSearchResult(block) - if (!result) continue - - tracks.push(this.buildTrack(result)) + if (!item.name || !item.item_url_path) continue + + tracks.push( + this.buildTrack({ + identifier: item.id != null ? String(item.id) : null, + title: item.name, + author: item.band_name || null, + uri: item.item_url_path, + artworkUrl: item.art_id + ? this.createArtworkUrl(item.art_id) + : (item.img ?? null) + }) + ) } if (tracks.length === 0) { @@ -403,13 +184,23 @@ export default class BandcampSource { /** * Resolves a Bandcamp track or album URL into a track or playlist payload. * + * Uses `data-tralbum` as the primary metadata source and enriches with + * JSON-LD structured data (ISRC, duration, artwork) when available. + * * @param url Canonical Bandcamp URL to resolve. * @returns A track, playlist, empty result, or a structured exception. */ public async resolve(url: string): Promise { try { - const tralbumData = await this.extractTralbumData(url) - if (!tralbumData?.trackinfo || tralbumData.trackinfo.length === 0) { + const pageData = await this.fetchPageData(url) + if (!pageData) { + logger('warn', 'Sources', `Failed to fetch BandCamp page for: ${url}`) + return { loadType: 'empty', data: {} } + } + + const { tralbum, jsonLd } = pageData + + if (!tralbum?.trackinfo || tralbum.trackinfo.length === 0) { logger( 'warn', 'Sources', @@ -418,13 +209,19 @@ export default class BandcampSource { return { loadType: 'empty', data: {} } } - const artworkUrl = this.createArtworkUrl(tralbumData.art_id) - const author = this.normalizeText(tralbumData.artist) ?? 'Unknown Artist' + const artworkUrl = + this.createArtworkUrl(tralbum.art_id) ?? + (typeof jsonLd?.image === 'string' ? jsonLd.image : null) + const author = + this.normalizeText(tralbum.artist) ?? + this.normalizeText(jsonLd?.byArtist?.name) ?? + 'Unknown Artist' + const pageIsrc = tralbum.current?.isrc ?? jsonLd?.isrcCode ?? null - if (tralbumData.trackinfo.length > 1) { - const tracks: BandcampTrackData[] = [] + if (tralbum.trackinfo.length > 1) { + const tracks: TrackData[] = [] - for (const item of tralbumData.trackinfo) { + for (const item of tralbum.trackinfo) { const trackUrl = item.title_link ? this.buildAbsoluteTrackUrl(item.title_link, url) : null @@ -449,11 +246,10 @@ export default class BandcampSource { return { loadType: 'empty', data: {} } } - const playlist: BandcampPlaylistData = { + const playlist: PlaylistData = { info: { name: - this.normalizeText(tralbumData.current?.title) ?? - 'BandCamp Playlist', + this.normalizeText(tralbum.current?.title) ?? 'BandCamp Playlist', selectedTrack: 0 }, pluginInfo: {} as Record, @@ -463,7 +259,7 @@ export default class BandcampSource { return { loadType: 'playlist', data: playlist } } - const trackData = tralbumData.trackinfo[0] + const trackData = tralbum.trackinfo[0] if (!trackData) { return { loadType: 'empty', data: {} } } @@ -472,11 +268,14 @@ export default class BandcampSource { identifier: this.getTrackIdentifier(trackData, url), isSeekable: true, author, - length: this.toDurationMilliseconds(trackData.duration), + length: + this.toDurationMilliseconds(trackData.duration) ?? + this.parseIsoDuration(jsonLd?.duration), isStream: false, title: this.normalizeText(trackData.title), uri: url, - artworkUrl + artworkUrl, + isrc: pageIsrc }) return { loadType: 'track', data: track } @@ -492,12 +291,20 @@ export default class BandcampSource { /** * Extracts the direct Bandcamp MP3 stream URL from a track page. * + * When possible, the stream URL is extracted directly from the + * `data-tralbum` payload to avoid an additional HTTP round-trip. + * Falls back to a regex scan of the full page body when the structured + * extraction does not yield a URL. + * * @param track Decoded track information produced by the source manager. * @returns A direct stream URL descriptor or a structured exception. */ public async getTrackUrl( track: TrackInfo - ): Promise { + ): Promise< + | (TrackUrlResult & { url: string; protocol: 'https'; format: 'mp3' }) + | SourceResult + > { try { const { body, error, statusCode } = await makeRequest(track.uri, { method: 'GET' @@ -526,9 +333,10 @@ export default class BandcampSource { } } - const streamUrlMatch = page.match(STREAM_URL_REGEX) + // Try extracting stream URL from the structured tralbum data first. + const streamUrl = this.extractStreamUrlFromPage(page, track.identifier) - if (!streamUrlMatch) { + if (!streamUrl) { return { loadType: 'error', exception: { @@ -540,7 +348,7 @@ export default class BandcampSource { } return { - url: this.decodeHtmlEntities(streamUrlMatch[0]), + url: streamUrl, protocol: 'https', format: 'mp3' } @@ -579,7 +387,10 @@ export default class BandcampSource { try { const response = await makeRequest(url, { method: 'GET', - streamOnly: true + streamOnly: true, + headers: { + Referer: decodedTrack.uri + } }) if (response.error || response.statusCode !== 200 || !response.stream) { @@ -596,7 +407,22 @@ export default class BandcampSource { } const stream = new PassThrough() - response.stream.pipe(stream) + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() + }) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error && error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger( + 'error', + 'Sources', + `BandCamp stream error: ${error.message}` + ) + } + } + ) return { stream } } catch (error) { @@ -620,14 +446,16 @@ export default class BandcampSource { } /** - * Fetches and parses the `data-tralbum` payload from a Bandcamp page. + * Fetches a Bandcamp page and extracts both `data-tralbum` and JSON-LD data. * * @param url Bandcamp track or album URL. - * @returns Parsed `data-tralbum` content or `null` when extraction fails. + * @returns Parsed page metadata or `null` when extraction fails. */ - public async extractTralbumData( - url: string - ): Promise { + public async fetchPageData(url: string): Promise<{ + tralbum: BandcampTralbumData | null + jsonLd: BandcampJsonLdData | null + rawPage: string + } | null> { const { body, error, statusCode } = await makeRequest(url, { method: 'GET' }) @@ -644,20 +472,10 @@ export default class BandcampSource { const page = this.getResponseText({ body }) if (page === null) return null - const match = page.match(TRALBUM_REGEX) - if (!match?.[2]) return null + const tralbum = this.parseTralbumFromPage(page) + const jsonLd = this.parseJsonLdFromPage(page) - try { - const decodedString = this.decodeHtmlEntities(match[2]) - return JSON.parse(decodedString) as BandcampTralbumData - } catch (error) { - logger( - 'warn', - 'Sources', - `Failed to parse BandCamp tralbum payload for ${url}: ${error instanceof Error ? error.message : 'invalid JSON'}` - ) - return null - } + return { tralbum, jsonLd, rawPage: page } } /** @@ -666,8 +484,8 @@ export default class BandcampSource { * @param partialInfo Track fields collected from search or page resolution. * @returns An encoded track entry compatible with the source manager. */ - public buildTrack(partialInfo: BandcampTrackBuildInput): BandcampTrackData { - const track: BandcampTrackInfo = { + public buildTrack(partialInfo: BandcampTrackBuildInput): TrackData { + const track: TrackEncodeInput & TrackInfo = { identifier: partialInfo.identifier?.trim() || this.getIdentifierFromUrl(partialInfo.uri), @@ -679,7 +497,7 @@ export default class BandcampSource { title: partialInfo.title?.trim() || 'Unknown Title', uri: partialInfo.uri, artworkUrl: partialInfo.artworkUrl, - isrc: null, + isrc: partialInfo.isrc ?? null, sourceName: 'bandcamp', details: [] } @@ -703,42 +521,80 @@ export default class BandcampSource { } /** - * Extracts a usable search result from a raw Bandcamp HTML block. + * Parses the `data-tralbum` JSON payload from a Bandcamp page body. * - * @param block Raw HTML fragment for a single search result entry. - * @returns Parsed search metadata or `null` when the entry is incomplete. + * @param page Full HTML page body. + * @returns Parsed tralbum data, or `null` when not found or invalid. */ - private parseSearchResult(block: string): BandcampSearchResult | null { - const urlMatch = block.match(SEARCH_URL_REGEX) - const titleMatch = block.match(SEARCH_TITLE_REGEX) - const subheadMatch = block.match(SEARCH_SUBHEAD_REGEX) - const artworkMatch = block.match(SEARCH_ARTWORK_REGEX) + private parseTralbumFromPage(page: string): BandcampTralbumData | null { + const match = page.match(TRALBUM_REGEX) + if (!match?.[1]) return null - if (!titleMatch?.[1] || !subheadMatch?.[1] || !urlMatch?.[1]) { + try { + const decoded = this.decodeHtmlEntities(match[1]) + return JSON.parse(decoded) as BandcampTralbumData + } catch (error) { + logger( + 'warn', + 'Sources', + `Failed to parse BandCamp tralbum payload: ${error instanceof Error ? error.message : 'invalid JSON'}` + ) return null } + } - const rawTitle = titleMatch[1] - const rawSubhead = subheadMatch[1] - const rawUri = urlMatch[1] - const title = this.normalizeText(this.stripHtml(rawTitle)) - const fullSubhead = this.normalizeText(this.stripHtml(rawSubhead)) - const uri = rawUri.split('?')[0] + /** + * Parses the JSON-LD `MusicRecording` block from a Bandcamp page body. + * + * @param page Full HTML page body. + * @returns Parsed JSON-LD data, or `null` when not found or invalid. + */ + private parseJsonLdFromPage(page: string): BandcampJsonLdData | null { + const match = page.match(JSON_LD_REGEX) + if (!match?.[1]) return null - if (!title || !fullSubhead || !uri) { + try { + return JSON.parse(match[1].trim()) as BandcampJsonLdData + } catch { return null } + } - const artistSegments = fullSubhead.split(' de ') - const author = - artistSegments[artistSegments.length - 1]?.trim() || 'Unknown Artist' - - return { - title, - author, - uri, - artworkUrl: artworkMatch?.[1] ?? null + /** + * Extracts the MP3 stream URL from a Bandcamp page body. + * + * Tries the structured `data-tralbum` `trackinfo[].file["mp3-128"]` field + * first, then falls back to a regex scan for a `t4.bcbits.com/stream` URL. + */ + private extractStreamUrlFromPage( + page: string, + trackId?: string + ): string | null { + // Try structured extraction from tralbum first. + const tralbum = this.parseTralbumFromPage(page) + if (tralbum?.trackinfo) { + // Find the specific track if an ID is provided, otherwise default to the first + const trackData = trackId + ? tralbum.trackinfo.find( + (t) => String(t.track_id) === trackId || String(t.id) === trackId + ) || tralbum.trackinfo[0] + : tralbum.trackinfo[0] + + if (trackData?.file) { + const mp3Url = trackData.file['mp3-128'] + if (mp3Url) { + return this.decodeHtmlEntities(mp3Url) + } + } } + + // Fallback: regex scan of the full page. + const decodedPage = this.decodeHtmlEntities(page) + // Fix: The regex must allow `&` to capture the token parameters. + const streamUrlMatch = decodedPage.match( + /https?:\/\/t4\.bcbits\.com\/stream\/[^"'\s]+/ + ) + return streamUrlMatch ? streamUrlMatch[0] : null } /** @@ -762,8 +618,37 @@ export default class BandcampSource { } /** - * Decodes the small subset of HTML entities used by the Bandcamp pages this - * source parses. + * Safely parses a JSON body from an HTTP response. + * + * @param body Raw response body from the HTTP helper. + * @returns The parsed JSON object, or `null` when parsing fails. + */ + private getJsonBody(body: HttpRequestResult['body']): T | null { + if ( + body !== null && + body !== undefined && + typeof body === 'object' && + !Buffer.isBuffer(body) + ) { + return body as T + } + + const text = this.getResponseText({ body }) + if (text === null) return null + + try { + return JSON.parse(text) as T + } catch { + return null + } + } + + /** + * Decodes HTML entities commonly found in Bandcamp page attributes and + * JSON payloads embedded in HTML. + * + * Handles named entities, decimal numeric entities, and hexadecimal + * numeric entities. * * @param value Raw HTML fragment or encoded attribute value. * @returns A decoded string safe to use in URLs and titles. @@ -773,20 +658,16 @@ export default class BandcampSource { .replaceAll('"', '"') .replaceAll('"', '"') .replaceAll(''', "'") + .replaceAll(''', "'") .replaceAll(''', "'") - .replaceAll('&', '&') .replaceAll('<', '<') .replaceAll('>', '>') - } - - /** - * Removes HTML tags from a fragment extracted from the Bandcamp search page. - * - * @param value Raw HTML fragment. - * @returns Plain-text content with tags removed. - */ - private stripHtml(value: string): string { - return value.replace(/<[^>]+>/g, ' ') + .replaceAll(' ', ' ') + .replaceAll('&', '&') + .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => + String.fromCharCode(parseInt(hex, 16)) + ) + .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10))) } /** @@ -814,13 +695,39 @@ export default class BandcampSource { return durationSeconds ? Math.round(durationSeconds * 1000) : -1 } + /** + * Parses an ISO 8601 duration string into milliseconds. + * + * Handles the `P00H05M20S` format used by Bandcamp's JSON-LD. + * + * @param iso ISO 8601 duration string. + * @returns Duration in milliseconds, or `-1` when parsing fails. + */ + private parseIsoDuration(iso?: string | null): number { + if (!iso) return -1 + + const match = iso.match( + /P(?:(\d+)D)?(?:T)?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?/ + ) + if (!match) return -1 + + const days = parseInt(match[1] || '0', 10) + const hours = parseInt(match[2] || '0', 10) + const minutes = parseInt(match[3] || '0', 10) + const seconds = parseFloat(match[4] || '0') + + return Math.round( + (days * 86400 + hours * 3600 + minutes * 60 + seconds) * 1000 + ) + } + /** * Builds the public Bandcamp artwork URL from an `art_id` value. * * @param artId Artwork identifier exposed by `data-tralbum`. * @returns The public image URL or `null` when no artwork exists. */ - private createArtworkUrl(artId?: string | number): string | null { + private createArtworkUrl(artId?: string | number | null): string | null { if (artId === undefined || artId === null || artId === '') { return null } @@ -869,8 +776,8 @@ export default class BandcampSource { * @returns A positive integer limit used when parsing search results. */ private getMaxSearchResults(): number { - const options = this.nodelink.options as BandcampRuntimeOptions - const limit = options.maxSearchResults + const options = this.nodelink.options + const limit = options.search.maxResults return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit diff --git a/src/sources/bilibili.ts b/src/sources/bilibili.ts index 6da285a4..90e1a854 100644 --- a/src/sources/bilibili.ts +++ b/src/sources/bilibili.ts @@ -210,7 +210,7 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -302,7 +302,7 @@ export default class BilibiliSource implements SourceInstance { Cookie: cookie, Referer: 'https://search.bilibili.com/' }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) body = searchResponse.body as BilibiliApiResponse @@ -322,7 +322,7 @@ export default class BilibiliSource implements SourceInstance { Cookie: cookie, Referer: 'https://search.bilibili.com/' }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) body = allSearchResponse.body as BilibiliApiResponse @@ -350,7 +350,7 @@ export default class BilibiliSource implements SourceInstance { } const tracks: TrackData[] = [] - const limit = (this.nodelink.options.maxSearchResults as number) || 10 + const limit = (this.nodelink.options.search.maxResults as number) || 10 for (const item of videos.slice(0, limit)) { const durationParts = String(item.duration || '0:0') @@ -412,7 +412,7 @@ export default class BilibiliSource implements SourceInstance { headers: HEADERS, maxRedirects: 3, timeout: 5000, - proxy: this.config.proxy + proxy: this.config.network?.proxy }) if (typeof res.body === 'string') { @@ -592,14 +592,14 @@ export default class BilibiliSource implements SourceInstance { const res = await makeRequest(apiUrl, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }) const body = res.body as | BilibiliApiResponse | undefined - if (!body || body.code !== 0) { + if (body?.code !== 0) { throw new Error(`API Error: ${body?.message || 'Video not found'}`) } @@ -635,14 +635,14 @@ export default class BilibiliSource implements SourceInstance { const res = await makeRequest(apiUrl, { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy }) const body = res.body as | BilibiliApiResponse | undefined - if (!body || body.code !== 0) + if (body?.code !== 0) throw new Error(`Bangumi API Error: ${body?.message}`) const result = body.result @@ -710,7 +710,7 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -718,8 +718,7 @@ export default class BilibiliSource implements SourceInstance { | BilibiliApiResponse | undefined - if (!body || body.code !== 0) - throw new Error(`Audio API Error: ${body?.msg}`) + if (body?.code !== 0) throw new Error(`Audio API Error: ${body?.msg}`) const data = body.data if (!data) throw new Error('No data returned from audio API.') @@ -752,7 +751,7 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -760,7 +759,7 @@ export default class BilibiliSource implements SourceInstance { | BilibiliApiResponse<{ data: BilibiliAudioData[] }> | undefined - if (!albumRes || albumRes.code !== 0) + if (albumRes?.code !== 0) throw new Error(`Album API Error: ${albumRes?.msg}`) const tracks: TrackData[] = (albumRes.data?.data || []).map( @@ -791,7 +790,7 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -827,7 +826,7 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -840,8 +839,7 @@ export default class BilibiliSource implements SourceInstance { }> | undefined - if (!body || body.code !== 0) - throw new Error(`Live API Error: ${body?.msg}`) + if (body?.code !== 0) throw new Error(`Live API Error: ${body?.msg}`) if (body.data?.live_status !== 1) throw new Error('Room is not live.') const data = body.data @@ -891,7 +889,7 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -901,7 +899,7 @@ export default class BilibiliSource implements SourceInstance { }> | undefined - if (!body || body.code !== 0) + if (body?.code !== 0) throw new Error(`Space API Error: ${body?.message}`) const list = body.data?.list?.vlist @@ -986,13 +984,13 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) const body = res.body as | BilibiliApiResponse<{ cdns: string[] }> | undefined - if (!body || body.code !== 0 || !body.data?.cdns?.[0]) { + if (body?.code !== 0 || !body.data?.cdns?.[0]) { throw new Error('Failed to get audio stream.') } @@ -1011,15 +1009,14 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) const body = res.body as BilibiliApiResponse | undefined if ( - !body || - body.code !== 0 || + body?.code !== 0 || !(body.data as { playurl_info?: unknown })?.playurl_info ) { throw new Error('Failed to get live stream info.') @@ -1107,13 +1104,13 @@ export default class BilibiliSource implements SourceInstance { { method: 'GET', headers: { ...HEADERS, Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) const body = res.body as | BilibiliApiResponse | undefined - if (!body || body.code !== 0 || !body.data) { + if (body?.code !== 0 || !body.data) { throw new Error('Failed to fetch video metadata for stream.') } @@ -1138,7 +1135,7 @@ export default class BilibiliSource implements SourceInstance { Referer: 'https://www.bilibili.com/', Cookie: this.buildCookieHeader() }, - proxy: this.config.proxy + proxy: this.config.network?.proxy } ) @@ -1146,7 +1143,7 @@ export default class BilibiliSource implements SourceInstance { | BilibiliApiResponse | undefined - if (!body || body.code !== 0 || !body.data) { + if (body?.code !== 0 || !body.data) { throw new Error(`Playurl API Error: ${body?.message}`) } @@ -1218,7 +1215,7 @@ export default class BilibiliSource implements SourceInstance { type: 'mpegts', localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, startTime: (additionalData?.startTime as number) || 0, - proxy: this.config.proxy + proxy: this.config.network?.proxy }), type: 'mpegts' } @@ -1228,7 +1225,7 @@ export default class BilibiliSource implements SourceInstance { method: 'GET', headers, streamOnly: true, - proxy: this.config.proxy + proxy: this.config.network?.proxy }) if (res.error || !res.stream) diff --git a/src/sources/bluesky.ts b/src/sources/bluesky.ts index 9b962b47..31161f4d 100644 --- a/src/sources/bluesky.ts +++ b/src/sources/bluesky.ts @@ -36,16 +36,6 @@ interface BlueskySourceConfig { maxSearchResults?: number } -/** - * Runtime options subset read by the Bluesky source. - */ -interface BlueskyRuntimeOptions { - /** - * Global search-result limit used by several sources. - */ - maxSearchResults?: number -} - /** * Service entry returned by a DID document or PLC directory response. */ @@ -317,13 +307,12 @@ export default class BlueskySource { * @param nodelink - Worker runtime used by the source implementation. */ public constructor(nodelink: WorkerNodeLink) { - const options = nodelink.options as BlueskyRuntimeOptions + const options = nodelink.options this.nodelink = nodelink this.config = { maxSearchResults: - typeof options.maxSearchResults === 'number' - ? options.maxSearchResults - : undefined + (options.sources?.bluesky as { maxSearchResults?: number }) + ?.maxSearchResults ?? options.search?.maxResults } this.searchTerms = ['bksearch'] this.patterns = [ diff --git a/src/sources/deezer.ts b/src/sources/deezer.ts index 77c836cd..1b390830 100644 --- a/src/sources/deezer.ts +++ b/src/sources/deezer.ts @@ -79,6 +79,12 @@ interface DeezerRuntimeOptions { * Maximum number of tracks loaded for albums, playlists, and artists. */ maxAlbumPlaylistLength?: number + search?: { + maxResults?: number + } + playback?: { + maxPlaylistLength?: number + } /** * Source-specific configuration map. @@ -630,7 +636,7 @@ export default class DeezerSource { /** * Search aliases handled by this source. */ - public readonly searchTerms = ['dzsearch'] + public readonly searchTerms = ['dzsearch', 'dzisrc'] /** * Recommendation aliases handled by this source. @@ -953,7 +959,7 @@ export default class DeezerSource { if (tracks.length === 0) return { loadType: 'empty', data: {} } return { - loadType: type as 'album' | 'playlist', + loadType: 'playlist', data: { info: { name: entity.title ?? 'Unknown Deezer Collection', @@ -1100,11 +1106,41 @@ export default class DeezerSource { return result } } catch (error) { - logger( - 'warn', - 'Deezer', - `Direct stream failed for ${decodedTrack.title}: ${this.getErrorMessage(error)}. Falling back to default search.` - ) + const errMsg = this.getErrorMessage(error) + if (errMsg.toLowerCase().includes('csrf') && !forceRefresh) { + logger( + 'warn', + 'Deezer', + `CSRF token expired (${errMsg}). Evicting cache and refreshing credentials...` + ) + const cm = this.nodelink.credentialManager + cm?.delete?.('deezer_csrf_token') + cm?.delete?.('deezer_license_token') + cm?.delete?.('deezer_cookie') + this.csrfToken = null + this.licenseToken = null + this.cookie = null + const success = await this.performSetup() + if (success && this.cookie && this.csrfToken && this.licenseToken) { + logger( + 'info', + 'Deezer', + 'Credentials refreshed. Retrying direct stream...' + ) + return this.getTrackUrl(decodedTrack, _itag, true) + } + logger( + 'warn', + 'Deezer', + 'Failed to refresh credentials. Falling back to search.' + ) + } else { + logger( + 'warn', + 'Deezer', + `Direct stream failed for ${decodedTrack.title}: ${errMsg}. Falling back to default search.` + ) + } } } @@ -1822,7 +1858,7 @@ export default class DeezerSource { * @returns Maximum number of search results to return. */ private getMaxSearchResults(): number { - const limit = this.config.maxSearchResults + const limit = this.config.search?.maxResults return typeof limit === 'number' && limit > 0 ? limit : 10 } @@ -1833,7 +1869,7 @@ export default class DeezerSource { * @returns Maximum collection length for albums, playlists, or artists. */ private getMaxCollectionLength(fallback: number): number { - const limit = this.config.maxAlbumPlaylistLength + const limit = this.config.playback?.maxPlaylistLength return typeof limit === 'number' && limit > 0 ? limit : fallback } diff --git a/src/sources/eternalbox.ts b/src/sources/eternalbox.ts index f98529b8..f0753695 100644 --- a/src/sources/eternalbox.ts +++ b/src/sources/eternalbox.ts @@ -225,7 +225,7 @@ export default class EternalboxSource implements SourceInstance { const limit = this.config.searchResults || - (this.nodelink.options.maxSearchResults as number) || + (this.nodelink.options.search.maxResults as number) || 10 const url = `${this.baseUrl}/api/analysis/search?query=${encodeURIComponent(query)}&results=${limit}` diff --git a/src/sources/flowery.ts b/src/sources/flowery.ts index 42147c83..38cd15e6 100644 --- a/src/sources/flowery.ts +++ b/src/sources/flowery.ts @@ -1,4 +1,4 @@ -import { PassThrough } from 'node:stream' +import { PassThrough, pipeline } from 'node:stream' import { URL } from 'node:url' import type { SourceResult, @@ -899,18 +899,27 @@ export default class FlowerySource { } const stream = new PassThrough() - response.stream.pipe(stream) - - response.stream.on('end', () => { - stream.emit('finishBuffering') + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() }) - response.stream.on('error', (error: Error) => { - logger('error', 'Sources', `Flowery TTS stream error: ${error.message}`) - if (!stream.destroyed) { - stream.destroy(error) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger( + 'error', + 'Sources', + `Flowery TTS stream error: ${error.message}` + ) + } + return + } + stream.emit('finishBuffering') } - }) + ) return { stream } } catch (error) { diff --git a/src/sources/gaana.ts b/src/sources/gaana.ts index 30fd46dd..5f99dfc3 100644 --- a/src/sources/gaana.ts +++ b/src/sources/gaana.ts @@ -2,6 +2,7 @@ import { createDecipheriv } from 'node:crypto' import { PassThrough } from 'node:stream' import HLSHandler from '../playback/hls/HLSHandler.ts' import { parse as parsePlaylist } from '../playback/hls/PlaylistParser.ts' +import type { GaanaSourceConfig } from '../typings/config/config.types.ts' import type { HLSSegment } from '../typings/playback/hls.types.ts' import type { SourceResult, @@ -42,7 +43,7 @@ export default class GaanaSource { /** * Gaana source configuration block. */ - public readonly config: Record + public readonly config: GaanaSourceConfig /** * Search aliases handled by this source. @@ -91,8 +92,8 @@ export default class GaanaSource { public constructor(nodelink: WorkerNodeLink) { this.nodelink = nodelink - const sourceConfig = this.asRecord(this.nodelink.options.sources?.gaana) - this.config = sourceConfig || {} + const sourceConfig = this.nodelink.options.sources.gaana + this.config = sourceConfig this.searchTerms = ['gnsearch', 'gaanasearch'] this.patterns = [ /^@?(?:https?:\/\/)?(?:www\.)?gaana\.com\/(?song|album|playlist|artist)\/(?[\w-]+)(?:[?#].*)?$/ @@ -100,9 +101,9 @@ export default class GaanaSource { this.priority = 70 this.maxSearchResults = - this.asNumber(this.nodelink.options.maxSearchResults) ?? 10 + this.asNumber(this.nodelink.options.search.maxResults) ?? 10 const maxAlbumPlaylistLength = - this.asNumber(this.nodelink.options.maxAlbumPlaylistLength) ?? 100 + this.asNumber(this.nodelink.options.playback.maxPlaylistLength) ?? 100 this.playlistLoadLimit = this.asNumber(this.config.playlistLoadLimit) ?? maxAlbumPlaylistLength this.albumLoadLimit = @@ -1013,7 +1014,10 @@ export default class GaanaSource { query = '' ): Promise | null> { const url = `${API_URL}?${new URLSearchParams( - Object.entries(params).map(([key, value]) => [key, String(value)]) + Object.entries(params).map(([key, value]) => [key, String(value)]) as [ + string, + string + ][] ).toString()}` const proxy = this.getProxyConfig() @@ -1072,7 +1076,7 @@ export default class GaanaSource { password?: string } | undefined { - const proxy = this.asRecord(this.config.proxy) + const proxy = this.asRecord(this.config.network?.proxy) const url = this.asString(proxy?.url) if (!url) return undefined diff --git a/src/sources/google-tts.ts b/src/sources/google-tts.ts index 323b7e60..9dc93dbc 100644 --- a/src/sources/google-tts.ts +++ b/src/sources/google-tts.ts @@ -1,4 +1,4 @@ -import { PassThrough } from 'node:stream' +import { PassThrough, pipeline } from 'node:stream' import type { SourceResult, TrackInfo, @@ -153,7 +153,7 @@ export default class GoogleTTSSource { this.nodelink = nodelink this.config = this.getConfig() this.language = this.config.language ?? 'en-US' - this.searchTerms = ['gtts', 'speak'] + this.searchTerms = ['gtts', 'speak', 'tts'] this.baseUrl = 'https://translate.google.com' this.priority = 50 } @@ -412,18 +412,27 @@ export default class GoogleTTSSource { } const stream = new PassThrough() - response.stream.pipe(stream) - - response.stream.on('end', () => { - stream.emit('finishBuffering') + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() }) - response.stream.on('error', (error: Error) => { - logger('error', 'Sources', `Google TTS stream error: ${error.message}`) - if (!stream.destroyed) { - stream.destroy(error) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger( + 'error', + 'Sources', + `Google TTS stream error: ${error.message}` + ) + } + return + } + stream.emit('finishBuffering') } - }) + ) return { stream } } catch (error) { diff --git a/src/sources/googledrive.ts b/src/sources/googledrive.ts index 0ed59436..a8e804dd 100644 --- a/src/sources/googledrive.ts +++ b/src/sources/googledrive.ts @@ -1,5 +1,6 @@ import crypto from 'node:crypto' import { PassThrough, type Readable } from 'node:stream' +import type { GoogleDriveSourceConfig } from '../typings/config/config.types.ts' import type { SourceInstance, SourceResult, @@ -106,9 +107,9 @@ export default class GoogleDriveSource implements SourceInstance { } const driveConfig = this.nodelink.options.sources?.googledrive as - | Record + | GoogleDriveSourceConfig | undefined - const userCookies = driveConfig?.cookies as string | undefined + const userCookies = driveConfig?.cookies if (userCookies) { cookiesStr = userCookies } diff --git a/src/sources/http.ts b/src/sources/http.ts index 59728f58..8fc8652c 100644 --- a/src/sources/http.ts +++ b/src/sources/http.ts @@ -15,6 +15,7 @@ import type { WorkerNodeLink } from '../typings/sources/source.types.ts' import type { + HttpRequestResult, HttpResponseHeaders, TrackEncodeInput } from '../typings/utils.types.ts' @@ -260,14 +261,23 @@ export default class HttpSource { let data = await http1makeRequest(url, { method: 'HEAD', headers: requestHeaders + }).catch((err) => { + logger( + 'warn', + 'HTTP Source', + `HEAD request failed for URL: ${url} with error: ${err.message} - falling back to GET request (this is expected for some servers that do not support HEAD)` + ) + return { error: err } }) const headContentType = headerToString( - (data.headers as Record)?.['content-type'] + ((data as HttpRequestResult).headers as Record)?.[ + 'content-type' + ] ) const headOk = !data.error && - (data.statusCode || 0) < 400 && + ((data as HttpRequestResult).statusCode || 0) < 400 && isValidMediaType(headContentType) if (!headOk) { @@ -290,17 +300,19 @@ export default class HttpSource { } } - if ((data.statusCode || 0) >= 400) { + if (((data as HttpRequestResult).statusCode || 0) >= 400) { return { loadType: 'error', exception: { - message: `HTTP error ${data.statusCode} while resolving`, + message: `HTTP error ${(data as HttpRequestResult).statusCode} while resolving`, severity: 'common' } } } - const headers = data.headers as HttpResponseHeaders | undefined + const headers = (data as HttpRequestResult).headers as + | HttpResponseHeaders + | undefined const contentType = headerToString( (headers as Record)?.['content-type'] ) diff --git a/src/sources/iheartradio.ts b/src/sources/iheartradio.ts index 3ceac33a..4c3e5636 100644 --- a/src/sources/iheartradio.ts +++ b/src/sources/iheartradio.ts @@ -45,6 +45,9 @@ interface IheartRuntimeOptions { * Maximum number of search results returned by the source. */ maxSearchResults?: number + search?: { + maxResults?: number + } } /** @@ -334,10 +337,10 @@ export default class IheartradioSource { const options = nodelink.options as IheartRuntimeOptions this.maxSearchResults = - typeof options.maxSearchResults === 'number' && - Number.isInteger(options.maxSearchResults) && - options.maxSearchResults > 0 - ? options.maxSearchResults + typeof options.search?.maxResults === 'number' && + Number.isInteger(options.search?.maxResults) && + options.search?.maxResults > 0 + ? options.search.maxResults : 10 } diff --git a/src/sources/instagram.ts b/src/sources/instagram.ts index 73206f3f..73d2b2fe 100644 --- a/src/sources/instagram.ts +++ b/src/sources/instagram.ts @@ -206,11 +206,17 @@ export default class InstagramSource { if (!value) return value as string return value - .replace(/&/g, '&') + .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => + String.fromCodePoint(Number.parseInt(hex, 16)) + ) + .replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec))) + .replace(/&/g, '&') .replace(/'/g, "'") - .replace(/"/g, '"') - .replace(/</g, '<') - .replace(/>/g, '>') + .replace(/"/g, '"') + .replace(//g, '>') + .replace(/'/g, "'") + .replace(/ /g, ' ') .trim() } @@ -714,7 +720,7 @@ export default class InstagramSource { 'X-ASBD-ID': '129477', 'Sec-Fetch-Site': 'same-origin', 'User-Agent': - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36', + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', Origin: 'https://www.instagram.com', Referer: `https://www.instagram.com/reels/audio/${audioId}/` } @@ -822,6 +828,18 @@ export default class InstagramSource { infoSource = 'music_info' } + if (!audioInfo) { + const items = payload?.items as + | { + media?: { + clips_metadata?: { music_info?: Record } + } + }[] + | undefined + audioInfo = items?.[0]?.media?.clips_metadata?.music_info + infoSource = 'music_info' + } + if (!audioInfo) { return { data: null, @@ -855,8 +873,11 @@ export default class InstagramSource { | Record | undefined - audioUrl = (musicAsset?.progressive_download_url as string) || null - + audioUrl = + (musicAsset?.fast_start_progressive_download_url as string) || + (audioInfo.progressive_download_url as string) || + null + // there is no difference between fast_start and progressive, but fast_start always appears first so. if (!audioUrl && musicConsumption?.dash_manifest) { const urlMatch = String(musicConsumption.dash_manifest).match( /(.*?)<\/BaseURL>/ @@ -870,10 +891,17 @@ export default class InstagramSource { audioUrl = (audioInfo.progressive_download_url as string) || null } - artist = (musicAsset?.artist_name as string) || 'User Unknown' + artist = + (musicAsset?.display_artist as string) || + (musicAsset?.artist_name as string) || + 'User Unknown' title = (musicAsset?.title as string) || 'Instagram Audio' duration = (musicAsset?.duration_in_ms as number) || 0 - thumbnail = (musicAsset?.cover_artwork_thumbnail_uri as string) || '' + // cover_artwork_uri gives better quality i see. + thumbnail = + (musicAsset?.cover_artwork_uri as string) || + (audioInfo.cover_artwork_thumbnail_uri as string) || + '' } if (!audioUrl) { @@ -900,6 +928,105 @@ export default class InstagramSource { } } + /** + * Fetches a video from Instagram's logged-out clips query. + * + * @param postId - Instagram shortcode for the video. + * @returns Video data when found, otherwise `null`. + */ + private async _fetchFromClipsQuery( + postId: string + ): Promise { + try { + const alphabet = + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_' + let mediaId = 0n + for (const character of postId) { + mediaId = mediaId * 64n + BigInt(alphabet.indexOf(character)) + } + + const variables = JSON.stringify({ + data: { + chaining_mode: 'same_author', + clips_media_id: mediaId.toString() + }, + __relay_internal__pv__PolarisReelsRecoDebugOverlayEnabledrelayprovider: false, + __relay_internal__pv__PolarisShortDramaEnabledrelayprovider: false + }) + const query = new URLSearchParams({ + doc_id: '27695069083459414', + variables + }) + const response = await makeRequest( + `https://www.instagram.com/graphql/query/?${query.toString()}`, + { method: 'GET' } + ) + if (response.error || response.statusCode !== 200) return null + + const responseData = + typeof response.body === 'string' + ? (JSON.parse(response.body) as Record) + : (response.body as Record) + const edges = ( + (responseData.data as Record | undefined) + ?.xdt_api__v1__clips__clips_on_logged_out_connection_v2 as + | Record + | undefined + )?.edges as + | Array<{ node: { media?: Record } }> + | undefined + const media = edges + ?.map((edge) => edge.node.media) + .find((item) => item?.code === postId) + if (media?.media_type !== 2) return null + + const videoVersions = media.video_versions as + | Array> + | undefined + const videoUrl = videoVersions?.find( + (version) => typeof version.url === 'string' + )?.url as string | undefined + if (!videoUrl) return null + + const user = media.user as Record | undefined + const caption = media.caption as Record | undefined + const imageVersions = media.image_versions2 as + | Record + | undefined + const imageCandidates = imageVersions?.candidates as + | Array> + | undefined + const manifest = media.video_dash_manifest as string | undefined + const manifestDuration = manifest?.match( + /mediaPresentationDuration="PT([\d.]+)S"/ + )?.[1] + + return { + data: { + videoUrl, + author: (user?.username as string) || 'User Unknown', + length: Math.round(Number(manifestDuration || 0) * 1000), + thumbnail: + (imageCandidates?.find( + (candidate) => typeof candidate.url === 'string' + )?.url as string | undefined) || '', + title: (caption?.text as string) || 'Instagram Video', + isStream: false, + isSeekable: true + }, + exception: null + } + } catch (e: unknown) { + const message = e instanceof Error ? e.message : String(e) + logger( + 'debug', + 'Sources', + `Instagram clips query failed for ${postId}: ${message}` + ) + return null + } + } + /** * Fetches post/reel media information from the Instagram GraphQL API. * @@ -919,7 +1046,9 @@ export default class InstagramSource { exception: { message: 'Post ID not provided', severity: 'common' } } } - + + // this no longer works btw... + // only is working from clips, but there are ways to do it on /embed/ too. const headers: Record = { Accept: '*/*', 'Accept-Language': 'en-US,en;q=0.9', @@ -1105,20 +1234,21 @@ export default class InstagramSource { let fetchError: InstagramFetchResult['exception'] = null if (type === 'post') { + const clipsResult = await this._fetchFromClipsQuery(contentId) ;({ data: trackData, exception: fetchError } = - await this._fetchFromGraphQL(contentId, pathSegment)) + clipsResult ?? (await this._fetchFromGraphQL(contentId, pathSegment))) } else if (type === 'audio') { ;({ data: trackData, exception: fetchError } = - await this._fetchAudioOgMetadata(contentId)) + await this._fetchFromAudioAPI(contentId)) if (fetchError) { logger( 'debug', 'Sources', - `Instagram audio OG metadata fallback triggered for ${contentId}: ${fetchError.message}` + `Instagram audio API fallback triggered for ${contentId}: ${fetchError.message}` ) ;({ data: trackData, exception: fetchError } = - await this._fetchFromAudioAPI(contentId)) + await this._fetchAudioOgMetadata(contentId)) } } else { return { @@ -1226,50 +1356,59 @@ export default class InstagramSource { let fetchError: InstagramFetchResult['exception'] = null if (type === 'post') { + const clipsResult = await this._fetchFromClipsQuery(contentId) ;({ data: trackData, exception: fetchError } = - await this._fetchFromGraphQL(contentId, pathSegment)) + clipsResult ?? (await this._fetchFromGraphQL(contentId, pathSegment))) } else if (type === 'audio') { - let mirrorTrack: BestMatchTrackInfo = track - let preferredQuery: string | null = null + ;({ data: trackData, exception: fetchError } = + await this._fetchFromAudioAPI(contentId)) - if ( - !track.title || - track.title === 'Instagram Audio' || - track.author === 'User Unknown' - ) { - const ogMetadata = await this._fetchAudioOgMetadata(contentId) - if (!ogMetadata.exception && ogMetadata.data) { - mirrorTrack = { - title: ogMetadata.data.title || track.title, - author: ogMetadata.data.author || track.author, - length: track.length, - uri: track.uri + if (!trackData) { + let mirrorTrack: BestMatchTrackInfo = track + let preferredQuery: string | null = null + + if ( + !track.title || + track.title === 'Instagram Audio' || + track.author === 'User Unknown' + ) { + const ogMetadata = await this._fetchAudioOgMetadata(contentId) + if (!ogMetadata.exception && ogMetadata.data) { + mirrorTrack = { + title: ogMetadata.data.title || track.title, + author: ogMetadata.data.author || track.author, + length: track.length, + uri: track.uri + } + preferredQuery = + ( + ogMetadata.data as InstagramRawTrackData & { + searchQuery?: string + } + ).searchQuery || null } - preferredQuery = - ( - ogMetadata.data as InstagramRawTrackData & { - searchQuery?: string - } - ).searchQuery || null } - } - - const mirrorResult = await this._resolveAudioMirrorTrack( - mirrorTrack, - preferredQuery - ) - if (!mirrorResult?.exception) { - return mirrorResult as TrackUrlResult - } - logger( - 'warn', - 'Sources', - `Instagram audio mirror failed for ${contentId}: ${mirrorResult.exception.message}. Falling back to direct stream lookup.` - ) + const mirrorResult = await this._resolveAudioMirrorTrack( + mirrorTrack, + preferredQuery + ) + if (!mirrorResult?.exception) { + return mirrorResult as TrackUrlResult + } - ;({ data: trackData, exception: fetchError } = - await this._fetchFromAudioAPI(contentId)) + logger( + 'warn', + 'Sources', + `Instagram audio mirror failed for ${contentId}: ${mirrorResult.exception.message}.` + ) + return { + exception: { + message: 'Audio API request failed', + severity: 'common' + } + } + } } else { return { exception: { diff --git a/src/sources/jiosaavn.ts b/src/sources/jiosaavn.ts index e05a83aa..df313a55 100644 --- a/src/sources/jiosaavn.ts +++ b/src/sources/jiosaavn.ts @@ -389,7 +389,7 @@ export default class JioSaavnSource { const { stream, error, statusCode } = await http1makeRequest(url, { method: 'GET', streamOnly: true, - proxy: this.config.proxy + proxy: this.config.network?.proxy }) if (error || statusCode !== 200 || !stream) { @@ -445,7 +445,7 @@ export default class JioSaavnSource { const { body, error, statusCode } = await http1makeRequest(url.toString(), { method: 'GET', headers: HEADERS, - proxy: this.config.proxy + proxy: this.config.network?.proxy }) if (error || statusCode !== 200) { diff --git a/src/sources/kwai.ts b/src/sources/kwai.ts index 443ccef4..59fc300b 100644 --- a/src/sources/kwai.ts +++ b/src/sources/kwai.ts @@ -1,4 +1,4 @@ -import { PassThrough } from 'node:stream' +import { PassThrough, pipeline } from 'node:stream' import type { SourceResult, TrackInfo, @@ -246,18 +246,22 @@ export default class KwaiSource { } const stream = new PassThrough() - - response.stream.on('data', (chunk: Buffer) => { - stream.write(chunk) - }) - response.stream.on('end', () => { - stream.emit('finishBuffering') - }) - response.stream.on('error', (error: Error) => { - logger('error', 'Kwai', `Upstream stream error: ${error.message}`) - stream.emit('error', error) - stream.emit('finishBuffering') + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() }) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Kwai', `Stream error: ${error.message}`) + } + return + } + stream.emit('finishBuffering') + } + ) return { stream, type: 'mp4' } } catch (error) { @@ -304,9 +308,11 @@ export default class KwaiSource { return null } - return value.replace(/\\u([\dA-Fa-f]{4})/g, (_match, code) => - String.fromCharCode(Number.parseInt(code, 16)) - ) + try { + return JSON.parse(`"${value}"`) as string + } catch { + return value + } } /** @@ -324,7 +330,7 @@ export default class KwaiSource { method: 'GET', headers: { 'User-Agent': - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3', + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', Accept: '*/*' } }) @@ -338,35 +344,42 @@ export default class KwaiSource { } const body = response.body - const mediaSection = body.match( - /share_info:c,main_mv_urls:\s*\[(.*?)\]/ - )?.[1] - const author = body.match(/kwai_id\s*:\s*"([^"]+)"/)?.[1] ?? 'Unknown' - const durationText = body.match(/duration:\s*([\d]+)/)?.[1] - - let thumbnailUrl = body.match(/poster="([^"]+)"/)?.[1] ?? null - if (!thumbnailUrl) { - const thumbnailMatch = body.match( - /cover_thumbnail_urls:\[\{cdn:p,url:\s*"([^"]+)"/ - ) - thumbnailUrl = this.decodeUnicodeEscapes(thumbnailMatch?.[1] ?? null) + const photoIndex = body.indexOf(`photo_id_str:"${videoId}"`) + if (photoIndex === -1) { + throw new Error('Video data not found in response') } - if (!mediaSection) { + const entryStart = body.lastIndexOf(']={', photoIndex) + const entryEnd = body.indexOf('};', photoIndex) + const videoData = body.slice(entryStart + 3, entryEnd) + const videoUrl = this.decodeUnicodeEscapes( + videoData.match(/main_mv_urls:\[\{[^}]*url:"((?:\\.|[^"])*)"/)?.[1] ?? + null + ) + if (!videoUrl) { throw new Error('Video URL not found in response') } - const videoUrlMatch = mediaSection.match(/url:\s*"([^"]+)"/)?.[1] - const videoUrl = this.decodeUnicodeEscapes(videoUrlMatch ?? null) - if (!videoUrl) { - throw new Error('Could not extract video URL') - } + const author = + this.decodeUnicodeEscapes( + videoData.match(/user_name:"((?:\\.|[^"])*)"/)?.[1] ?? null + ) ?? 'Unknown' + const title = + this.decodeUnicodeEscapes( + videoData.match(/caption:"((?:\\.|[^"])*)"/)?.[1] ?? null + ) ?? (author === 'Unknown' ? 'Kwai Video' : `Kwai - ${author}`) + const durationText = videoData.match(/ext_params:\{[^}]*sound:(\d+)/)?.[1] + const thumbnail = this.decodeUnicodeEscapes( + videoData.match( + /cover_thumbnail_urls:\[\{[^}]*url:"((?:\\.|[^"])*)"/ + )?.[1] ?? null + ) return { author, - title: author === 'Unknown' ? 'Kwai Video' : `Kwai - ${author}`, - length: durationText ? Number.parseInt(durationText, 10) * 1000 : 0, - thumbnail: thumbnailUrl, + title, + length: durationText ? Number.parseInt(durationText, 10) : 0, + thumbnail, videoUrl } } diff --git a/src/sources/lastfm.ts b/src/sources/lastfm.ts index d12b0927..0714c06b 100644 --- a/src/sources/lastfm.ts +++ b/src/sources/lastfm.ts @@ -110,7 +110,7 @@ export default class LastFMSource { getMaxSearchResults(): number { const options = this.nodelink.options - const limit = options.maxSearchResults + const limit = options.search.maxResults return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit : 10 diff --git a/src/sources/lazypytts.ts b/src/sources/lazypytts.ts index 10dc688b..f550bc02 100644 --- a/src/sources/lazypytts.ts +++ b/src/sources/lazypytts.ts @@ -76,7 +76,7 @@ export default class LazyPyTtsSource { const sourceConfig = this.nodelink.options.sources?.lazypytts this.config = sourceConfig && typeof sourceConfig === 'object' - ? (sourceConfig as Record) + ? (sourceConfig as unknown as Record) : {} this.searchTerms = ['lazypytts', 'lazytts'] this.patterns = [/^lazypytts:/i, /^lazytts:/i] diff --git a/src/sources/letrasmus.ts b/src/sources/letrasmus.ts index 1079a949..7d497aee 100644 --- a/src/sources/letrasmus.ts +++ b/src/sources/letrasmus.ts @@ -44,6 +44,9 @@ interface LetrasRuntimeOptions { * Maximum number of search results returned by the source. */ maxSearchResults?: number + search?: { + maxResults?: number + } } /** @@ -386,10 +389,10 @@ export default class LetrasMusSource { const options = nodelink.options as LetrasRuntimeOptions this.maxSearchResults = - typeof options.maxSearchResults === 'number' && - Number.isInteger(options.maxSearchResults) && - options.maxSearchResults > 0 - ? options.maxSearchResults + typeof options.search?.maxResults === 'number' && + Number.isInteger(options.search?.maxResults) && + options.search?.maxResults > 0 + ? options.search.maxResults : 10 } diff --git a/src/sources/mixcloud.ts b/src/sources/mixcloud.ts index 75974e5f..33c0fdd8 100644 --- a/src/sources/mixcloud.ts +++ b/src/sources/mixcloud.ts @@ -279,7 +279,7 @@ export default class MixcloudSource { } }) .filter((track) => track.info.uri.length > 0) - .slice(0, this.config.maxSearchResults || DEFAULT_MAX_RESULTS) + .slice(0, this.config.search.maxResults || DEFAULT_MAX_RESULTS) if (tracks.length === 0) return this.emptyResult() @@ -415,7 +415,7 @@ export default class MixcloudSource { let hasNextPage = true let playlistName = 'Mixcloud Playlist' const maxTracks = - this.config.maxAlbumPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH + this.config.playback.maxPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH while (hasNextPage && tracks.length < maxTracks) { const response = await this._request(queryTemplate(cursor)) @@ -493,7 +493,7 @@ export default class MixcloudSource { let hasNextPage = true let userDisplayName = username const maxTracks = - this.config.maxAlbumPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH + this.config.playback.maxPlaylistLength || DEFAULT_MAX_PLAYLIST_LENGTH while (hasNextPage && tracks.length < maxTracks) { const response = await this._request(queryTemplate(cursor)) diff --git a/src/sources/monochrome.ts b/src/sources/monochrome.ts index 36bf745c..c366cb0f 100644 --- a/src/sources/monochrome.ts +++ b/src/sources/monochrome.ts @@ -48,6 +48,7 @@ class MonochromeSource implements SourceInstance { private apiInstances: InstanceHealth[] = [] private streamingInstances: InstanceHealth[] = [] + private qobuzInstances: InstanceHealth[] = [] /** * Initializes the Monochrome source with health-tracked instance pools. @@ -55,7 +56,7 @@ class MonochromeSource implements SourceInstance { */ constructor(nodelink: WorkerNodeLink) { this.nodelink = nodelink - const sources = nodelink.options?.sources as + const sources = nodelink.options?.sources as unknown as | Record | undefined this.config = @@ -76,6 +77,11 @@ class MonochromeSource implements SourceInstance { 'https://api.monochrome.tf' ] + const defaultQobuzUrls = [ + 'https://qobuz.kennyy.com.br', + 'https://trypt-hifi-dl-456461932686.us-west1.run.app' + ] + const initPool = (urls: string[]) => urls.map((url) => ({ url: url.replace(/\/$/, ''), @@ -92,9 +98,13 @@ class MonochromeSource implements SourceInstance { const streamingInstances = this.config.streamingInstances?.length ? this.config.streamingInstances : instances + const qobuzInstances = this.config.qobuzInstances?.length + ? this.config.qobuzInstances + : defaultQobuzUrls this.apiInstances = initPool(instances) this.streamingInstances = initPool(streamingInstances) + this.qobuzInstances = initPool(qobuzInstances) this.patterns = [ /^https?:\/\/monochrome\.tf\/(track|album|playlist|artist|video)\/[\w-]+/, @@ -121,76 +131,17 @@ class MonochromeSource implements SourceInstance { return false } - logger( - 'info', - 'Monochrome', - `Initializing latency check for ${apiCount} instances...` - ) - - const checkInstance = async (instance: InstanceHealth) => { - const start = Date.now() - try { - const { statusCode } = await http1makeRequest(`${instance.url}/`, { - method: 'GET', - timeout: 3000 - }) - const latency = Date.now() - start - - if (statusCode === 200 || statusCode === 404 || statusCode === 302) { - // Success (or at least reachable) - if (latency < 500) instance.score = 100 - else if (latency < 1500) instance.score = 80 - else if (latency < 3000) instance.score = 50 - else instance.score = 20 - - logger( - 'debug', - 'Monochrome', - `Instance ${instance.url} - Latency: ${latency}ms, Initial Score: ${instance.score}` - ) - } else { - instance.score = 0 - instance.lastFailure = Date.now() - logger( - 'debug', - 'Monochrome', - `Instance ${instance.url} - Error: Status ${statusCode}, Score: 0` - ) - } - } catch (_e) { - instance.score = 0 - instance.lastFailure = Date.now() - logger( - 'debug', - 'Monochrome', - `Instance ${instance.url} - Connection Failed, Score: 0` - ) - } - } - - await Promise.allSettled(this.apiInstances.map(checkInstance)) - - // Sync streaming scores if they use the same URLs for (const s of this.streamingInstances) { const api = this.apiInstances.find((a) => a.url === s.url) if (api) s.score = api.score } - const reachable = this.apiInstances.filter((i) => i.score > 0).length logger( 'info', 'Monochrome', - `Source is ready with ${apiCount} API (${reachable} reachable) and ${streamCount} streaming instances.` + `Source is ready with ${apiCount} API and ${streamCount} streaming instances.` ) - if (reachable === 0) { - logger( - 'warn', - 'Monochrome', - 'No reachable Monochrome instances at startup. Source will stay loaded but degraded.' - ) - } - return true } catch (error) { logger( @@ -464,7 +415,7 @@ class MonochromeSource implements SourceInstance { } } - // 3. Collection resolution (Album/Playlist) with exaustive pagination + // 3. Collection resolution (Album/Playlist) with exhaustive pagination const collectionMatch = url.match(/(album|playlist)\/([a-f0-9-]+|\d+)/) if (collectionMatch) { const type = collectionMatch[1] || '' @@ -479,7 +430,7 @@ class MonochromeSource implements SourceInstance { while ( tracks.length < total && tracks.length < - ((this.nodelink.options.maxAlbumPlaylistLength as number) || 1000) + ((this.nodelink.options.playback.maxPlaylistLength as number) || 1000) ) { const res = await this.fetchWithRetry< MonochromeResponse<{ @@ -539,6 +490,19 @@ class MonochromeSource implements SourceInstance { */ public async getTrackUrl(track: TrackInfo): Promise { const isVideo = track.uri.includes('/video/') + + if (!isVideo && track.isrc) { + const qobuzQuality = this.config.qobuzQuality ?? 6 + const qobuzUrl = await this.fetchQobuzProxyUrl(track.isrc, qobuzQuality) + if (qobuzUrl) { + return { + url: qobuzUrl, + protocol: 'https', + format: qobuzQuality > 5 ? 'audio/flac' : 'audio/mpeg' + } + } + } + const quality = this.config.quality || 'LOSSLESS' const params = new URLSearchParams({ @@ -567,39 +531,33 @@ class MonochromeSource implements SourceInstance { '2.7' ) - if (!response) - return { - exception: { - message: 'Failed to fetch playback manifest', - severity: 'fault' + if (response) { + const uri = this.extractStreamUrl(response) + if (uri) { + const attr = response?.data?.data?.attributes + if (attr?.trackAudioNormalizationData) { + logger( + 'debug', + 'Monochrome', + `Normalization for ${track.identifier}: Gain ${attr.trackAudioNormalizationData.replayGain} dB, Peak ${attr.trackAudioNormalizationData.peakAmplitude}` + ) } - } - - const uri = this.extractStreamUrl(response) - if (!uri) - return { - exception: { - message: 'Failed to extract playable URI from manifest', - severity: 'fault' + return { + url: uri, + protocol: uri.includes('.mpd') + ? 'dash' + : uri.includes('.m3u8') + ? 'hls' + : 'http' } } - - const attr = response?.data?.data?.attributes - if (attr?.trackAudioNormalizationData) { - logger( - 'debug', - 'Monochrome', - `Normalization for ${track.identifier}: Gain ${attr.trackAudioNormalizationData.replayGain} dB, Peak ${attr.trackAudioNormalizationData.peakAmplitude}` - ) } return { - url: uri, - protocol: uri.includes('.mpd') - ? 'dash' - : uri.includes('.m3u8') - ? 'hls' - : 'http' + exception: { + message: 'Failed to fetch playback manifest', + severity: 'fault' + } } } @@ -820,6 +778,123 @@ class MonochromeSource implements SourceInstance { } } + /** + * Fetches a direct stream URL from the Qobuz proxy instances. + * Steps: search by ISRC → get track ID → download music. + * @param isrc - Track ISRC code. + * @returns Direct stream URL or null. + * @private + */ + private async fetchQobuzProxyUrl( + isrc: string, + quality: number = 6 + ): Promise { + const pool = this.qobuzInstances.filter((i) => i.score > 0) + if (pool.length === 0) { + logger('warn', 'Monochrome', 'No Qobuz proxy instances available.') + return null + } + + const proxyHeaders = { + 'User-Agent': + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36', + Accept: '*/*', + 'Accept-Language': 'en;q=0.8', + Origin: 'https://monochrome.tf', + Referer: 'https://monochrome.tf/', + Pragma: 'no-cache', + 'Cache-Control': 'no-cache' + } + + for (const instance of pool) { + instance.activeRequests++ + try { + const searchUrl = `${instance.url}/api/get-music?q=${encodeURIComponent(isrc)}&offset=0` + const { body: searchBody, statusCode: searchStatus } = + await http1makeRequest(searchUrl, { + method: 'GET', + timeout: 5000, + headers: proxyHeaders + }) + + if (searchStatus !== 200 || !searchBody) { + instance.score = Math.max(instance.score - 10, 0) + instance.failures++ + instance.lastFailure = Date.now() + continue + } + + const searchData = + typeof searchBody === 'string' + ? (JSON.parse(searchBody) as Record) + : (searchBody as Record) + + const tracks = (searchData?.data as Record | undefined) + ?.tracks as Record | undefined + const items = tracks?.items as + | Array> + | undefined + const track = items?.[0] + if (!track) { + instance.score = Math.max(instance.score - 5, 0) + continue + } + + const trackId = track.id as number | undefined + if (!trackId) { + instance.score = Math.max(instance.score - 5, 0) + continue + } + + const downloadUrl = `${instance.url}/api/download-music?track_id=${trackId}&quality=${quality}` + const { body: downloadBody, statusCode: downloadStatus } = + await http1makeRequest(downloadUrl, { + method: 'GET', + timeout: 5000, + headers: proxyHeaders + }) + + if (downloadStatus !== 200 || !downloadBody) { + instance.score = Math.max(instance.score - 10, 0) + instance.failures++ + instance.lastFailure = Date.now() + continue + } + + const downloadData = + typeof downloadBody === 'string' + ? (JSON.parse(downloadBody) as Record) + : (downloadBody as Record) + + const url = (downloadData?.data as Record | undefined) + ?.url as string | undefined + if (url) { + instance.score = Math.min(instance.score + 5, 100) + logger( + 'debug', + 'Monochrome', + `Qobuz proxy resolved track ${isrc} via ${instance.url}` + ) + return url + } + + instance.score = Math.max(instance.score - 5, 0) + } catch (e) { + instance.score = Math.max(instance.score - 20, 0) + instance.lastFailure = Date.now() + logger( + 'error', + 'Monochrome', + `Qobuz proxy error for ${isrc} on ${instance.url}: ${e instanceof Error ? e.message : String(e)}` + ) + } finally { + instance.activeRequests-- + } + } + + return null + } + /** * Normalizes a raw track object into NodeLink's TrackInfo structure. * @param t - Raw Tidal track data. diff --git a/src/sources/netease.ts b/src/sources/netease.ts index 978c6b5b..62bdfd9d 100644 --- a/src/sources/netease.ts +++ b/src/sources/netease.ts @@ -103,7 +103,7 @@ export default class NeteaseSource { ] this.priority = 45 this.searchTerms = ['ntsearch'] - this.maxSearchResults = nodelink.options.maxSearchResults || 10 + this.maxSearchResults = nodelink.options.search.maxResults || 10 } /** diff --git a/src/sources/newgrounds.ts b/src/sources/newgrounds.ts new file mode 100644 index 00000000..b10a1dea --- /dev/null +++ b/src/sources/newgrounds.ts @@ -0,0 +1,399 @@ +import { PassThrough, pipeline } from 'node:stream' +import type { + SourceInstance, + SourceResult, + TrackInfo, + TrackStreamResult, + TrackUrlResult, + WorkerNodeLink +} from '../typings/sources/source.types.ts' +import type { TrackEncodeInput } from '../typings/utils.types.ts' +import { encodeTrack, logger, makeRequest } from '../utils.ts' + +const NEWGROUNDS_AUDIO_PATTERN = + /^https?:\/\/(?:www\.)?newgrounds\.com\/audio\/listen\/(\d+)(?:[/?#]|$)/i +const NEWGROUNDS_BASE_URL = 'https://www.newgrounds.com' +const NEWGROUNDS_USER_AGENT = + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/151.0.0.0 Safari/537.36' + +/** + * Audio metadata embedded in a Newgrounds listen page. + * @internal + */ +interface NewgroundsAudioPage { + identifier: string + streamUrl: string + version: number + duration: number + title: string + author: string +} + +/** + * Resolves and streams tracks from the Newgrounds Audio Portal. + * @public + */ +export default class NewgroundsSource implements SourceInstance { + public readonly nodelink: WorkerNodeLink + public readonly patterns = [NEWGROUNDS_AUDIO_PATTERN] + public readonly priority = 50 + + /** + * Creates a Newgrounds source bound to the worker runtime. + * @param nodelink - Worker runtime shared with all sources. + */ + public constructor(nodelink: WorkerNodeLink) { + this.nodelink = nodelink + } + + /** + * Initializes the Newgrounds source. + * @returns Always `true`; this source requires no credentials. + */ + public async setup(): Promise { + logger('info', 'Sources', 'Loaded Newgrounds source.') + return true + } + + /** + * Resolves a Newgrounds Audio Portal listen page. + * @param url - Newgrounds listen-page URL. + * @returns A normalized track, an empty result, or an extraction error. + */ + public async resolve(url: string): Promise { + if (!NEWGROUNDS_AUDIO_PATTERN.test(url)) { + return { loadType: 'empty', data: {} } + } + + try { + const audio = await this._fetchAudioPage(url) + if (!audio) return { loadType: 'empty', data: {} } + + const canonicalUrl = this._buildListenUrl(audio.identifier) + const artworkUrl = this._buildArtworkUrl(audio.identifier, audio.version) + const info: TrackInfo = { + identifier: audio.identifier, + isSeekable: true, + author: audio.author, + length: Math.round(audio.duration * 1000), + isStream: false, + position: 0, + title: audio.title, + uri: canonicalUrl, + artworkUrl, + isrc: null, + sourceName: 'newgrounds' + } + const encodedInput: TrackEncodeInput = { ...info, details: [] } + + return { + loadType: 'track', + data: { + encoded: encodeTrack(encodedInput), + info, + pluginInfo: {} + } + } + } catch (error) { + const message = this._getErrorMessage(error) + logger('error', 'Newgrounds', `Failed to resolve audio: ${message}`) + return { + loadType: 'error', + exception: { + message, + severity: 'fault', + cause: 'Newgrounds page extraction failed' + } + } + } + } + + /** + * Refreshes the direct Newgrounds media URL before playback. + * @param track - Decoded Newgrounds track metadata. + * @returns The direct audio URL or a structured exception. + */ + public async getTrackUrl(track: TrackInfo): Promise { + try { + if (!/^\d+$/.test(track.identifier)) { + throw new Error('Invalid Newgrounds audio identifier') + } + + const audio = await this._fetchAudioPage( + this._buildListenUrl(track.identifier) + ) + if (!audio) { + const directory = Math.floor(Number(track.identifier) / 1000) * 1000 + const title = track.title + .trim() + .replace(/[^\p{L}\p{N}\s-]/gu, '') + .replace(/\s+/g, '-') + const version = track.artworkUrl?.match(/[?&]f(\d+)/)?.[1] + + if (!title) throw new Error('Newgrounds audio is unavailable') + + return { + url: `https://audio-download.ngfiles.com/${directory}/${track.identifier}_${title}.mp3${version ? `?f${version}` : ''}`, + protocol: 'https', + format: 'mp3' + } + } + + return { + url: audio.streamUrl, + protocol: 'https', + format: 'mp3' + } + } catch (error) { + return { + exception: { + message: this._getErrorMessage(error), + severity: 'fault', + cause: 'Newgrounds stream extraction failed' + } + } + } + } + + /** + * Opens a Newgrounds audio stream for playback. + * @param track - Decoded track metadata used for request context. + * @param url - Direct Newgrounds media URL. + * @returns A readable MP3 stream or a structured exception. + */ + public async loadStream( + track: TrackInfo, + url: string + ): Promise { + try { + const response = await makeRequest(url, { + method: 'GET', + streamOnly: true, + headers: { + Accept: 'audio/mpeg,audio/*;q=0.9,*/*;q=0.8', + Referer: track.uri, + 'User-Agent': NEWGROUNDS_USER_AGENT + } + }) + + if ( + response.error || + !response.statusCode || + response.statusCode < 200 || + response.statusCode >= 300 || + !response.stream + ) { + throw new Error( + response.error || + `Newgrounds returned stream status ${response.statusCode ?? 'unknown'}` + ) + } + + const stream = new PassThrough() + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() + }) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error && error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Newgrounds', `Stream error: ${error.message}`) + } + } + ) + + return { stream, type: 'audio/mpeg' } + } catch (error) { + const message = this._getErrorMessage(error) + logger('error', 'Newgrounds', `Failed to load stream: ${message}`) + return { + exception: { + message, + severity: 'fault', + cause: 'Newgrounds stream request failed' + } + } + } + } + + /** + * Fetches and parses the player payload embedded in a listen page. + * @param url - Newgrounds listen-page URL. + * @returns Parsed audio metadata, or `null` for a missing submission. + * @internal + */ + private async _fetchAudioPage( + url: string + ): Promise { + const response = await makeRequest(url, { + method: 'GET', + headers: { + Accept: 'text/html,application/xhtml+xml', + 'User-Agent': NEWGROUNDS_USER_AGENT + } + }) + + if (response.statusCode === 403) { + const identifier = url.match(NEWGROUNDS_AUDIO_PATTERN)?.[1] + if (!identifier) return null + + const previewResponse = await makeRequest( + `https://cardyb.bsky.app/v1/extract?url=${encodeURIComponent(url)}`, + { + method: 'GET', + headers: { 'User-Agent': NEWGROUNDS_USER_AGENT } + } + ) + const preview = previewResponse.body as { + error?: string + title?: string + image?: string + } + const title = preview.title?.trim() + if (previewResponse.statusCode !== 200 || preview.error || !title) { + return null + } + + const directory = Math.floor(Number(identifier) / 1000) * 1000 + const filename = title + .replace(/[^\p{L}\p{N}\s-]/gu, '') + .replace(/\s+/g, '-') + + return { + identifier, + streamUrl: `https://audio-download.ngfiles.com/${directory}/${identifier}_${filename}.mp3`, + version: Number(preview.image?.match(/f(\d+)/)?.[1] || 0), + duration: 0, + title, + author: 'Unknown Artist' + } + } + + if (response.statusCode === 404) return null + if (response.error || response.statusCode !== 200) { + throw new Error( + response.error || + `Newgrounds returned page status ${response.statusCode ?? 'unknown'}` + ) + } + + const html = this._getResponseText(response.body) + if (!html) throw new Error('Newgrounds returned an unreadable page') + + const playerMatch = html.match( + /NgAudioPlayer\.fromListenPage\(\s*\{([\s\S]*?)\}\s*,\s*\d+\s*\)/ + ) + const player = playerMatch?.[1] + if (!player) return null + + const identifier = this._extractNumber(player, 'generic_id') + const streamUrl = this._extractString(player, 'url') + const version = this._extractNumber(player, 'version') + const duration = this._extractNumber(player, 'duration') + const title = this._extractString(player, 'title') + const author = this._extractString(player, 'author') + + if ( + identifier === null || + !streamUrl || + version === null || + duration === null || + !title || + !author + ) { + throw new Error('Newgrounds player metadata is incomplete') + } + + return { + identifier: String(identifier), + streamUrl: streamUrl.startsWith('//') ? `https:${streamUrl}` : streamUrl, + version, + duration, + title, + author + } + } + + /** + * Extracts a JSON-encoded string field from the player object literal. + * @param player - Player object literal body. + * @param field - Field name to extract. + * @returns Decoded field value, or `null` when absent or invalid. + * @internal + */ + private _extractString(player: string, field: string): string | null { + const match = player.match( + new RegExp(`['"]${field}['"]\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`) + ) + if (!match?.[1]) return null + + try { + const value = JSON.parse(match[1]) + return typeof value === 'string' && value ? value : null + } catch { + return null + } + } + + /** + * Extracts a finite numeric field from the player object literal. + * @param player - Player object literal body. + * @param field - Field name to extract. + * @returns Numeric field value, or `null` when absent or invalid. + * @internal + */ + private _extractNumber(player: string, field: string): number | null { + const match = player.match( + new RegExp(`['"]${field}['"]\\s*:\\s*(-?\\d+(?:\\.\\d+)?)`) + ) + if (!match?.[1]) return null + + const value = Number(match[1]) + return Number.isFinite(value) ? value : null + } + + /** + * Converts a request body into HTML text. + * @param body - Response body returned by the request helper. + * @returns UTF-8 text, or `null` for an unsupported body value. + * @internal + */ + private _getResponseText(body: unknown): string | null { + if (typeof body === 'string') return body + if (Buffer.isBuffer(body)) return body.toString('utf8') + return null + } + + /** + * Builds the canonical listen-page URL for an audio identifier. + * @param identifier - Newgrounds audio identifier. + * @returns Canonical listen-page URL. + * @internal + */ + private _buildListenUrl(identifier: string): string { + return `${NEWGROUNDS_BASE_URL}/audio/listen/${identifier}` + } + + /** + * Builds the medium-size Newgrounds audio thumbnail URL. + * @param identifier - Newgrounds audio identifier. + * @param version - Media version used for cache busting. + * @returns Medium-size artwork URL. + * @internal + */ + private _buildArtworkUrl(identifier: string, version: number): string { + const directory = Math.floor(Number(identifier) / 1000) + return `https://aicon.ngfiles.com/${directory}/${identifier}_medium.png?f${version}` + } + + /** + * Normalizes unknown exceptions into loggable messages. + * @param error - Caught exception value. + * @returns Human-readable error message. + * @internal + */ + private _getErrorMessage(error: unknown): string { + return error instanceof Error ? error.message : String(error) + } +} diff --git a/src/sources/pandora.ts b/src/sources/pandora.ts index a4ace574..cb659c22 100644 --- a/src/sources/pandora.ts +++ b/src/sources/pandora.ts @@ -376,7 +376,7 @@ export default class PandoraSource implements SourceInstance { types: ['TR'], listener: null, start: 0, - count: this.options.maxSearchResults ?? 10, + count: this.options.search.maxResults ?? 10, annotate: true, searchTime: 0, annotationRecipe: 'CLASS_OF_2019' @@ -559,7 +559,9 @@ export default class PandoraSource implements SourceInstance { * @internal */ private getMaxPlaylistLength(): number { - return (this.options.maxAlbumPlaylistLength as number | undefined) ?? 100 + return ( + (this.options.playback.maxPlaylistLength as number | undefined) ?? 100 + ) } /** @@ -1099,8 +1101,7 @@ export default class PandoraSource implements SourceInstance { ) if ( - !searchResult || - searchResult.loadType !== 'search' || + searchResult?.loadType !== 'search' || !Array.isArray(searchResult.data) || searchResult.data.length === 0 ) { diff --git a/src/sources/pinterest.ts b/src/sources/pinterest.ts index ccd0aa77..6fe1b6e9 100644 --- a/src/sources/pinterest.ts +++ b/src/sources/pinterest.ts @@ -1,4 +1,5 @@ import { PassThrough } from 'node:stream' +import HLSHandler from '../playback/hls/HLSHandler.ts' import type { SourceResult, TrackInfo, @@ -378,10 +379,10 @@ export default class PinterestSource { } /** - * Selects the first MP4-compatible format from the Pinterest payload. + * Selects the first MP4 or HLS format from the Pinterest payload. * * @param videoList - Available Pinterest video variants. - * @returns First playable MP4-capable format, or `null` when none are found. + * @returns First playable format, or `null` when none are found. */ private getPlayableFormat( videoList: PinterestVideoList | null @@ -395,7 +396,7 @@ export default class PinterestSource { if (videoList.V_360P?.url) return videoList.V_360P for (const format of Object.values(videoList)) { - if (format?.url?.endsWith('.mp4')) { + if (format?.url?.includes('.mp4') || format?.url?.includes('.m3u8')) { return format } } @@ -551,7 +552,7 @@ export default class PinterestSource { * @param decodedTrack - Decoded track information previously returned by the * resolver. * @returns Direct HTTP track URL and its container metadata. - * @throws Error when Pinterest does not expose a playable MP4 stream. + * @throws Error when Pinterest does not expose a playable media stream. */ public async getTrackUrl(decodedTrack: TrackInfo): Promise { const videoId = decodedTrack.identifier @@ -564,10 +565,15 @@ export default class PinterestSource { const format = this.getPlayableFormat(this.getVideoList(data)) if (!format?.url) { - throw new Error('No MP4 format found for Pinterest video') + throw new Error('No playable format found for Pinterest video') } - return { url: format.url, protocol: 'http', format: 'mp4' } + const isHls = format.url.includes('.m3u8') + return { + url: format.url, + protocol: isHls ? 'hls' : 'http', + format: 'mp4' + } } catch (error) { const message = error instanceof Error ? error.message : 'Failed to get track URL.' @@ -585,26 +591,44 @@ export default class PinterestSource { * * @param _decodedTrack - Decoded track metadata, unused by this source. * @param url - Direct media URL returned by `getTrackUrl(...)`. - * @param _protocol - Protocol hint, unused by this source. - * @param _additionalData - Additional stream metadata, unused by this source. + * @param protocol - Protocol hint returned by `getTrackUrl(...)`. + * @param additionalData - Additional stream metadata. * @returns Playable stream payload, or an exception object when the upstream * request fails. */ public async loadStream( _decodedTrack: TrackInfo, url: string, - _protocol?: string, - _additionalData?: Record + protocol?: string, + additionalData?: Record ): Promise { try { + const headers = { + 'User-Agent': + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', + Accept: '*/*' + } + + if (protocol === 'hls' || url.includes('.m3u8')) { + return { + stream: new HLSHandler(url, { + type: 'fmp4', + strategy: 'segmented', + headers, + localAddress: this.nodelink.routePlanner?.getIP?.() ?? null, + startTime: + typeof additionalData?.startTime === 'number' + ? additionalData.startTime + : 0 + }), + type: 'mp4' + } + } + const response = await http1makeRequest(url, { method: 'GET', streamOnly: true, - headers: { - 'User-Agent': - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3', - Accept: '*/*' - } + headers }) if (response.error || !response.stream) { diff --git a/src/sources/pipertts.ts b/src/sources/pipertts.ts index 6b685617..f182b957 100644 --- a/src/sources/pipertts.ts +++ b/src/sources/pipertts.ts @@ -1,4 +1,4 @@ -import { PassThrough } from 'node:stream' +import { PassThrough, pipeline } from 'node:stream' import type { SourceResult, TrackInfo, @@ -456,18 +456,27 @@ export default class PiperSource { } const stream = new PassThrough() - response.stream.pipe(stream) - - response.stream.on('end', () => { - stream.emit('finishBuffering') + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() }) - response.stream.on('error', (error: Error) => { - logger('error', 'Sources', `Piper TTS stream error: ${error.message}`) - if (!stream.destroyed) { - stream.destroy(error) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error) { + if (error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger( + 'error', + 'Sources', + `Piper TTS stream error: ${error.message}` + ) + } + return + } + stream.emit('finishBuffering') } - }) + ) return { stream, type: 'wav' } } catch (error) { diff --git a/src/sources/qobuz.ts b/src/sources/qobuz.ts index cdea91f8..8971c08d 100644 --- a/src/sources/qobuz.ts +++ b/src/sources/qobuz.ts @@ -87,7 +87,7 @@ export default class QobuzSource { ) { this.nodelink = nodelink this.config = nodelink.options - this.searchTerms = ['qbsearch'] + this.searchTerms = ['qbsearch', 'qbisrc'] this.recommendationTerm = ['qbrec'] this.patterns = [ /https?:\/\/(?:www\.|play\.|open\.)?qobuz\.com\/(?:(?:[a-z]{2}-[a-z]{2}\/)?(track|album|playlist|artist)\/(?:.+?\/)?([a-zA-Z0-9]+)|(playlist)\/(\d+))/ @@ -828,7 +828,7 @@ export default class QobuzSource { * @returns Max search size. */ private getMaxSearchResults(): number { - return this.asNumber(this.config.maxSearchResults) ?? 10 + return this.asNumber(this.config.search.maxResults) ?? 10 } /** @@ -836,7 +836,7 @@ export default class QobuzSource { * @returns Max playlist size. */ private getMaxAlbumPlaylistLength(): number { - return this.asNumber(this.config.maxAlbumPlaylistLength) ?? 100 + return this.asNumber(this.config.playback.maxPlaylistLength) ?? 100 } /** diff --git a/src/sources/reddit.ts b/src/sources/reddit.ts index 28a608cc..44953620 100644 --- a/src/sources/reddit.ts +++ b/src/sources/reddit.ts @@ -1,4 +1,4 @@ -import { PassThrough } from 'node:stream' +import { PassThrough, pipeline } from 'node:stream' import type { SourceResult, TrackInfo, @@ -13,8 +13,10 @@ import type { import { encodeTrack, logger, makeRequest } from '../utils.ts' const USER_AGENT = - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3' + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36' const REDDIT_BASE = 'https://www.reddit.com' +const LOID_CACHE_KEY = 'reddit_loid' +const LOID_FALLBACK_TTL_MS = 24 * 60 * 60 * 1000 const COMMENTS_REGEX = /\/comments\/([^/?]+)/ const VIDEO_REGEX = /\/video\/([^/?]+)/ const SHARE_REGEX = /\/r\/([^/]+)\/s\/([^/?]+)/ @@ -289,6 +291,63 @@ async function resolveRedirectingUrl( return COMMENTS_REGEX.exec(finalUrl)?.[1] ?? null } +async function getLoid(nodelink: WorkerNodeLink): Promise { + // seems like a loid cookie can take up 2+ years to expire... idk why but it does... + const cachedLoid = + nodelink.credentialManager?.get(LOID_CACHE_KEY) ?? null + if (cachedLoid) { + return cachedLoid + } + + try { + const res = await makeRequest(`${REDDIT_BASE}/`, { + headers: { 'User-Agent': USER_AGENT } + }) + if (res.error) { + return null + } + + const text = (await res.body) as string + const token = /name="token"\s+value="([^"]+)"/.exec(text)?.[1] + const secret = /await\([^)]*\)\("([0-9a-f]+)"\)/.exec(text)?.[1] + if (!token || !secret) { + return null + } + + const url = new URL(`${REDDIT_BASE}/`) + url.searchParams.set('solution', secret + secret) + url.searchParams.set('js_challenge', '1') + url.searchParams.set('token', token) + url.searchParams.set('jsc_orig_r', '') + + const res2 = await makeRequest(url.toString(), { + headers: { + 'User-Agent': USER_AGENT, + Referer: `${REDDIT_BASE}/` + } + }) + const setCookie = res2.headers?.['set-cookie'] as string | undefined + const loid = /(?:^|,\s*)loid=([^;]+)/.exec(setCookie ?? '')?.[1] + if (!loid) { + return null + } + + const maxAge = /;\s*max-age=(\d+)/i.exec(setCookie ?? '')?.[1] + const expires = /;\s*expires=([^;]+)/i.exec(setCookie ?? '')?.[1] + const expiresAt = expires ? Date.parse(expires) : Number.NaN + const ttlMs = maxAge + ? Number(maxAge) * 1000 + : Number.isFinite(expiresAt) && expiresAt > Date.now() + ? expiresAt - Date.now() + : LOID_FALLBACK_TTL_MS + + nodelink.credentialManager?.set(LOID_CACHE_KEY, loid, ttlMs) + return loid + } catch { + return null + } +} + /** * Reddit source implementation. */ @@ -465,7 +524,18 @@ export default class RedditSource { } const stream = new PassThrough() - response.stream.pipe(stream) + stream.once('close', () => { + ;(response.stream as { destroy?: () => void }).destroy?.() + }) + pipeline( + response.stream, + stream, + (error: NodeJS.ErrnoException | null) => { + if (error && error.code !== 'ERR_STREAM_PREMATURE_CLOSE') { + logger('error', 'Sources', `Reddit stream error: ${error.message}`) + } + } + ) const type = url.endsWith('.mp3') ? 'mp3' : 'mp4' return { stream, type } @@ -548,9 +618,13 @@ export default class RedditSource { return { error: 'fetch.short_link' } } + const loid = await getLoid(this.nodelink) const response = await makeRequest( `${REDDIT_BASE}/comments/${currentParams.id}.json`, - { method: 'GET', headers } + { + method: 'GET', + headers: loid ? { ...headers, Cookie: `loid=${loid}` } : headers + } ) if ( @@ -585,8 +659,9 @@ export default class RedditSource { typeof postData.author === 'string' && postData.author.length > 0 ? `u/${postData.author}` : 'Reddit' - const thumbnail = - postData.thumbnail || postData.preview?.images?.[0]?.source?.url || null + const thumbnailUrl = + postData.preview?.images?.[0]?.source?.url || postData.thumbnail + const thumbnail = thumbnailUrl?.replaceAll('&', '&') || null const commonData = { resolvedId: currentParams.id, title: postData.title || 'Reddit Video', diff --git a/src/sources/shazam.ts b/src/sources/shazam.ts index a7264a42..d4fb2aa4 100644 --- a/src/sources/shazam.ts +++ b/src/sources/shazam.ts @@ -21,6 +21,12 @@ const SHAZAM_PATTERN = /^https?:\/\/(?:www\.)?shazam\.com\/song\/\d+(?:\/[^/?#]+)?\/?(?:[?#].*)?$/ const SHAZAM_SEARCH_BASE = 'https://www.shazam.com/services/amapi/v1/catalog/US/search' +const SHAZAM_VALIDATION_URL = + 'https://www.shazam.com/services/partner/oauth/commerce/validate' +const SHAZAM_COMMERCE_SEARCH_BASE = + 'https://api.music.apple.com/v1/catalog/US/search' // amp- :) +const SHAZAM_ANDROID_USER_AGENT = + 'Dalvik/2.1.0 (Linux; U; Android 12; SM-G9980 Build/af013b0.2) Shazam/v16.51.1' /** * JSON-compatible scalar or nested value used for payload narrowing. @@ -52,6 +58,9 @@ interface ShazamRuntimeOptions { * Global maximum search-result limit used by several sources. */ maxSearchResults?: number + search?: { + maxResults?: number + } /** * Source configuration keyed by source name. @@ -292,7 +301,7 @@ export default class ShazamSource { */ private getMaxSearchResults(): number { const options = this.nodelink.options as ShazamRuntimeOptions - const limit = options.maxSearchResults + const limit = options.search?.maxResults return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit @@ -369,7 +378,70 @@ export default class ShazamSource { return { loadType: 'empty', data: {} } } - const { body, statusCode, error } = await http1makeRequest(url) + const { body, statusCode, error } = await http1makeRequest(url, { + headers: { + 'sec-ch-ua': + '"Chromium";v="148", "Google Chrome";v="148", "Not/A)Brand";v="99"' + } + }) + + if (statusCode === 403) { + const validationResponse = await http1makeRequest( + SHAZAM_VALIDATION_URL, + { + method: 'GET', + headers: { + Origin: 'https://www.shazam.com', + 'User-Agent': SHAZAM_ANDROID_USER_AGENT + } + } + ) + const validationHeader = + validationResponse.headers?.['x-shz-validation'] + const validation = Array.isArray(validationHeader) + ? validationHeader[0] + : validationHeader + + if ( + validationResponse.error || + validationResponse.statusCode !== 200 || + typeof validation !== 'string' || + !validation + ) { + return { loadType: 'empty', data: {} } + } + + const pathParts = new URL(url).pathname.split('/').filter(Boolean) + const identifier = pathParts[1] + const slug = pathParts[2] + if (!identifier || !slug) { + return { loadType: 'empty', data: {} } + } + + const searchUrl = + `${SHAZAM_COMMERCE_SEARCH_BASE}?limit=5&types=songs&term=` + + encodeURIComponent(decodeURIComponent(slug).replace(/[-_]+/g, ' ')) + const searchResponse = await http1makeRequest(searchUrl, { + headers: { + Authorization: `Bearer ${validation}`, + Origin: 'https://www.shazam.com', + 'User-Agent': SHAZAM_ANDROID_USER_AGENT + } + }) + + if (searchResponse.error || searchResponse.statusCode !== 200) { + return { loadType: 'empty', data: {} } + } + + const song = this.extractSearchSongs(searchResponse.body).find( + (item) => item.id === identifier + ) + const track = song ? this.buildTrack(song) : null + return track + ? { loadType: 'track', data: track } + : { loadType: 'empty', data: {} } + } + if (error || statusCode !== 200) { return { loadType: 'empty', data: {} } } diff --git a/src/sources/songlink.ts b/src/sources/songlink.ts index 71dc665f..afc097de 100644 --- a/src/sources/songlink.ts +++ b/src/sources/songlink.ts @@ -1,3 +1,7 @@ +import type { + SonglinkSourceConfig, + SourcesRegistry +} from '../typings/config/config.types.ts' import type { SourceResult, TrackInfo, @@ -69,7 +73,7 @@ export default class SongLinkSource { /** * Raw source configuration block. */ - public readonly config: Record + public readonly config: SonglinkSourceConfig /** * Search aliases supported by this source. @@ -136,11 +140,7 @@ export default class SongLinkSource { } ) { this.nodelink = nodelink - const sourceConfig = this.nodelink.options.sources?.songlink - this.config = - sourceConfig && typeof sourceConfig === 'object' - ? (sourceConfig as Record) - : {} + this.config = this.nodelink.options.sources.songlink this.searchTerms = ['slsearch'] this.patterns = [SONG_LINK_PATTERN] this.priority = 95 @@ -270,7 +270,7 @@ export default class SongLinkSource { _searchType = 'track' ): Promise { try { - const maxSearchRaw = this.nodelink.options.maxSearchResults + const maxSearchRaw = this.nodelink.options.search?.maxResults const limit = typeof maxSearchRaw === 'number' && Number.isFinite(maxSearchRaw) ? maxSearchRaw @@ -695,7 +695,8 @@ export default class SongLinkSource { * @returns True when source can be used. */ private _isSourceAvailable(sourceName: string): boolean { - const sourceConfig = this.nodelink.options.sources?.[sourceName] + const sourceConfig = + this.nodelink.options.sources[sourceName as keyof SourcesRegistry] if (!sourceConfig?.enabled) return false return !!this.nodelink.sources.getSource(sourceName) } diff --git a/src/sources/soundcloud.ts b/src/sources/soundcloud.ts index d5b89638..1dee60f6 100644 --- a/src/sources/soundcloud.ts +++ b/src/sources/soundcloud.ts @@ -27,7 +27,7 @@ const ASSET_PATTERN = /https:\/\/a-v2\.sndcdn\.com\/assets\/[a-zA-Z0-9-]+\.js/g const CLIENT_ID_PATTERN = /(?:[?&/]?(?:client_id)[\s:=&]*"?|"data":{"id":")([A-Za-z0-9]{32})"?/ const TRACK_PATTERN = - /^https?:\/\/(?:www\.|m\.)?soundcloud\.com\/[^/\s]+\/(?:sets\/)?[^/\s]+$/ + /^https?:\/\/(?:www\.|m\.)?soundcloud\.com\/[^/\s]+\/(?:sets\/)?[^/\s?]+(\?.*)?$/ const SEARCH_URL_PATTERN = /^https?:\/\/(?:www\.)?soundcloud\.com\/search(?:\/(sounds|people|albums|sets))?(?:\?|$)/ const BATCH_SIZE = 50 @@ -66,6 +66,15 @@ export default class SoundCloudSource implements SoundCloudSourceState { } async setup(): Promise { + if (this.clientId) { + logger( + 'info', + 'Sources', + `Loaded SoundCloud (clientId: ${this.clientId}) from config` + ) + return true + } + const cachedId = this.nodelink.credentialManager.get( 'soundcloud_client_id' ) @@ -215,7 +224,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { const params = new URLSearchParams({ q: searchQuery, client_id: this.clientId ?? '', - limit: String(this.nodelink.options.maxSearchResults ?? 50), + limit: String(this.nodelink.options.search.maxResults ?? 50), offset: '0', linked_partitioning: '1' }) @@ -300,7 +309,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { _processUsers( collection: SoundCloudApiSearchItem[] ): SoundCloudTrackDataResult[] { - const max = this.nodelink.options.maxSearchResults ?? 50 + const max = this.nodelink.options.search.maxResults ?? 50 const users: SoundCloudTrackDataResult[] = [] for (let i = 0; i < collection.length && users.length < max; i++) { @@ -341,7 +350,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { _processAlbums( collection: SoundCloudApiSearchItem[] ): SoundCloudTrackDataResult[] { - const max = this.nodelink.options.maxSearchResults ?? 50 + const max = this.nodelink.options.search.maxResults ?? 50 const albums: SoundCloudTrackDataResult[] = [] for (let i = 0; i < collection.length && albums.length < max; i++) { @@ -382,7 +391,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { _processPlaylists( collection: SoundCloudApiSearchItem[] ): SoundCloudTrackDataResult[] { - const max = this.nodelink.options.maxSearchResults ?? 50 + const max = this.nodelink.options.search.maxResults ?? 50 const playlists: SoundCloudTrackDataResult[] = [] for (let i = 0; i < collection.length && playlists.length < max; i++) { @@ -423,7 +432,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { _processAll( collection: SoundCloudApiSearchItem[] ): SoundCloudTrackDataResult[] { - const max = this.nodelink.options.maxSearchResults ?? 50 + const max = this.nodelink.options.search.maxResults ?? 50 const results: SoundCloudTrackDataResult[] = [] for (let i = 0; i < collection.length && results.length < max; i++) { @@ -585,7 +594,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { } } - const limit = this.nodelink.options.maxAlbumPlaylistLength ?? 100 + const limit = this.nodelink.options.playback.maxPlaylistLength ?? 100 const neededIds = ids.slice(0, Math.max(0, limit - complete.length)) if (neededIds.length > 0) { @@ -638,7 +647,7 @@ export default class SoundCloudSource implements SoundCloudSourceState { _processTracks( collection: SoundCloudApiSearchItem[] ): SoundCloudTrackDataResult[] { - const max = this.nodelink.options.maxSearchResults ?? 50 + const max = this.nodelink.options.search.maxResults ?? 50 const tracks: SoundCloudTrackDataResult[] = [] if (!Array.isArray(collection)) return [] diff --git a/src/sources/spotify.ts b/src/sources/spotify.ts index fcc121fd..3308f32f 100644 --- a/src/sources/spotify.ts +++ b/src/sources/spotify.ts @@ -76,11 +76,11 @@ const QUERIES = { }, getPlaylist: { name: 'fetchPlaylist', - hash: 'bb67e0af06e8d6f52b531f97468ee4acd44cd0f82b988e15c2ea47b1148efc77' + hash: 'e4b2953f160e58e38ac025d79b5a9b3aceee5c4c716598e9830bfceb69faff5f' }, getArtist: { name: 'queryArtistOverview', - hash: '35648a112beb1794e39ab931365f6ae4a8d45e65396d641eeda94e4003d41497' + hash: 'ae0e2958a4ab645b35ca19ac04d0495ae12d9c5d7b7286217674801a9aab281a' }, getRecommendations: { name: 'internalLinkRecommenderTrack', @@ -88,7 +88,7 @@ const QUERIES = { }, searchDesktop: { name: 'searchDesktop', - hash: 'fcad5a3e0d5af727fb76966f06971c19cfa2275e6ff7671196753e008611873c' + hash: 'db61238974d27839a136c9dc02bfdbe3fab7635f21cf85976ebff9a1ee281345' } } as const satisfies Record @@ -193,6 +193,15 @@ export default class SpotifySource implements SourceInstance { */ private refreshPromises = new Map>() + /** + * Predictive token refresh timers. + * @internal + */ + private tokenRefreshTimers = new Map< + SpotifyTokenType, + ReturnType + >() + /** * Creates a new SpotifySource instance. * @param nodelink - The worker context providing managers and options. @@ -219,14 +228,24 @@ export default class SpotifySource implements SourceInstance { const cm = this.nodelink.credentialManager if (!cm) return false - this.accessToken = cm.get('spotify_access_token') - this.anonymousToken = cm.get('spotify_anonymous_token') - this.mobileToken = cm.get('spotify_mobile_token') + const accessToken = cm.getEntry?.('spotify_access_token') + const anonymousToken = cm.getEntry?.('spotify_anonymous_token') + const mobileToken = cm.getEntry?.('spotify_mobile_token') + + this.accessToken = + accessToken?.value ?? cm.get('spotify_access_token') + this.accessTokenExpiry = accessToken?.expiresAt ?? null + this.anonymousToken = + anonymousToken?.value ?? cm.get('spotify_anonymous_token') + this.anonymousTokenExpiry = anonymousToken?.expiresAt ?? null + this.mobileToken = + mobileToken?.value ?? cm.get('spotify_mobile_token') + this.mobileTokenExpiry = mobileToken?.expiresAt ?? null const hasOfficial = !!(this.config.clientId && this.config.clientSecret) try { - if (hasOfficial && !this.accessToken) await this._ensureToken('official') + if (hasOfficial) await this._ensureToken('official') await this._ensureToken('anonymous') await this._ensureToken('mobile') @@ -280,7 +299,11 @@ export default class SpotifySource implements SourceInstance { expiry = this.mobileTokenExpiry } - if (token && (!expiry || now < expiry - TOKEN_REFRESH_MARGIN_MS)) { + if ( + token && + typeof expiry === 'number' && + now < expiry - TOKEN_REFRESH_MARGIN_MS + ) { return true } @@ -297,6 +320,26 @@ export default class SpotifySource implements SourceInstance { } } + /** + * Schedules a background token refresh to prevent latency during playback. + * @internal + */ + private _scheduleTokenRefresh(type: SpotifyTokenType, expiry: number) { + const existing = this.tokenRefreshTimers.get(type) + if (existing) clearTimeout(existing) + + const now = Date.now() + const timeUntilRefresh = expiry - now - TOKEN_REFRESH_MARGIN_MS + + if (timeUntilRefresh > 0) { + const timer = setTimeout(() => { + this._refreshToken(type).catch(() => {}) + }, timeUntilRefresh) + timer.unref?.() + this.tokenRefreshTimers.set(type, timer) + } + } + /** * Implementation logic for refreshing various Spotify token tiers. * Handles Client Credentials flow, local Web Player generation, and session cookie flows. @@ -334,6 +377,7 @@ export default class SpotifySource implements SourceInstance { const ttl = (body.expires_in || 3600) * 1000 this.accessTokenExpiry = Date.now() + ttl cm.set('spotify_access_token', this.accessToken, ttl) + this._scheduleTokenRefresh('official', this.accessTokenExpiry) return true } } @@ -357,6 +401,7 @@ export default class SpotifySource implements SourceInstance { this.mobileToken, Math.max(ttl, 60000) ) + this._scheduleTokenRefresh('mobile', expiry) } else { this.anonymousToken = data.accessToken this.anonymousTokenExpiry = expiry @@ -365,6 +410,7 @@ export default class SpotifySource implements SourceInstance { this.anonymousToken, Math.max(ttl, 60000) ) + this._scheduleTokenRefresh('anonymous', expiry) } return true } @@ -396,6 +442,7 @@ export default class SpotifySource implements SourceInstance { this.anonymousToken, Math.max(ttl, 60000) ) + this._scheduleTokenRefresh('anonymous', this.anonymousTokenExpiry) return true } } catch (e) { @@ -419,6 +466,17 @@ export default class SpotifySource implements SourceInstance { } } + /** + * Cleans up all pending timers. + * @public + */ + public cleanup(): void { + for (const timer of this.tokenRefreshTimers.values()) { + clearTimeout(timer) + } + this.tokenRefreshTimers.clear() + } + /** * Unified HTTP client for executing Spotify API calls. * Handles tiered authentication selection, automatic retries on token failure, @@ -733,14 +791,10 @@ export default class SpotifySource implements SourceInstance { return this.getRecommendations(query) try { - let limit = this.config.playlistLoadLimit || 10 - - // fixes the error Argument for field /searchV2 cannot be greater than 1000 - // this is a config issue from the user side, but if this can be used as a workaround, - // we set it to 10 to avoid the error :p. - if (limit > 999) { - limit = 10 - } + const limit = Math.min( + Math.max(this.nodelink.options.search.maxResults ?? 10, 1), + 50 + ) // Priority 1: Internal Search (Rich nodes + Local matching) if (this.anonymousToken || this.config.sp_dc) { @@ -1017,7 +1071,7 @@ export default class SpotifySource implements SourceInstance { */ private async _resolveAlbum(id: string): Promise { const maxTracks = - (this.nodelink.options.maxAlbumPlaylistLength as number) || 1000 + (this.nodelink.options.playback.maxPlaylistLength as number) || 1000 const tracks: TrackData[] = [] let name = 'Unknown Album' @@ -1118,7 +1172,7 @@ export default class SpotifySource implements SourceInstance { */ private async _resolvePlaylist(id: string): Promise { const maxTracks = - (this.nodelink.options.maxAlbumPlaylistLength as number) || 1000 + (this.nodelink.options.playback.maxPlaylistLength as number) || 1000 const tracks: TrackData[] = [] let name = 'Unknown Playlist' diff --git a/src/sources/tidal.ts b/src/sources/tidal.ts index d00b5f37..a9f1fc31 100644 --- a/src/sources/tidal.ts +++ b/src/sources/tidal.ts @@ -186,7 +186,7 @@ export default class TidalSource { } try { - const limit = this.asNumber(this.nodelink.options.maxSearchResults) ?? 10 + const limit = this.asNumber(this.nodelink.options.search.maxResults) ?? 10 const data = await this.getJson('search', { query, limit, diff --git a/src/sources/tiktok.ts b/src/sources/tiktok.ts new file mode 100644 index 00000000..777b06b7 --- /dev/null +++ b/src/sources/tiktok.ts @@ -0,0 +1,335 @@ +import { PassThrough } from 'node:stream' + +import type { + SourceInstance, + SourceResult, + TrackData, + TrackInfo, + TrackStreamResult, + TrackUrlResult, + WorkerNodeLink +} from '../typings/sources/source.types.ts' +import type { TrackEncodeInput } from '../typings/utils.types.ts' +import { encodeTrack, http1makeRequest, logger } from '../utils.ts' + +/** + * Browser user agent sent with TikTok requests. + * @internal + */ +const USER_AGENT = + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36' + +/** + * TikTok player API endpoint used by embeds. + * @internal + */ +const API_BASE = 'https://www.tiktok.com/player/api/v1/items' + +/** + * Regex pattern to extract the video ID from a TikTok URL. + * @internal + */ +const VIDEO_ID_RE = /\/video\/(\d{15,})/ + +/** + * JSON-compatible item structure returned by the TikTok player API. + * @internal + */ +interface TikTokApiItem { + author_info?: { nickname?: string } + desc?: string + video_info?: { + meta?: { duration?: number } + cover?: { url_list?: unknown[] } + profiles?: Array<{ play_addr?: { url_list?: unknown[] } }> + url_list?: unknown[] + } +} + +/** + * Returns the first valid string from an array of unknown values. + * @param list - Array of unknown values (usually strings from API). + * @returns The first valid string, or an empty string if none found. + * @internal + */ +function firstString(list: unknown): string { + if (Array.isArray(list)) { + for (const v of list) { + if (typeof v === 'string' && v.length) return v + } + } + return '' +} + +/** + * TikTok source implementation. + * + * Resolves `tiktok.com/@user/video/ID` URLs and extracts MP4 playback streams + * using the TikTok player API endpoint. + * @public + */ +export default class TiktokSource implements SourceInstance { + /** + * Runtime worker context. + */ + public readonly nodelink: WorkerNodeLink + + /** + * URL patterns this source handles. + */ + public readonly patterns: RegExp[] + + /** + * Match priority used by the source manager (higher wins). + */ + public readonly priority: number + + /** + * Creates a new TikTok source wrapper. + * @param nodelink - Worker runtime context. + */ + public constructor(nodelink: WorkerNodeLink) { + this.nodelink = nodelink + this.patterns = [ + /^https?:\/\/(?:www\.)?tiktok\.com\/@[\w.-]+\/video\/(\d+)/i, + /^https?:\/\/(?:www\.)?vm\.tiktok\.com\/([\w-]+)/i, + /^https?:\/\/(?:www\.)?m\.tiktok\.com\/([\w-]+)/i + ] + this.priority = 60 + } + + /** + * Initializes source resources. No async setup required. + * @returns `true` when the source is ready to accept requests. + */ + public async setup(): Promise { + logger('info', 'Sources', 'Loaded TikTok source.') + return true + } + + /** + * TikTok does not support keyword search. + * @param _query - Unused search query. + * @param _sourceName - Unused source name. + * @param _searchType - Unused search type. + * @returns An empty result. + */ + public async search( + _query?: string, + _sourceName?: string, + _searchType?: string + ): Promise { + return { loadType: 'empty', data: {} } + } + + /** + * Resolves a TikTok video URL into a playable track. + * + * Fetches metadata and playback URLs from the TikTok player API endpoint. + * @param url - Public TikTok video URL. + * @param _type - Unused type hint kept for source-manager compatibility. + * @returns A track result, an empty payload, or a structured exception. + */ + public async resolve(url: string, _type?: string): Promise { + const match = url.match(VIDEO_ID_RE) + const videoId = match?.[1] + if (!videoId) return { loadType: 'empty', data: {} } + + try { + const params = new URLSearchParams({ + item_ids: videoId, + language: 'en', + aid: '1284', + app_name: 'tiktok_web', + device_platform: 'web_pc' + }) + + const response = await http1makeRequest(`${API_BASE}?${params}`, { + method: 'GET', + headers: { + 'User-Agent': USER_AGENT, + Referer: `https://www.tiktok.com/player/v1/${videoId}`, + Accept: 'application/json, text/plain, */*' + } + }) + + if (response.error || response.statusCode !== 200) { + return { + loadType: 'error', + exception: { + message: `TikTok API failed: ${response.error || `Status ${response.statusCode}`}`, + severity: 'fault' + } + } + } + + let data = response.body + if (typeof data === 'string') { + try { + data = JSON.parse(data) + } catch { + return { + loadType: 'error', + exception: { message: 'Invalid TikTok JSON', severity: 'fault' } + } + } + } + + const items = (data as Record)?.items + const item = (Array.isArray(items) ? items[0] : undefined) as + | TikTokApiItem + | undefined + if (!item) return { loadType: 'empty', data: {} } + + const vi = item.video_info ?? {} + + const profile = Array.isArray(vi.profiles) ? vi.profiles[0] : null + const directUrl: string = + firstString(profile?.play_addr?.url_list) || firstString(vi.url_list) + + if (!directUrl) { + return { + loadType: 'error', + exception: { + message: 'No playback URL in TikTok response', + severity: 'fault' + } + } + } + + const author: string = item.author_info?.nickname || 'TikTok User' + const desc: string = item.desc || '' + const title: string = desc.split('#')[0]?.trim() || 'TikTok Video' + + const rawDuration: number = vi.meta?.duration ?? 0 + const durationMs: number = + rawDuration > 0 + ? rawDuration < 1000 + ? rawDuration * 1000 + : rawDuration + : -1 + + const thumbnail: string | null = firstString(vi.cover?.url_list) || null + + const info: TrackEncodeInput = { + identifier: videoId, + isSeekable: true, + author, + length: durationMs, + isStream: false, + position: 0, + title, + uri: url, + artworkUrl: thumbnail, + isrc: null, + sourceName: 'tiktok', + details: [] + } + + const trackData: TrackData = { + encoded: encodeTrack(info), + info: info as unknown as TrackInfo, + pluginInfo: { directUrl, videoId } + } + + return { loadType: 'track', data: trackData } + } catch (e) { + const message = e instanceof Error ? e.message : String(e) + logger('error', 'TikTok', `Resolve failed: ${message}`) + return { loadType: 'error', exception: { message, severity: 'fault' } } + } + } + + /** + * Returns the cached or resolved direct playback URL. + * + * When the track already carries a `pluginInfo.directUrl`, the URL is + * returned immediately. Otherwise the video is re-resolved. + * @param trackInfo - Decoded TikTok track information. + * @param _itag - Unused itag placeholder kept for source-manager compatibility. + * @param _isRecovering - Whether this is a recovery attempt. + * @returns Direct playback URL metadata or a structured exception. + */ + public async getTrackUrl( + trackInfo: TrackInfo, + _itag?: number, + _isRecovering?: boolean + ): Promise { + const pluginInfo = (trackInfo as { pluginInfo?: Record }) + .pluginInfo + const directUrl = pluginInfo?.directUrl as string | undefined + + if (directUrl && typeof directUrl === 'string') { + return { url: directUrl, protocol: 'https', format: 'mp4' } + } + + const uri = trackInfo.uri + if (uri && VIDEO_ID_RE.test(uri)) { + const result = await this.resolve(uri) + if (result.loadType === 'track') { + const trackData = result.data as TrackData + const url = trackData?.pluginInfo?.directUrl as string | undefined + if (url) return { url, protocol: 'https', format: 'mp4' } + } + } + + return { + url: undefined, + protocol: undefined, + format: undefined, + exception: { + message: 'No playable URL for TikTok track', + severity: 'fault' + } + } + } + + /** + * Loads the MP4 stream for a TikTok video. + * + * Proxies the direct playback URL through a `PassThrough` stream. + * @param track - Decoded track information. + * @param url - Resolved playback URL. + * @param _protocol - Optional protocol hint (unused). + * @param _additionalData - Optional additional data (unused). + * @returns A readable stream or a structured exception. + */ + public async loadStream( + _track: TrackInfo, + url: string, + _protocol?: string, + _additionalData?: Record + ): Promise { + try { + const response = await http1makeRequest(url, { + method: 'GET', + streamOnly: true, + headers: { + 'User-Agent': USER_AGENT, + Referer: 'https://www.tiktok.com/' + } + }) + + if (response.error || !response.stream) { + throw new Error(response.error || 'No stream returned') + } + + const stream = new PassThrough() + response.stream.on('data', (chunk: Buffer) => stream.write(chunk)) + response.stream.on('end', () => { + stream.emit('finishBuffering') + stream.end() + }) + response.stream.on('error', (err: Error) => stream.destroy(err)) + + return { stream, type: 'video/mp4' } + } catch (e) { + const message = e instanceof Error ? e.message : String(e) + return { + stream: undefined, + type: undefined, + exception: { message, severity: 'fault' } + } + } + } +} diff --git a/src/sources/twitch.ts b/src/sources/twitch.ts index 243f0240..deb1ce48 100644 --- a/src/sources/twitch.ts +++ b/src/sources/twitch.ts @@ -389,7 +389,7 @@ export default class TwitchSource implements SourceInstance { const res = (await this._gqlRequest(payload)) as TwitchGraphQLResponse const stream = res.data?.user?.stream - if (!stream || stream.type !== 'live') { + if (stream?.type !== 'live') { return { loadType: 'error', exception: { diff --git a/src/sources/twitter.ts b/src/sources/twitter.ts index a3845f7d..6fa07aad 100644 --- a/src/sources/twitter.ts +++ b/src/sources/twitter.ts @@ -42,6 +42,9 @@ interface TwitterRuntimeOptions { * Global maximum search-result limit used by several sources. */ maxSearchResults?: number + search?: { + maxResults?: number + } } /** @@ -685,7 +688,7 @@ export default class TwitterSource { */ private getMaxSearchResults(): number { const options = this.nodelink.options as TwitterRuntimeOptions - const limit = options.maxSearchResults + const limit = options.search?.maxResults return typeof limit === 'number' && Number.isInteger(limit) && limit > 0 ? limit diff --git a/src/sources/vimeo.ts b/src/sources/vimeo.ts index 9a3971aa..27ec3202 100644 --- a/src/sources/vimeo.ts +++ b/src/sources/vimeo.ts @@ -1,9 +1,7 @@ import { Buffer } from 'node:buffer' -import { spawn } from 'node:child_process' -import http, { type IncomingMessage } from 'node:http' -import https from 'node:https' -import { PassThrough, type Writable } from 'node:stream' -import zlib from 'node:zlib' +import { once } from 'node:events' +import { PassThrough } from 'node:stream' +import { pipeline } from 'node:stream/promises' import HLSHandler from '../playback/hls/HLSHandler.ts' import type { SourceResult, @@ -17,26 +15,23 @@ import type { VimeoCdnConfig, VimeoConfig, VimeoConfigFiles, - VimeoCurlOptions, VimeoDecodedTrack, VimeoHandoffEntry, - VimeoHttpRequestOptions, - VimeoHttpResponse, VimeoNodeLinkContext, VimeoOembedResponse, VimeoPlaylist, VimeoPlaylistData, - VimeoPlaylistSegment, - VimeoProgressiveResult, VimeoSegmentedResult, - VimeoSourceState, VimeoStreamResult, VimeoUserData, VimeoVideoMetadata, VimeoVideoTrack } from '../typings/sources/vimeo.types.ts' -import type { TrackEncodeInput } from '../typings/utils.types.ts' -import { encodeTrack, logger } from '../utils.ts' +import type { + HttpRequestOptions, + TrackEncodeInput +} from '../typings/utils.types.ts' +import { encodeTrack, http1makeRequest, logger } from '../utils.ts' const VIMEO_PATTERNS: RegExp[] = [ /^https?:\/\/(?:www\.)?vimeo\.com\/(\d+)(?:|[/?#])/i, @@ -48,815 +43,214 @@ const VIMEO_PATTERNS: RegExp[] = [ ] const VIMEO_BASE = 'https://vimeo.com' -const VIMEO_PLAYER_BASE = 'https://player.vimeo.com' +const VIMEO_API_BASE = 'https://api.vimeo.com' const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36' - -const CDN_PRIORITY = ['akfire_interconnect_quic', 'fastly_skyfire'] const REQUEST_TIMEOUT = 15000 -const MAX_REDIRECTS = 5 - -const SEGMENT_HIGH_WATER_MARK = 64 * 1024 -const PROGRESSIVE_HIGH_WATER_MARK = 16 * 1024 - const HANDOFF_TTL = 15000 const HANDOFF_MAX = 20 +const CDN_PRIORITY = ['akfire_interconnect_quic', 'fastly_skyfire'] +const PLAYER_QUERY = + 'autoplay=0&muted=0&badge=1&title=0&portrait=0&byline=0&share=1&like=1&watch_later=1&transparent=0&ask_ai=0&transcript=0&preload=auto&chapters=1&airplay=1&audio_tracks=1&chromecast=1&cc=1&cc_track_menu=1&disable_context_menu=0&colors=000000%2C00adef%2Cffffff%2C000000&fullscreen=1&vimeo_logo=1&pip=1&playbar=1&play_button_position=auto&quality_selector=1&speed=1&skipping_forward=1&volume=1&outro=beginning' -const HTTP_AGENT = new http.Agent({ - keepAlive: true, - maxSockets: 16, - maxFreeSockets: 4 -}) -const HTTPS_AGENT = new https.Agent({ - keepAlive: true, - maxSockets: 16, - maxFreeSockets: 4 -}) - -const _CONFIG_PATTERNS: RegExp[] = [ - /window\.playerConfig\s*=\s*(\{[\s\S]*?\});\s*(?:window\.|<\/script>|if\s*\()/i, - /window\.playerConfig\s*=\s*(\{[\s\S]*?"video"[\s\S]*?\})\s*;/i, - /"config"\s*:\s*(\{[\s\S]*?"request"[\s\S]*?\})\s*[,}]/i -] - -const _functions = { - parseJson(data: Buffer | string): unknown { - try { - const str = Buffer.isBuffer(data) ? data.toString('utf8') : data - return JSON.parse(str) - } catch { - return null - } - }, - - unescapeString(text: string): string { - if (!text) return '' - const s = String(text) - return s - .replaceAll('\\u002F', '/') - .replaceAll('\\/', '/') - .replaceAll('\\u0026', '&') - .replaceAll('\\u003C', '<') - .replaceAll('\\u003E', '>') - .replaceAll('\\"', '"') - .replaceAll('&', '&') - }, - - extractVideoId(url: string): string | null { - if (!url) return null - for (const pattern of VIMEO_PATTERNS) { - const match = url.match(pattern) - if (match?.[1]) return match[1] - } - return null - }, - - extractHashParam(url: string): string | null { - try { - return new URL(url).searchParams.get('h') - } catch { - return null - } - }, - - decompressBody( - body: Buffer, - encoding: string | string[] | undefined - ): Buffer { - if (!encoding || !body) return body - const enc = Array.isArray(encoding) ? encoding[0] : encoding - try { - switch (enc) { - case 'gzip': - return zlib.gunzipSync(body) - case 'deflate': - return zlib.inflateSync(body) - case 'br': - return zlib.brotliDecompressSync(body) - default: - return body - } - } catch { - return body - } - }, - - sortTracksByQuality(tracks: VimeoAudioTrack[]): VimeoAudioTrack[] { - return [...tracks].sort((a, b) => { - const aSampleRate = a.sample_rate || a.audio_sample_rate || 0 - const bSampleRate = b.sample_rate || b.audio_sample_rate || 0 - - const aIs48k = aSampleRate >= 44100 - const bIs48k = bSampleRate >= 44100 - if (aIs48k && !bIs48k) return -1 - if (bIs48k && !aIs48k) return 1 - - const aBitrate = a.avg_bitrate || a.bitrate || 0 - const bBitrate = b.avg_bitrate || b.bitrate || 0 - return bBitrate - aBitrate - }) - }, - - selectBestAudioTrack(tracks: VimeoAudioTrack[]): VimeoAudioTrack | null { - if (!Array.isArray(tracks) || tracks.length === 0) return null - - const validTracks = tracks.filter((t) => (t?.segments?.length ?? 0) > 0) - if (validTracks.length === 0) return null - - const mp42Aac = validTracks.filter((t) => { - const codecs = t.codecs || '' - const format = t.format || '' - return ( - codecs.includes('mp4a') && - (format === 'mp42' || format === 'iso5' || format === 'iso6') - ) - }) - - if (mp42Aac.length) - return _functions.sortTracksByQuality(mp42Aac)[0] ?? null - - const aac = validTracks.filter((t) => (t.codecs || '').includes('mp4a')) - if (aac.length) return _functions.sortTracksByQuality(aac)[0] ?? null - - let best: VimeoAudioTrack | null = validTracks[0] ?? null - for (const t of validTracks) { - const bw = t?.avg_bitrate || t?.bitrate || 0 - if (bw > ((best?.avg_bitrate ?? 0) || (best?.bitrate ?? 0))) { - best = t - } - } - return best - }, - - playlistDir(playlistUrl: string): string { - const urlWithoutQuery = playlistUrl.split('?')[0] || '' - return urlWithoutQuery.substring(0, urlWithoutQuery.lastIndexOf('/') + 1) - }, - - buildSegmentUrl( - playlistDir: string, - basePath: string, - trackPath: string, - segmentPath: string - ): string | null { - try { - const relativePath = (basePath || '') + (trackPath || '') + segmentPath - return new URL(relativePath, playlistDir).href - } catch (err) { - logger( - 'error', - 'Sources', - `[vimeo] Failed to build segment URL: ${err instanceof Error ? err.message : String(err)}` - ) - return null - } - }, - - resolveRedirectUrl(currentUrl: string, location: string): string | null { - if (!location) return null - if (location.startsWith('/')) { - const u = new URL(currentUrl) - return `${u.protocol}//${u.host}${location}` - } - return location - }, - - makeHeaders(extra: Record): Record { - return { - 'User-Agent': USER_AGENT, - Accept: '*/*', - 'Accept-Language': 'en-US,en;q=0.9', - Connection: 'keep-alive', - ...extra - } - }, - - async httpRequest( - url: string, - options: VimeoHttpRequestOptions = {} - ): Promise { - let currentUrl = url - const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS - - for (let i = 0; i <= maxRedirects; i++) { - const urlObj = new URL(currentUrl) - const isHttps = urlObj.protocol === 'https:' - const httpLib = isHttps ? https : http - - const headers = _functions.makeHeaders({ - 'Accept-Encoding': 'gzip, deflate, br', - ...options.headers - }) - - const { timeout = REQUEST_TIMEOUT } = options - - const res: IncomingMessage = await new Promise((resolve, reject) => { - const req = httpLib.request( - { - hostname: urlObj.hostname, - port: urlObj.port || (isHttps ? 443 : 80), - path: urlObj.pathname + urlObj.search, - method: options.method || 'GET', - headers, - timeout, - agent: isHttps ? HTTPS_AGENT : HTTP_AGENT - }, - resolve - ) - - req.once('error', reject) - req.once('timeout', () => req.destroy(new Error('Request timeout'))) - req.end() - }) - - if ( - res.statusCode !== undefined && - res.statusCode >= 300 && - res.statusCode < 400 && - res.headers.location - ) { - res.resume() - const redirectUrl = _functions.resolveRedirectUrl( - currentUrl, - res.headers.location - ) - if (!redirectUrl) throw new Error('Redirect without location') - currentUrl = redirectUrl - continue - } - - const chunks: Buffer[] = [] - let totalSize = 0 - const maxSize = options.maxSize || 10 * 1024 * 1024 - - const statusCode = res.statusCode ?? 0 - const resHeaders = res.headers - - const body: Buffer = await new Promise((resolve, reject) => { - res.on('data', (chunk: Buffer) => { - totalSize += chunk.length - if (totalSize > maxSize) { - res.destroy(new Error('Response too large')) - return - } - chunks.push(chunk) - }) - - res.once('error', (err: Error) => { - chunks.length = 0 - reject(err) - }) - - res.once('end', () => { - const raw = Buffer.concat(chunks, totalSize) - chunks.length = 0 - resolve( - _functions.decompressBody(raw, resHeaders['content-encoding']) - ) - }) - }) - - return { statusCode, headers: resHeaders, body } - } - - throw new Error('Too many redirects') - }, - - async pumpUrlToWritable( - url: string, - writable: Writable, - options: VimeoHttpRequestOptions = {} - ): Promise { - let currentUrl = url - const maxRedirects = options.maxRedirects ?? MAX_REDIRECTS - const timeout = options.timeout ?? REQUEST_TIMEOUT - const maxSize = options.maxSize ?? 0 - - let req: http.ClientRequest | null = null - let res: IncomingMessage | null = null - let done = false - - const cancel = (err?: Error): void => { - if (done) return - done = true - if (res && !res.destroyed) res.destroy(err) - if (req && !req.destroyed) req.destroy(err) - } - - const onWritableClose = (): void => cancel(new Error('Destination closed')) - const onWritableError = (err: Error): void => cancel(err) - - writable.once('close', onWritableClose) - writable.once('error', onWritableError) - - try { - for (let i = 0; i <= maxRedirects; i++) { - if (writable.destroyed) throw new Error('Destination destroyed') - - const urlObj = new URL(currentUrl) - const isHttps = urlObj.protocol === 'https:' - const httpLib = isHttps ? https : http - - const headers = _functions.makeHeaders({ - 'Accept-Encoding': 'identity', - ...options.headers - }) - - res = await new Promise((resolve, reject) => { - const newReq = httpLib.request( - { - hostname: urlObj.hostname, - port: urlObj.port || (isHttps ? 443 : 80), - path: urlObj.pathname + urlObj.search, - method: 'GET', - headers, - timeout, - agent: isHttps ? HTTPS_AGENT : HTTP_AGENT - }, - resolve - ) - - req = newReq - newReq.once('error', reject) - newReq.once('timeout', () => - newReq.destroy(new Error('Request timeout')) - ) - newReq.end() - }) - - const code = res.statusCode ?? 0 - - if (code >= 300 && code < 400 && res.headers.location) { - res.resume() - const redirectUrl = _functions.resolveRedirectUrl( - currentUrl, - res.headers.location - ) - if (!redirectUrl) throw new Error('Redirect without location') - currentUrl = redirectUrl - req = null - res = null - continue - } - - if (code >= 400) { - res.resume() - throw new Error(`HTTP ${code}`) - } - - const currentRes = res - const bytes: number = await new Promise((resolve, reject) => { - let total = 0 - let draining = false - - const cleanup = (): void => { - currentRes.removeListener('data', onData) - currentRes.removeListener('end', onEnd) - currentRes.removeListener('error', onErr) - currentRes.removeListener('close', onClose) - writable.removeListener('drain', onDrain) - } - - const onDrain = (): void => { - draining = false - if (!currentRes.destroyed && !writable.destroyed) - currentRes.resume() - } - - const onData = (chunk: Buffer): void => { - total += chunk.length - if (maxSize && total > maxSize) { - cleanup() - currentRes.destroy(new Error('Response too large')) - return - } - - if (writable.destroyed) { - cleanup() - currentRes.destroy(new Error('Destination destroyed')) - return - } - - if (!writable.write(chunk) && !draining) { - draining = true - currentRes.pause() - writable.once('drain', onDrain) - } - } - - const onEnd = (): void => { - cleanup() - resolve(total) - } - - const onErr = (err: Error): void => { - cleanup() - reject(err) - } - - const onClose = (): void => { - if (done) return - cleanup() - reject(new Error('Response closed early')) - } - - currentRes.on('data', onData) - currentRes.once('end', onEnd) - currentRes.once('error', onErr) - currentRes.once('close', onClose) - }) +interface VimeoAnonymousVideoResponse { + embed_player_config_url?: string +} - return bytes - } +interface VimeoSignature { + videoId: string + value: string + jwt: string +} - throw new Error('Too many redirects') - } finally { - done = true - writable.removeListener('close', onWritableClose) - writable.removeListener('error', onWritableError) - req = null - res = null - } +interface VimeoPageProps { + clipId?: string | number + pageMetadata?: { + clipSignature?: string + } + viewerBootstrap?: { + jwt?: string } } -function curlRequest( - url: string, - options: VimeoCurlOptions = {} -): Promise { - return new Promise((resolve, reject) => { - const args: string[] = [ - '-s', - '-L', - '-A', - USER_AGENT, - '-H', - 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', - '-H', - 'Accept-Language: en-US,en;q=0.9', - '-H', - 'Accept-Encoding: gzip, deflate, br', - '-H', - 'DNT: 1', - '-H', - 'Connection: keep-alive', - '-H', - 'Upgrade-Insecure-Requests: 1', - '-H', - 'Sec-Fetch-Dest: iframe', - '-H', - 'Sec-Fetch-Mode: navigate', - '-H', - 'Sec-Fetch-Site: cross-site', - '--compressed', - '-w', - '\n%{http_code}', - '-m', - String(Math.floor(REQUEST_TIMEOUT / 1000)) - ] - - if (options.referer) args.push('-H', `Referer: ${options.referer}`) - if (options.origin) args.push('-H', `Origin: ${options.origin}`) - args.push(url) - - const curlProcess = spawn('curl', args) - const outputChunks: Buffer[] = [] - let completed = false - - const cleanup = (): void => { - outputChunks.length = 0 - curlProcess.stdout.removeAllListeners() - curlProcess.stderr.removeAllListeners() - curlProcess.removeAllListeners() - } - - const timeoutId = setTimeout(() => { - if (completed) return - completed = true - curlProcess.kill('SIGTERM') - cleanup() - reject(new Error('curl timeout')) - }, REQUEST_TIMEOUT) - timeoutId.unref?.() - - curlProcess.stdout.on('data', (chunk: Buffer) => outputChunks.push(chunk)) - curlProcess.stderr.resume() - - curlProcess.once('error', (err: Error) => { - clearTimeout(timeoutId) - if (completed) return - completed = true - cleanup() - reject(err) - }) +interface VimeoNextData { + buildId?: string + locale?: string + props?: { + pageProps?: VimeoPageProps + } +} - curlProcess.once('close', (exitCode: number | null) => { - clearTimeout(timeoutId) - if (completed) return - completed = true +interface VimeoNextPageResponse { + pageProps?: VimeoPageProps +} - if (exitCode !== 0) { - cleanup() - return reject(new Error(`curl exited with code ${exitCode}`)) - } +function parseNextData(html: string): VimeoNextData | null { + const json = html.match( + /]*\bid\s*=\s*["']__NEXT_DATA__["'][^>]*>([\s\S]*?)<\/script>/i + )?.[1] + if (!json) return null - const output = Buffer.concat(outputChunks).toString('utf8') - outputChunks.length = 0 + try { + return JSON.parse(json) as VimeoNextData + } catch { + return null + } +} - const lastNewlineIndex = output.lastIndexOf('\n') - const statusCode = parseInt(output.slice(lastNewlineIndex + 1), 10) || 0 - const bodyText = output.slice(0, lastNewlineIndex) +function getSignature(pageProps: VimeoPageProps): VimeoSignature | null { + const signature = pageProps.pageMetadata?.clipSignature + const jwt = pageProps.viewerBootstrap?.jwt + if (!pageProps.clipId || !signature || !jwt) return null - cleanup() - resolve({ - statusCode, - headers: {}, - body: Buffer.from(bodyText, 'utf8') - }) - }) - }) + return { + videoId: String(pageProps.clipId), + value: signature, + jwt + } } -class SegmentStreamer { - declare playlistData: VimeoPlaylistData | null - declare outputStream: PassThrough | null - declare aborted: boolean - declare segmentsFetched: number - declare bytesWritten: number - declare _playlistDir: string | null - - constructor(playlistData: VimeoPlaylistData, outputStream: PassThrough) { - this.playlistData = playlistData - this.outputStream = outputStream - this.aborted = false - this.segmentsFetched = 0 - this.bytesWritten = 0 - this._playlistDir = null +function extractVideoId(url: string): string | null { + for (const pattern of VIMEO_PATTERNS) { + const match = url.match(pattern) + if (match?.[1]) return match[1] } + return null +} - abort(): void { - this.aborted = true +function extractHashParam(url: string): string | null { + try { + return new URL(url).searchParams.get('h') + } catch { + return null } +} - async start(): Promise { - const { - playlistUrl, - basePath, - trackPath, - initSegment, - segments, - isDashFormat - } = this.playlistData || {} - - if (!playlistUrl || !Array.isArray(segments) || !this.outputStream) { - if (this.outputStream && !this.outputStream.destroyed) { - this.outputStream.destroy(new Error('Invalid Vimeo playlist data')) - } - return - } - - const outputStream = this.outputStream - const playlistDir = _functions.playlistDir(playlistUrl) - this._playlistDir = playlistDir - - const onClose = (): void => this.abort() - const onError = (): void => this.abort() - - outputStream.once('close', onClose) - outputStream.once('error', onError) - - try { - if (initSegment && !this.aborted) { - const initBuffer = Buffer.from(initSegment, 'base64') - logger( - 'debug', - 'Sources', - `[vimeo] Writing init segment: ${initBuffer.length} bytes (dash: ${isDashFormat})` - ) - - if (outputStream.destroyed || this.aborted) return - if (!outputStream.write(initBuffer)) { - await new Promise((resolve) => { - const onDrain = (): void => { - cleanup() - resolve() - } - const onClose2 = (): void => { - cleanup() - resolve() - } - const cleanup = (): void => { - outputStream.removeListener('drain', onDrain) - outputStream.removeListener('close', onClose2) - } - outputStream.once('drain', onDrain) - outputStream.once('close', onClose2) - }) - } - this.bytesWritten += initBuffer.length - } - - for (let i = 0; i < segments.length; i++) { - if (this.aborted || outputStream.destroyed) break - - const segmentPath = segments[i]?.url - if (!segmentPath) continue - - const segmentUrl = _functions.buildSegmentUrl( - playlistDir, - basePath || '', - trackPath || '', - segmentPath - ) - - if (!segmentUrl) { - logger( - 'warn', - 'Sources', - `[vimeo] Failed to build segment URL: ${segmentPath}` - ) - continue - } - - try { - const bytes = await _functions.pumpUrlToWritable( - segmentUrl, - outputStream, - { - headers: { - Accept: '*/*', - Origin: VIMEO_BASE, - Referer: `${VIMEO_BASE}/`, - 'Sec-Fetch-Dest': 'empty', - 'Sec-Fetch-Mode': 'cors', - 'Sec-Fetch-Site': 'cross-site' - }, - timeout: REQUEST_TIMEOUT, - maxSize: 5 * 1024 * 1024 - } - ) - - if (this.aborted || outputStream.destroyed) break - if (bytes > 0) { - this.segmentsFetched++ - this.bytesWritten += bytes - } else { - logger( - 'warn', - 'Sources', - `[vimeo] Empty segment ${i + 1}/${segments.length}` - ) - } - } catch (err) { - if (this.aborted || outputStream.destroyed) break - logger( - 'warn', - 'Sources', - `[vimeo] Segment fetch error (${i + 1}/${segments.length}): ${err instanceof Error ? err.message : String(err)}` - ) - } - } +function getPlaylistDirectory(url: string): string { + const parsed = new URL(url) + parsed.pathname = parsed.pathname.slice( + 0, + parsed.pathname.lastIndexOf('/') + 1 + ) + parsed.search = '' + parsed.hash = '' + return parsed.toString() +} - logger( - 'debug', - 'Sources', - `[vimeo] Streaming complete: ${this.segmentsFetched}/${segments.length} segments, ${this.bytesWritten} bytes` - ) +function buildSegmentUrl( + playlistUrl: string, + basePath: string, + trackPath: string, + segmentPath: string +): string { + if (/^https?:\/\//i.test(segmentPath)) return segmentPath + return new URL( + `${basePath}${trackPath}${segmentPath}`, + getPlaylistDirectory(playlistUrl) + ).toString() +} - if (!this.aborted && !outputStream.destroyed) { - outputStream.emit('finishBuffering') - outputStream.end() - } - } catch (error) { - logger( - 'error', - 'Sources', - `[vimeo] Segment streaming error: ${error instanceof Error ? error.message : String(error)}` +function selectAudioTrack(tracks: VimeoAudioTrack[]): VimeoAudioTrack | null { + const playable = tracks.filter( + (track) => track.segments?.length && track.init_segment + ) + const candidates = playable.filter((track) => + /mp4a|aac/i.test(track.codecs ?? '') + ) + + return ( + candidates.sort((a, b) => { + const aSampleRate = a.sample_rate ?? a.audio_sample_rate ?? 0 + const bSampleRate = b.sample_rate ?? b.audio_sample_rate ?? 0 + if (aSampleRate !== bSampleRate) return bSampleRate - aSampleRate + return ( + (b.avg_bitrate ?? b.bitrate ?? 0) - (a.avg_bitrate ?? a.bitrate ?? 0) ) - if (!outputStream.destroyed) { - outputStream.destroy( - error instanceof Error ? error : new Error(String(error)) - ) - } - } finally { - outputStream.removeListener('close', onClose) - outputStream.removeListener('error', onError) - this.cleanup() - } - } - - cleanup(): void { - this.aborted = true - this.playlistData = null - this.outputStream = null - this._playlistDir = null - } + })[0] ?? null + ) } -export default class VimeoSource implements VimeoSourceState { - declare nodelink: VimeoNodeLinkContext - declare config: VimeoNodeLinkContext['options'] - declare searchTerms: string[] - declare patterns: RegExp[] - declare priority: number - - declare _curlAvailable: boolean | null - declare _activeStreams: Set - declare _handoff: Map - - constructor(nodelink: VimeoNodeLinkContext) { +/** + * Vimeo source implementation. + * + * Resolves public Vimeo pages through the anonymous player configuration flow + * and streams the selected adaptive audio track. + * + * @public + */ +export default class VimeoSource { + public readonly nodelink: VimeoNodeLinkContext + public readonly config: VimeoNodeLinkContext['options'] + public readonly searchTerms: string[] + public readonly patterns: RegExp[] + public readonly priority: number + private readonly activeStreams = new Set() + private readonly handoff = new Map() + + /** + * Creates the Vimeo source. + * + * @param nodelink - NodeLink worker context. + */ + public constructor(nodelink: VimeoNodeLinkContext) { this.nodelink = nodelink this.config = nodelink.options this.searchTerms = [] this.patterns = VIMEO_PATTERNS this.priority = 70 - - this._curlAvailable = null - this._activeStreams = new Set() - this._handoff = new Map() } - _handoffGet(key: string): VimeoSegmentedResult | null { - const entry = this._handoff.get(key) - if (!entry) return null - if (Date.now() >= entry.expiresAt) { - this._handoff.delete(key) - return null - } - return entry.value - } - - _handoffSet(key: string, value: VimeoSegmentedResult): void { - const now = Date.now() - for (const [k, v] of this._handoff) { - if (now >= v.expiresAt) this._handoff.delete(k) - } - while (this._handoff.size >= HANDOFF_MAX) { - const firstKey = this._handoff.keys().next().value - if (firstKey !== undefined) this._handoff.delete(firstKey) - } - this._handoff.set(key, { value, expiresAt: now + HANDOFF_TTL }) - } - - _handoffTake(key: string): VimeoSegmentedResult | null { - const value = this._handoffGet(key) - if (value) this._handoff.delete(key) - return value - } - - async _checkCurlAvailability(): Promise { - if (this._curlAvailable !== null) return this._curlAvailable - - return new Promise((resolve) => { - const curlProcess = spawn('curl', ['--version']) - - curlProcess.once('error', () => { - this._curlAvailable = false - resolve(false) - }) - - curlProcess.once('close', (code: number | null) => { - this._curlAvailable = code === 0 - resolve(this._curlAvailable) - }) - - curlProcess.stdout.resume() - curlProcess.stderr.resume() - }) - } - - async setup(): Promise { - await this._checkCurlAvailability() + /** + * Initializes the source. + * + * @returns `true` when the source is ready. + */ + public async setup(): Promise { return true } - match(url: string): boolean { - return _functions.extractVideoId(url) !== null + /** + * Checks whether a URL belongs to Vimeo. + * + * @param url - Candidate URL. + * @returns Whether the URL contains a supported Vimeo video id. + */ + public match(url: string): boolean { + return extractVideoId(url) !== null } - async search(): Promise { - return { loadType: 'empty', data: {} as Record } + /** + * Vimeo does not expose text search through this source. + * + * @returns Empty search result. + */ + public async search(): Promise { + return { loadType: 'empty', data: {} } } - async resolve(url: string): Promise { - const videoId = _functions.extractVideoId(url) - const hashParam = _functions.extractHashParam(url) - if (!videoId) - return { loadType: 'empty', data: {} as Record } + /** + * Resolves Vimeo metadata into an encoded track. + * + * @param url - Vimeo video URL. + * @returns Resolved track or an empty result. + */ + public async resolve(url: string): Promise { + const videoId = extractVideoId(url) + const hashParam = extractHashParam(url) + if (!videoId) return { loadType: 'empty', data: {} } - const metadata = await this._fetchVideoMetadata(videoId, hashParam) - if (!metadata?.title) - return { loadType: 'empty', data: {} as Record } + const metadata = await this.fetchVideoMetadata(videoId, hashParam) + if (!metadata?.title) return { loadType: 'empty', data: {} } const trackInfo: TrackEncodeInput & { userData?: VimeoUserData } = { title: metadata.title, author: metadata.author || 'Unknown', - length: metadata.durationMs || 0, + length: metadata.durationMs, identifier: videoId, isSeekable: true, isStream: false, - uri: `https://vimeo.com/${videoId}${hashParam ? `?h=${hashParam}` : ''}`, - artworkUrl: metadata.artworkUrl || null, + uri: `${VIMEO_BASE}/${videoId}${hashParam ? `?h=${hashParam}` : ''}`, + artworkUrl: metadata.artworkUrl, isrc: null, sourceName: 'vimeo', position: 0, @@ -868,16 +262,23 @@ export default class VimeoSource implements VimeoSourceState { loadType: 'track', data: { encoded: encodeTrack(trackInfo), - info: trackInfo as unknown as TrackInfo, + info: trackInfo as TrackInfo, pluginInfo: {} } } } - async getTrackUrl(decodedTrack: VimeoDecodedTrack): Promise { - const videoId = decodedTrack?.identifier - const hashParam = decodedTrack?.userData?.vimeo?.h || null - + /** + * Resolves the playable Vimeo stream. + * + * @param decodedTrack - Decoded Vimeo track. + * @returns Adaptive, HLS, or progressive stream descriptor. + */ + public async getTrackUrl( + decodedTrack: VimeoDecodedTrack + ): Promise { + const videoId = decodedTrack.identifier + const hashParam = decodedTrack.userData?.vimeo?.h ?? null if (!videoId) { return { exception: { @@ -888,22 +289,19 @@ export default class VimeoSource implements VimeoSourceState { } try { - const result = await this._extractFromEmbed(videoId, hashParam) - if (result && 'playlistData' in result && result.playlistData) { - const key = `handoff:${videoId}:${hashParam || ''}` - this._handoffSet(key, result as VimeoSegmentedResult) + const config = await this.fetchPlayerConfig(videoId, hashParam) + const result = await this.extractStream(config, videoId) + if ('playlistData' in result && result.playlistData) { + this.setHandoff(this.handoffKey(videoId, hashParam), result) } - return result as TrackUrlResult - } catch (err) { - logger( - 'warn', - 'Sources', - `[vimeo] Embed extraction failed for ${videoId}: ${err instanceof Error ? err.message : String(err)}` - ) + return result + } catch (error) { + const message = + error instanceof Error ? error.message : 'Unknown Vimeo error' + logger('warn', 'Vimeo', `Stream extraction failed: ${message}`) return { exception: { - message: - 'Failed to extract Vimeo stream. Video may be private or require authentication.', + message: `Failed to extract Vimeo stream: ${message}`, severity: 'fault', cause: 'Upstream' } @@ -911,20 +309,23 @@ export default class VimeoSource implements VimeoSourceState { } } - async loadStream( + /** + * Opens a Vimeo media stream. + * + * @param decodedTrack - Decoded Vimeo track. + * @param url - URL returned by `getTrackUrl`. + * @param protocol - Vimeo stream protocol. + * @returns Playable stream result. + */ + public async loadStream( decodedTrack: VimeoDecodedTrack, url: string, protocol?: string ): Promise { if (protocol === 'hls') { - logger('debug', 'Sources', '[vimeo] Loading HLS stream') return { stream: new HLSHandler(url, { - headers: { - 'User-Agent': USER_AGENT, - Referer: `${VIMEO_BASE}/`, - Origin: VIMEO_BASE - }, + headers: this.mediaHeaders(), localAddress: this.nodelink.routePlanner?.getIP?.() ?? undefined, type: 'mpegts' }), @@ -932,663 +333,498 @@ export default class VimeoSource implements VimeoSourceState { } } - const isProgressive = protocol === 'https' || protocol === 'http' - const highWaterMark = isProgressive - ? PROGRESSIVE_HIGH_WATER_MARK - : SEGMENT_HIGH_WATER_MARK - const stream = new PassThrough({ - highWaterMark, + highWaterMark: 64 * 1024, emitClose: true, autoDestroy: true }) - - this._activeStreams.add(stream) - + this.activeStreams.add(stream) const cleanup = (): void => { - this._activeStreams.delete(stream) - ;( - stream as PassThrough & { _segmentStreamer?: SegmentStreamer | null } - )._segmentStreamer = null + this.activeStreams.delete(stream) } - stream.once('close', cleanup) stream.once('error', cleanup) - if (isProgressive) { - setImmediate(() => { - _functions - .pumpUrlToWritable(url, stream, { timeout: REQUEST_TIMEOUT }) - .then(() => { - if (!stream.destroyed) { - stream.emit('finishBuffering') - stream.end() - } - }) - .catch((err: Error) => { - if (!stream.destroyed) stream.destroy(err) - }) - }) - return { stream } + if (protocol === 'http' || protocol === 'https') { + void this.pipeProgressive(url, stream) + return { stream, type: 'mp4' } } if (protocol === 'segmented') { - const videoId = decodedTrack?.identifier - const hashParam = decodedTrack?.userData?.vimeo?.h || '' - const key = `handoff:${videoId}:${hashParam}` - - setImmediate(async () => { - try { - if (stream.destroyed) return - - let playlistResult = this._handoffTake(key) - if (!playlistResult?.playlistData) { - playlistResult = await this._fetchPlaylist( - url, - videoId || 'unknown' - ) - } - - if (!playlistResult?.playlistData) - throw new Error('Vimeo playlistData not found') - - const segmentStreamer = new SegmentStreamer( - playlistResult.playlistData, - stream - ) - ;( - stream as PassThrough & { - _segmentStreamer?: SegmentStreamer | null - } - )._segmentStreamer = segmentStreamer - await segmentStreamer.start() - } catch (err) { - if (!stream.destroyed) - stream.destroy(err instanceof Error ? err : new Error(String(err))) - } - }) + const hashParam = decodedTrack.userData?.vimeo?.h ?? null + const key = this.handoffKey(decodedTrack.identifier, hashParam) + const result = this.takeHandoff(key) ?? (await this.fetchPlaylist(url)) + if (!result.playlistData) { + stream.destroy(new Error('Vimeo playlist data is missing')) + return { stream } + } - return { stream } + void this.pipeSegments(result.playlistData, stream) + return { stream, type: result.format } } - stream.destroy(new Error(`Unsupported protocol: ${protocol}`)) + stream.destroy(new Error(`Unsupported Vimeo protocol: ${protocol}`)) return { stream } } - cleanupAllStreams(): void { - for (const stream of this._activeStreams) { + /** + * Destroys active Vimeo streams and cached handoffs. + */ + public cleanupAllStreams(): void { + for (const stream of this.activeStreams) { if (!stream.destroyed) stream.destroy() } - this._activeStreams.clear() - this._handoff.clear() + this.activeStreams.clear() + this.handoff.clear() } - async _fetchVideoMetadata( - videoId: string, - hashParam: string | null - ): Promise { - try { - const targetUrl = hashParam - ? `https://vimeo.com/${videoId}?h=${hashParam}` - : `https://vimeo.com/${videoId}` - - const oembedUrl = `https://vimeo.com/api/oembed.json?url=${encodeURIComponent(targetUrl)}` - const response = await _functions.httpRequest(oembedUrl, { - headers: { Accept: 'application/json' }, - maxSize: 1024 * 1024 - }) - - if (response.statusCode >= 400) - return this._fetchMetadataFromApiV2(videoId) - - const data = _functions.parseJson( - response.body - ) as VimeoOembedResponse | null - if (!data?.title) return this._fetchMetadataFromApiV2(videoId) + private requestOptions( + headers: Record = {} + ): HttpRequestOptions { + return { + headers: { + 'User-Agent': USER_AGENT, + ...headers + }, + timeout: REQUEST_TIMEOUT, + maxResponseBodyBytes: 5 * 1024 * 1024 + } + } - return { - title: data.title, - author: data.author_name || 'Unknown', - durationMs: (data.duration || 0) * 1000, - artworkUrl: data.thumbnail_url || null - } - } catch { - return this._fetchMetadataFromApiV2(videoId) + private mediaHeaders(): Record { + return { + 'User-Agent': USER_AGENT, + Accept: '*/*', + Origin: VIMEO_BASE, + Referer: `${VIMEO_BASE}/` } } - async _fetchMetadataFromApiV2( - videoId: string + private async fetchVideoMetadata( + videoId: string, + hashParam: string | null ): Promise { + const targetUrl = `${VIMEO_BASE}/${videoId}${hashParam ? `?h=${hashParam}` : ''}` + const oembedUrl = `${VIMEO_BASE}/api/oembed.json?url=${encodeURIComponent(targetUrl)}` + try { - const response = await _functions.httpRequest( - `https://vimeo.com/api/v2/video/${videoId}.json`, - { - headers: { Accept: 'application/json' }, - maxSize: 1024 * 1024 - } + const response = await http1makeRequest( + oembedUrl, + this.requestOptions({ Accept: 'application/json' }) ) + const data = response.body as VimeoOembedResponse + if (response.statusCode === 200 && data?.title) { + return { + title: data.title, + author: data.author_name ?? 'Unknown', + durationMs: (data.duration ?? 0) * 1000, + artworkUrl: data.thumbnail_url ?? null + } + } + } catch {} - if (response.statusCode >= 400) return null - - const data = _functions.parseJson(response.body) as - | VimeoApiV2Video[] - | null - if (!Array.isArray(data) || !data[0]) return null - - const video = data[0] + try { + const response = await http1makeRequest( + `${VIMEO_BASE}/api/v2/video/${videoId}.json`, + this.requestOptions({ Accept: 'application/json' }) + ) + const data = response.body as VimeoApiV2Video[] + const video = Array.isArray(data) ? data[0] : undefined + if (response.statusCode !== 200 || !video?.title) return null return { - title: video.title || 'Unknown', - author: video.user_name || 'Unknown', - durationMs: (video.duration || 0) * 1000, - artworkUrl: video.thumbnail_large || video.thumbnail_medium || null + title: video.title, + author: video.user_name ?? 'Unknown', + durationMs: (video.duration ?? 0) * 1000, + artworkUrl: video.thumbnail_large ?? video.thumbnail_medium ?? null } } catch { return null } } - async _extractFromEmbed( + private async fetchPlayerConfig( videoId: string, hashParam: string | null - ): Promise { - const playerUrl = hashParam - ? `${VIMEO_PLAYER_BASE}/video/${videoId}?h=${hashParam}&app_id=122963` - : `${VIMEO_PLAYER_BASE}/video/${videoId}?app_id=122963` - - let response: VimeoHttpResponse - - if (this._curlAvailable) { - try { - response = await curlRequest(playerUrl, { - referer: `${VIMEO_BASE}/${videoId}`, - origin: VIMEO_BASE - }) - } catch { - response = (await _functions.httpRequest(playerUrl, { - headers: { - Accept: - 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', - 'Sec-Fetch-Dest': 'iframe', - 'Sec-Fetch-Mode': 'navigate', - 'Sec-Fetch-Site': 'cross-site', - Referer: `${VIMEO_BASE}/${videoId}`, - Origin: VIMEO_BASE - }, - maxSize: 5 * 1024 * 1024 - })) as VimeoHttpResponse - } - } else { - response = (await _functions.httpRequest(playerUrl, { - headers: { - Accept: - 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', - 'Sec-Fetch-Dest': 'iframe', - 'Sec-Fetch-Mode': 'navigate', - 'Sec-Fetch-Site': 'cross-site', - Referer: `${VIMEO_BASE}/${videoId}`, - Origin: VIMEO_BASE - }, - maxSize: 5 * 1024 * 1024 - })) as VimeoHttpResponse + ): Promise { + const pageUrl = `${VIMEO_BASE}/${videoId}${hashParam ? `?h=${hashParam}` : ''}` + const signature = getSignature( + await this.fetchNextPageProps(videoId, hashParam) + ) + if (!signature) { + throw new Error('Vimeo anonymous credentials were not found') } - if (response.statusCode >= 400) - throw new Error(`HTTP ${response.statusCode}`) + const apiUrl = new URL( + `/videos/${signature.videoId}?${PLAYER_QUERY}`, + VIMEO_API_BASE + ) + apiUrl.searchParams.set('anon_signature', signature.value) + apiUrl.searchParams.set( + 'fields', + 'type,embed_player_config_url,width,height,live.recurring_event.link,live.recurring_event.stream_privacy.unlisted_hash,player_embed_url' + ) - const html = response.body.toString('utf8') - if (html.includes('Just a moment') || html.includes('challenge-platform')) { - throw new Error('Cloudflare challenge detected') + const api = await http1makeRequest(apiUrl.toString(), { + ...this.requestOptions({ + Accept: 'application/vnd.vimeo.*+json;version=3.4.12', + Authorization: `jwt ${signature.jwt}`, + 'Content-Type': 'application/json', + 'Vimeo-Page': '/video/[clipId]', + 'Accept-Language': 'en', + Referer: `${VIMEO_BASE}/` + }), + maxRetries: 0 + }) + const apiData = ( + typeof api.body === 'string' ? JSON.parse(api.body) : api.body + ) as VimeoAnonymousVideoResponse + if (api.statusCode !== 200 || !apiData?.embed_player_config_url) { + throw new Error( + `Vimeo anonymous API returned HTTP ${api.statusCode ?? 0}` + ) } - return this._parsePageForConfig(html, playerUrl, videoId) + const config = await http1makeRequest( + apiData.embed_player_config_url, + this.requestOptions({ + Accept: 'application/json', + Referer: pageUrl, + Origin: VIMEO_BASE + }) + ) + if (config.statusCode !== 200 || !config.body) { + throw new Error( + `Vimeo player config returned HTTP ${config.statusCode ?? 0}` + ) + } + return config.body as VimeoConfig } - async _parsePageForConfig( - html: string, - refererUrl: string, - videoId: string - ): Promise { - const cfgKeyIdx = html.indexOf('"config_url"') - if (cfgKeyIdx !== -1) { - const q1 = html.indexOf('"', html.indexOf(':', cfgKeyIdx) + 1) - const q2 = q1 !== -1 ? html.indexOf('"', q1 + 1) : -1 - if (q1 !== -1 && q2 !== -1) { - const raw = html.slice(q1 + 1, q2) - try { - const result = await this._fetchConfigFromUrl( - _functions.unescapeString(raw), - refererUrl, - videoId - ) - if (result) return result - } catch {} - } + private async fetchNextPageProps( + videoId: string, + hashParam: string | null + ): Promise { + const watch = await http1makeRequest( + `${VIMEO_BASE}/watch`, + this.requestOptions({ + Accept: + 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8' + }) + ) + if (watch.statusCode !== 200 || typeof watch.body !== 'string') { + throw new Error(`Vimeo bootstrap returned HTTP ${watch.statusCode ?? 0}`) } - const cfgKeyIdx2 = html.indexOf('data-config-url="') - if (cfgKeyIdx2 !== -1) { - const start = cfgKeyIdx2 + 'data-config-url="'.length - const end = html.indexOf('"', start) - if (end !== -1) { - try { - const result = await this._fetchConfigFromUrl( - _functions.unescapeString(html.slice(start, end)), - refererUrl, - videoId - ) - if (result) return result - } catch {} - } + const nextData = parseNextData(watch.body) + if (!nextData?.buildId || !nextData.locale) { + throw new Error('Vimeo Next.js bootstrap data was not found') } - for (const pattern of _CONFIG_PATTERNS) { - const match = html.match(pattern) - if (!match?.[1]) continue - const config = this._parseJsonConfig(match[1]) - if (!config) continue - const result = await this._extractPlaylistFromConfig( - config, - refererUrl, - videoId - ) - if (result) return result - } + // i never hated the devtools debugger as much as i do now. im going crazy w vimeo. - const cdnMatch = html.match( - /(https?:\/\/[^"'\s\\]*vimeocdn\.com[^"'\s\\]*playlist\.json[^"'\s\\]*)/i + const dataUrl = new URL( + `/_next/data/${encodeURIComponent(nextData.buildId)}/${encodeURIComponent(nextData.locale)}/${encodeURIComponent(videoId)}.json`, + VIMEO_BASE ) - if (cdnMatch?.[1]) { - try { - const result = await this._fetchPlaylist( - _functions.unescapeString(cdnMatch[1]), - videoId - ) - if (result) return result as VimeoStreamResult - } catch {} - } + if (hashParam) dataUrl.searchParams.set('h', hashParam) - const progressiveMatch = html.match(/"progressive"\s*:\s*\[([\s\S]*?)\]/i) - if (progressiveMatch?.[1]) { - const result = this._handleProgressiveUrls(progressiveMatch[1], videoId) - if (result) return result + const page = await http1makeRequest(dataUrl.toString(), { + ...this.requestOptions({ + Accept: 'application/json', + 'Accept-Language': nextData.locale, + 'x-nextjs-data': '1', + Referer: `${VIMEO_BASE}/watch` + }), + maxRetries: 0 + }) + const pageData = page.body as VimeoNextPageResponse + if (page.statusCode !== 200 || !pageData?.pageProps) { + throw new Error(`Vimeo video data returned HTTP ${page.statusCode ?? 0}`) } - - throw new Error('No config found in embed page') + return pageData.pageProps } - _handleProgressiveUrls( - progressiveJson: string, + private async extractStream( + config: VimeoConfig, videoId: string - ): VimeoProgressiveResult | null { - try { - const parsed = _functions.parseJson(`[${progressiveJson}]`) as Array<{ - url?: string - quality?: string - height?: number - }> | null - if (Array.isArray(parsed) && parsed.length) { - const sorted = [...parsed].sort( - (a, b) => (a?.height || 0) - (b?.height || 0) - ) - const best = - sorted.find((p) => (p?.height || 0) >= 360) || - sorted[sorted.length - 1] - if (best?.url) { + ): Promise { + const files = this.findFiles(config) + if (!files) throw new Error('Vimeo player config has no files') + + const dash = files.dash + if (dash?.cdns) { + const cdn = this.pickCdn(dash.cdns, dash.default_cdn) + const playlistUrl = cdn?.url ?? cdn?.avc_url + if (playlistUrl) { + try { + return await this.fetchPlaylist(playlistUrl) + } catch (error) { logger( - 'warn', - 'Sources', - `[vimeo] Using progressive stream for ${videoId} (${best.height || 0}p)` + 'debug', + 'Vimeo', + `DASH audio failed for ${videoId}: ${ + error instanceof Error ? error.message : String(error) + }` ) - return { - url: _functions.unescapeString(best.url), - protocol: 'https', - format: 'mp4', - additionalData: { - source: 'vimeo.progressive', - quality: best.quality, - height: best.height || 0 - } - } } } - } catch {} - - try { - const urls: Array<{ url: string; height: number }> = [] - let pos = 0 - - while (true) { - const urlStart = progressiveJson.indexOf('"url"', pos) - if (urlStart === -1) break - - const valueStart = progressiveJson.indexOf('"', urlStart + 5) - if (valueStart === -1) break - - const valueEnd = progressiveJson.indexOf('"', valueStart + 1) - if (valueEnd === -1) break - - const url = _functions.unescapeString( - progressiveJson.substring(valueStart + 1, valueEnd) - ) + } - let height = 0 - const before = progressiveJson.substring(pos, urlStart) - const heightKey = before.lastIndexOf('"height"') - if (heightKey !== -1) { - const colon = before.indexOf(':', heightKey) - if (colon !== -1) { - const num = - before - .slice(colon + 1) - .trim() - .split(',')[0] || '0' - height = parseInt(num, 10) || 0 - } + const hls = files.hls + if (hls?.cdns) { + const cdn = this.pickCdn(hls.cdns, hls.default_cdn) + if (cdn?.url) { + return { + url: cdn.url, + protocol: 'hls', + format: 'mpegts', + additionalData: { source: 'vimeo.hls' } } - - urls.push({ url, height }) - pos = valueEnd + 1 } + } - urls.sort((a, b) => a.height - b.height) - const best = urls.find((p) => p.height >= 360) || urls[urls.length - 1] - - if (best?.url) { - logger( - 'warn', - 'Sources', - `[vimeo] Using progressive stream for ${videoId} (${best.height}p)` - ) - return { - url: best.url, - protocol: 'https', - format: 'mp4', - additionalData: { source: 'vimeo.progressive', height: best.height } + const progressive = [...(files.progressive ?? [])].sort( + (a, b) => (b.height ?? 0) - (a.height ?? 0) + )[0] + if (progressive?.url) { + return { + url: progressive.url, + protocol: 'https', + format: 'mp4', + additionalData: { + source: 'vimeo.progressive', + quality: progressive.quality, + height: progressive.height ?? 0 } } - } catch {} + } - return null + throw new Error('Vimeo player config has no playable streams') } - _parseJsonConfig(configString: string): VimeoConfig | null { - try { - let braceDepth = 0 - let endIndex = 0 - - for (let i = 0; i < configString.length; i++) { - const c = configString[i] - if (c === '{') braceDepth++ - else if (c === '}') braceDepth-- - if (braceDepth === 0 && i > 0) { - endIndex = i + 1 - break - } - } + private findFiles(config: VimeoConfig): VimeoConfigFiles | null { + const files = + config.request?.files ?? + config.video?.files ?? + config.files ?? + config.clip?.files + if (files) return files - return _functions.parseJson( - configString.substring(0, endIndex || configString.length) - ) as VimeoConfig | null - } catch { - return null - } + const nested = config.config ?? config.player?.config ?? config.data?.config + return nested ? this.findFiles(nested) : null } - async _fetchConfigFromUrl( - configUrl: string, - refererUrl: string, - videoId: string - ): Promise { - if (configUrl.startsWith('/')) { - const refUrl = new URL(refererUrl) - configUrl = `${refUrl.protocol}//${refUrl.host}${configUrl}` - } + private pickCdn( + cdns: Record, + defaultCdn?: string + ): VimeoCdnConfig | null { + for (const name of CDN_PRIORITY) { + if (cdns[name]) return cdns[name] + } + return ( + (defaultCdn ? cdns[defaultCdn] : undefined) ?? + Object.values(cdns)[0] ?? + null + ) + } - const response = await _functions.httpRequest(configUrl, { - headers: { - Accept: 'application/json', - Referer: refererUrl, - Origin: VIMEO_BASE - }, - maxSize: 2 * 1024 * 1024 + private async fetchPlaylist( + playlistUrl: string + ): Promise { + const response = await http1makeRequest(playlistUrl, { + ...this.requestOptions(this.mediaHeaders()), + maxResponseBodyBytes: 2 * 1024 * 1024 }) + if (response.statusCode !== 200) { + throw new Error( + `Vimeo playlist returned HTTP ${response.statusCode ?? 0}` + ) + } - if (response.statusCode >= 400) - throw new Error(`HTTP ${response.statusCode}`) + const playlist = response.body as VimeoPlaylist + const audio = selectAudioTrack(playlist.audio ?? []) + if (audio) return this.buildAudioResult(playlistUrl, playlist, audio) - const config = _functions.parseJson(response.body) as VimeoConfig | null - if (!config) throw new Error('Invalid config JSON') + const video = [...(playlist.video ?? [])].sort( + (a, b) => + (b.avg_bitrate ?? b.bitrate ?? 0) - (a.avg_bitrate ?? a.bitrate ?? 0) + )[0] + if (video?.segments?.length) { + return this.buildVideoResult(playlistUrl, playlist, video) + } - return this._extractPlaylistFromConfig(config, configUrl, videoId) + throw new Error('Vimeo playlist has no compatible audio track') } - async _extractPlaylistFromConfig( - config: VimeoConfig, - refererUrl: string, - videoId: string - ): Promise { - let files: VimeoConfigFiles | undefined = config?.request?.files - if (!files) - files = config?.video?.files || config?.files || config?.clip?.files - if (!files) { - const nested = - config?.config || config?.player?.config || config?.data?.config - if (nested) - return this._extractPlaylistFromConfig(nested, refererUrl, videoId) - } - if (!files) throw new Error('No files in config') - - const pickCdn = ( - cdns: Record | undefined, - def: string | undefined - ): VimeoCdnConfig | null => { - for (const name of CDN_PRIORITY) if (cdns?.[name]) return cdns[name] - return cdns?.[def || ''] ?? (cdns ? Object.values(cdns)[0] : null) ?? null - } - - const dash = files.dash - if (dash?.cdns) { - const selected = pickCdn(dash.cdns, dash.default_cdn) - if (selected) { - let playlistUrl = _functions.unescapeString( - selected.avc_url || selected.url || '' - ) - if (playlistUrl) { - if ( - !playlistUrl.includes('playlist.json') && - !playlistUrl.includes('master.json') - ) { - playlistUrl = playlistUrl.replace( - /\/[^/?]+(\?|$)/, - '/playlist.json$1' - ) - } - if (!playlistUrl.includes('omit=')) { - playlistUrl += `${playlistUrl.includes('?') ? '&' : '?'}omit=av1-hevc` - } - try { - return await this._fetchPlaylist(playlistUrl, videoId) - } catch {} - } + private buildAudioResult( + playlistUrl: string, + playlist: VimeoPlaylist, + audio: VimeoAudioTrack + ): VimeoSegmentedResult { + const codecs = audio.codecs ?? '' + const playlistData: VimeoPlaylistData = { + playlistUrl, + basePath: this.withTrailingSlash(playlist.base_url), + trackPath: this.withTrailingSlash(audio.base_url), + initSegment: audio.init_segment ?? null, + segments: audio.segments ?? [], + duration: audio.duration, + bitrate: audio.avg_bitrate ?? audio.bitrate, + codecs, + sampleRate: audio.sample_rate ?? audio.audio_sample_rate ?? 48000, + clipId: playlist.clip_id, + isDashFormat: audio.format === 'dash', + streamType: 'mp4' + } + + logger( + 'debug', + 'Vimeo', + `Selected AAC audio: ${codecs}, ${playlistData.bitrate ?? 0}bps` + ) + return { + url: playlistUrl, + protocol: 'segmented', + format: 'mp4', + playlistData, + additionalData: { + source: 'vimeo.adaptive', + bitrate: playlistData.bitrate, + codecs, + segments: playlistData.segments.length, + sampleRate: playlistData.sampleRate, + format: audio.format } } + } - const hls = files.hls - if (hls?.cdns) { - const selected = pickCdn(hls.cdns, hls.default_cdn) - if (selected?.url) { - return { - url: _functions.unescapeString(selected.url), - protocol: 'hls', - format: 'mpegts', - additionalData: { source: 'vimeo.hls' } - } + private buildVideoResult( + playlistUrl: string, + playlist: VimeoPlaylist, + video: VimeoVideoTrack + ): VimeoSegmentedResult { + return { + url: playlistUrl, + protocol: 'segmented', + format: 'mp4', + playlistData: { + playlistUrl, + basePath: this.withTrailingSlash(playlist.base_url), + trackPath: this.withTrailingSlash(video.base_url), + initSegment: video.init_segment ?? null, + segments: video.segments ?? [], + duration: video.duration, + bitrate: video.avg_bitrate ?? video.bitrate, + codecs: video.codecs, + clipId: playlist.clip_id, + isDashFormat: video.format === 'dash', + streamType: 'mp4' + }, + additionalData: { + source: 'vimeo.video-fallback', + segments: video.segments?.length ?? 0 } } + } - const progressive = files.progressive - if (Array.isArray(progressive) && progressive.length) { - const sorted = [...progressive].sort( - (a, b) => (a.height || 0) - (b.height || 0) - ) - const best = - sorted.find((p) => (p.height || 0) >= 360) || sorted[sorted.length - 1] - - if (best?.url) { - logger( - 'warn', - 'Sources', - `[vimeo] Using progressive stream for ${videoId}` + private async pipeProgressive( + url: string, + output: PassThrough + ): Promise { + try { + const response = await http1makeRequest(url, { + ...this.requestOptions(this.mediaHeaders()), + streamOnly: true + }) + if (response.statusCode !== 200 || !response.stream) { + throw new Error( + `Vimeo progressive stream returned HTTP ${response.statusCode ?? 0}` + ) + } + await pipeline(response.stream, output) + output.emit('finishBuffering') + } catch (error) { + if (!output.destroyed) { + output.destroy( + error instanceof Error ? error : new Error(String(error)) ) - return { - url: best.url, - protocol: 'https', - format: 'mp4', - additionalData: { - source: 'vimeo.progressive', - quality: best.quality, - height: best.height - } - } } } - - throw new Error('No playable streams in config') } - async _fetchPlaylist( - playlistUrl: string, - _videoId: string - ): Promise { - const response = await _functions.httpRequest(playlistUrl, { - headers: { - Accept: '*/*', - Origin: VIMEO_BASE, - Referer: `${VIMEO_BASE}/`, - 'Sec-Fetch-Dest': 'empty', - 'Sec-Fetch-Mode': 'cors', - 'Sec-Fetch-Site': 'cross-site' - }, - maxSize: 2 * 1024 * 1024 - }) + private async pipeSegments( + playlist: VimeoPlaylistData, + output: PassThrough + ): Promise { + try { + if (playlist.initSegment) { + await this.write(output, Buffer.from(playlist.initSegment, 'base64')) + } - if (response.statusCode >= 400) - throw new Error(`HTTP ${response.statusCode}`) - - const playlist = _functions.parseJson(response.body) as VimeoPlaylist | null - if (!playlist) throw new Error('Invalid playlist JSON') - - if (playlist.audio?.length) { - const audioTrack = _functions.selectBestAudioTrack(playlist.audio) - if (audioTrack) { - const segments: VimeoPlaylistSegment[] = ( - audioTrack.segments || [] - ).map((seg) => ({ - url: seg.url, - start: seg.start, - end: seg.end, - size: seg.size - })) - - const sampleRate = - audioTrack.sample_rate || audioTrack.audio_sample_rate || 48000 - const isDashFormat = audioTrack.format === 'dash' - - let basePath = playlist.base_url || '' - let trackPath = audioTrack.base_url || '' - - if (!basePath && !trackPath) basePath = '../../../../../' - else if (basePath && !basePath.endsWith('/')) basePath += '/' - - if (trackPath && !trackPath.endsWith('/')) trackPath += '/' - - const playlistData: VimeoPlaylistData = { - playlistUrl, - basePath, - trackPath, - initSegment: audioTrack.init_segment || null, - segments, - duration: audioTrack.duration, - bitrate: audioTrack.avg_bitrate || audioTrack.bitrate, - codecs: audioTrack.codecs, - sampleRate, - clipId: playlist.clip_id, - isDashFormat + for (const segment of playlist.segments) { + if (output.destroyed || !segment.url) return + const url = buildSegmentUrl( + playlist.playlistUrl, + playlist.basePath, + playlist.trackPath, + segment.url + ) + const response = await http1makeRequest(url, { + ...this.requestOptions(this.mediaHeaders()), + responseType: 'buffer', + maxResponseBodyBytes: 5 * 1024 * 1024 + }) + if (response.statusCode !== 200 || !Buffer.isBuffer(response.body)) { + throw new Error( + `Vimeo segment returned HTTP ${response.statusCode ?? 0}` + ) } + await this.write(output, response.body) + } - logger( - 'debug', - 'Sources', - `[vimeo] Using audio: ${audioTrack.codecs} @ ${playlistData.bitrate}bps, ${sampleRate}Hz, ${segments.length} segments, format: ${audioTrack.format}` + if (!output.destroyed) { + output.emit('finishBuffering') + output.end() + } + } catch (error) { + if (!output.destroyed) { + output.destroy( + error instanceof Error ? error : new Error(String(error)) ) - - return { - url: playlistUrl, - protocol: 'segmented', - format: 'mp4', - playlistData, - additionalData: { - source: 'vimeo.adaptive', - bitrate: playlistData.bitrate, - codecs: playlistData.codecs, - segments: segments.length, - sampleRate, - format: audioTrack.format - } - } } } + } - if (playlist.video?.length) { - logger( - 'warn', - 'Sources', - `[vimeo] No compatible audio tracks, falling back to video track` - ) + private async write(output: PassThrough, chunk: Buffer): Promise { + if (output.write(chunk)) return + await once(output, 'drain') + } - const video = playlist.video.reduce( - (best: VimeoVideoTrack | null, v: VimeoVideoTrack) => { - const bw = v.avg_bitrate || v.bitrate || 0 - return bw > (best?.avg_bitrate || best?.bitrate || 0) ? v : best - }, - null - ) + private withTrailingSlash(value?: string): string { + if (!value) return '' + return value.endsWith('/') ? value : `${value}/` + } - if (video?.segments?.length) { - const segments: VimeoPlaylistSegment[] = video.segments.map((seg) => ({ - url: seg.url, - start: seg.start, - end: seg.end, - size: seg.size - })) - - const playlistData: VimeoPlaylistData = { - playlistUrl, - basePath: playlist.base_url || '', - trackPath: video.base_url || '', - initSegment: video.init_segment || null, - segments, - duration: video.duration, - bitrate: video.avg_bitrate || video.bitrate, - codecs: video.codecs, - clipId: playlist.clip_id, - isDashFormat: video.format === 'dash' - } + private handoffKey(videoId: string, hashParam: string | null): string { + return `${videoId}:${hashParam ?? ''}` + } - return { - url: playlistUrl, - protocol: 'segmented', - format: 'mp4', - playlistData, - additionalData: { - source: 'vimeo.video-only', - segments: segments.length - } - } - } + private setHandoff(key: string, value: VimeoSegmentedResult): void { + const now = Date.now() + for (const [entryKey, entry] of this.handoff) { + if (entry.expiresAt <= now) this.handoff.delete(entryKey) + } + while (this.handoff.size >= HANDOFF_MAX) { + const firstKey = this.handoff.keys().next().value + if (typeof firstKey === 'string') this.handoff.delete(firstKey) } + this.handoff.set(key, { value, expiresAt: now + HANDOFF_TTL }) + } - throw new Error('No compatible audio tracks in playlist') + private takeHandoff(key: string): VimeoSegmentedResult | null { + const entry = this.handoff.get(key) + this.handoff.delete(key) + if (!entry || entry.expiresAt <= Date.now()) return null + return entry.value } } diff --git a/src/sources/vkmusic.ts b/src/sources/vkmusic.ts index a6d14503..f7451a4a 100644 --- a/src/sources/vkmusic.ts +++ b/src/sources/vkmusic.ts @@ -215,7 +215,7 @@ export default class VKMusicSource implements SourceInstance { body: 'version=1&app_id=6287487', disableBodyCompression: true, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) const body = res.body as { @@ -281,7 +281,9 @@ export default class VKMusicSource implements SourceInstance { try { const res = await this._apiRequest('audio.search', { q: query, - count: String((this.nodelink.options.maxSearchResults as number) || 10), + count: String( + (this.nodelink.options.search.maxResults as number) || 10 + ), extended: '1' }) @@ -405,7 +407,7 @@ export default class VKMusicSource implements SourceInstance { owner_id: ownerId, extended: '1', count: String( - (this.nodelink.options.maxAlbumPlaylistLength as number) || 100 + (this.nodelink.options.playback.maxPlaylistLength as number) || 100 ) } if (playlistId) params.album_id = playlistId @@ -441,7 +443,7 @@ export default class VKMusicSource implements SourceInstance { try { const res = await http1makeRequest(url, { headers: { 'User-Agent': USER_AGENT, Cookie: this.cookie }, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) if (res.statusCode !== 200) throw new Error(`HTTP ${res.statusCode}`) @@ -535,7 +537,7 @@ export default class VKMusicSource implements SourceInstance { try { const res = await http1makeRequest(url, { headers: { 'User-Agent': USER_AGENT, Cookie: this.cookie }, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) if (res.statusCode !== 200) throw new Error(`HTTP ${res.statusCode}`) @@ -790,7 +792,7 @@ export default class VKMusicSource implements SourceInstance { type: 'mpegts', localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, startTime: (additionalData?.startTime as number) || 0, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }), type: 'mpegts' } @@ -800,7 +802,7 @@ export default class VKMusicSource implements SourceInstance { method: 'GET', streamOnly: true, headers, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) if (res.error || !res.stream) @@ -840,7 +842,7 @@ export default class VKMusicSource implements SourceInstance { 'KateMobileAndroid/56 lite-460 (Android 4.4.2; SDK 19; x86; unknown Android SDK built for x86; en)' }, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) const body = res.body as VKApiResponse diff --git a/src/sources/yandexmusic.ts b/src/sources/yandexmusic.ts index c5144008..2a6b2036 100644 --- a/src/sources/yandexmusic.ts +++ b/src/sources/yandexmusic.ts @@ -270,7 +270,7 @@ export default class YandexMusicSource implements SourceInstance { if (!data) return { loadType: 'empty', data: {} } - const limit = (this.nodelink.options.maxSearchResults as number) || 10 + const limit = (this.nodelink.options.search.maxResults as number) || 10 if (searchType === 'album') { const albums = (data.albums?.results || []) @@ -494,7 +494,7 @@ export default class YandexMusicSource implements SourceInstance { streamOnly: true, headers, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) } @@ -1068,7 +1068,7 @@ export default class YandexMusicSource implements SourceInstance { 'X-Yandex-Music-Client': CLIENT_HEADER }, localAddress: this.nodelink.routePlanner?.getIP?.() || undefined, - proxy: this.config.proxy + proxy: this.config.network?.proxy ?? this.config.proxy }) if (res.statusCode !== 200) { @@ -1404,7 +1404,7 @@ export default class YandexMusicSource implements SourceInstance { const sm = this.nodelink.sources if (!sm) return false const config = ( - this.nodelink.options.sources as + this.nodelink.options.sources as unknown as | Record | undefined )?.[name] diff --git a/src/sources/youtube/CipherManager.ts b/src/sources/youtube/CipherManager.ts index 80de114f..e25d4665 100644 --- a/src/sources/youtube/CipherManager.ts +++ b/src/sources/youtube/CipherManager.ts @@ -115,8 +115,11 @@ export default class CipherManager implements ICipherManager { this.nodelink = nodelink this.config = { ...(( - (nodelink.options.sources as Record | undefined) - ?.youtube as { cipher?: YouTubeCipherConfig } | undefined + ( + nodelink.options.sources as unknown as + | Record + | undefined + )?.youtube as { cipher?: YouTubeCipherConfig } | undefined )?.cipher ?? {}) } if (this.config.url) { @@ -406,9 +409,17 @@ export default class CipherManager implements ICipherManager { const parsedBody = (body ?? {}) as YouTubeCipherServiceResponse if (error || statusCode !== 200 || !parsedBody.sts) { - throw new Error( - `Failed to get STS: ${error || parsedBody.message || 'Invalid response'}` + const detail = + error || + parsedBody.message || + (typeof body === 'object' ? JSON.stringify(body) : body) || + 'Invalid response' + logger( + 'error', + 'YouTube-Cipher', + `Failed to get STS from cipher service (Status: ${statusCode ?? 'unknown'}): ${detail}` ) + throw new Error(`Failed to get STS: ${detail}`) } logger('debug', 'YouTube-Cipher', `Received STS: ${parsedBody.sts}`) @@ -581,19 +592,27 @@ export default class CipherManager implements ICipherManager { Date.now() - startTime ) - logger( - 'debug', - 'YouTube-Cipher', - `Received from cipher service (Status: ${statusCode})` - ) - const parsedBody = (body ?? {}) as YouTubeCipherServiceResponse if (error || statusCode !== 200 || !parsedBody.resolved_url) { - throw new Error( - `Failed to resolve URL: ${error || parsedBody.message || 'Invalid response'}` + const detail = + error || + parsedBody.message || + (typeof body === 'object' ? JSON.stringify(body) : body) || + 'Invalid response' + logger( + 'error', + 'YouTube-Cipher', + `Failed to resolve URL via cipher service (Status: ${statusCode ?? 'unknown'}): ${detail}` ) + throw new Error(`Failed to resolve URL: ${detail}`) } + logger( + 'debug', + 'YouTube-Cipher', + `Received from cipher service (Status: ${statusCode}): ${parsedBody.resolved_url}` + ) + logger( 'debug', 'YouTube-Cipher', @@ -646,9 +665,8 @@ export default class CipherManager implements ICipherManager { const watchPage = typeof body === 'string' ? body : '' if (error || statusCode !== 200 || !watchPage) { - throw new Error( - `Failed to fetch watch page for player script: ${error || statusCode || 'unknown'}` - ) + const reason = error || `Status ${statusCode ?? 'unknown'}` + throw new Error(`Failed to fetch watch page for player script: ${reason}`) } const jsUrlMatch = watchPage.match(/"jsUrl":"([^"]+)"/) diff --git a/src/sources/youtube/YouTube.ts b/src/sources/youtube/YouTube.ts index 6ff0ccff..459a6c4b 100644 --- a/src/sources/youtube/YouTube.ts +++ b/src/sources/youtube/YouTube.ts @@ -1,9 +1,6 @@ import { PassThrough } from 'node:stream' import HLSHandler from '../../playback/hls/HLSHandler.ts' -import type { - PreviousSessionState, - SabrStreamConfig -} from '../../typings/sources/sabr.types.ts' +import type { SabrStreamConfig } from '../../typings/sources/sabr.types.ts' import type { SourceResult, TrackInfo, @@ -32,15 +29,6 @@ import { makeRequest } from '../../utils.ts' import CipherManager from './CipherManager.ts' -import Android from './clients/Android.ts' -import AndroidVR from './clients/AndroidVR.ts' -import IOS from './clients/IOS.ts' -import Music from './clients/Music.ts' -import TV from './clients/TV.ts' -import TVCast from './clients/TVCast.ts' -import Web from './clients/Web.ts' -import WebRemix from './clients/Web_Remix.ts' -import WebEmbedded from './clients/WebEmbedded.ts' import { checkURLType, YOUTUBE_CONSTANTS, @@ -62,6 +50,16 @@ const MAX_URL_REFRESH = 10 /** Interval in milliseconds between visitor data refreshes. */ const VISITOR_DATA_INTERVAL = 3_600_000 +/** PassThrough buffer size. 48KB = ~3s of 128kbps Opus, enough to cover reconnect gaps. */ +const STREAM_BUFFER_SIZE = 48 * 1024 + +/** Refresh URL before YouTube's ~6h expiry. */ +const URL_MAX_AGE_MS = 4.5 * 60 * 60 * 1000 + +/** Recovery base delay with exponential backoff. So 2s, 4s, 8s, etc. */ +const RECOVER_BASE_DELAY_MS = 2000 +const MAX_RETRY_DELAY_MS = 8000 + /** * Manages a scored pool of proxies with automatic health tracking. * @@ -201,6 +199,9 @@ export default class YouTubeSource { /** Interval handle for periodic visitor data refresh, or `null` when not running. */ private visitorDataInterval: ReturnType | null + /** Interval handle to clear failingClientsByTrack periodically. */ + private failingClientsInterval: ReturnType | null + /** Cipher/signature decryption manager shared across all innertube clients. */ private cipherManager: CipherManager @@ -213,9 +214,15 @@ export default class YouTubeSource { /** Set of fallback-mirror lookup keys currently in flight, used to prevent infinite recursion loops. */ private mirrorFallbackInFlight: Set + /** Map of track identifiers to a set of client names that failed to provide a playable URL. */ + private failingClientsByTrack: Map> + /** YouTube innertube request context sent with every API call (device info, locale, visitor data). */ private ytContext: YouTubeContext + /** Dynamic bandwidth estimate in bits per second (starts at 128kbps/16KB/s). */ + private bandwidthEstimate = 128_000 + // -- Public fields consumed by the framework -- /** Additional source names this source can proxy through (e.g. `['ytmusic']`). */ @@ -235,9 +242,8 @@ export default class YouTubeSource { */ constructor(nodelink: WorkerNodeLink) { this.nodelink = nodelink - this.config = ( - nodelink.options as Record | undefined> - ).sources?.youtube as YouTubeSourceConfig + this.config = nodelink.options.sources + .youtube as unknown as YouTubeSourceConfig this.proxyManager = new YouTubeProxyManager(this.config.proxies || []) this.additionalsSourceName = ['ytmusic'] this.searchTerms = ['ytsearch', 'ytmsearch'] @@ -252,6 +258,7 @@ export default class YouTubeSource { this.clients = {} this.oauth = null this.visitorDataInterval = null + this.failingClientsInterval = null this.cipherManager = new CipherManager(nodelink) this.liveChat = new YouTubeLiveChat(nodelink, { getProxy: this.getProxy.bind(this), @@ -259,6 +266,7 @@ export default class YouTubeSource { }) this.activeStreams = new Map() this.mirrorFallbackInFlight = new Set() + this.failingClientsByTrack = new Map() this.ytContext = { client: { screenDensityFloat: 1, @@ -310,6 +318,30 @@ export default class YouTubeSource { this.oauth = new OAuth(this.nodelink) + const [ + { default: Android }, + { default: AndroidVR }, + { default: IOS }, + { default: Music }, + { default: WebRemix }, + { default: TV }, + { default: TV_DOWN }, + { default: TVCast }, + { default: Web }, + { default: WebEmbedded } + ] = await Promise.all([ + import('./clients/Android.ts'), + import('./clients/AndroidVR.ts'), + import('./clients/IOS.ts'), + import('./clients/Music.ts'), + import('./clients/Web_Remix.ts'), + import('./clients/TV.ts'), + import('./clients/TV_downgraded.ts'), + import('./clients/TVCast.ts'), + import('./clients/Web.ts'), + import('./clients/WebEmbedded.ts') + ]) + const clientClasses: ClientClassMap = { Android, AndroidVR, @@ -317,6 +349,7 @@ export default class YouTubeSource { Music, WebRemix, TV, + TV_DOWN, TVCast, Web, WebEmbedded @@ -336,16 +369,20 @@ export default class YouTubeSource { await this._fetchVisitorData() await this.cipherManager.getCachedPlayerScript() - await this.cipherManager.checkCipherServerStatus() if (this.visitorDataInterval) clearInterval(this.visitorDataInterval) this.visitorDataInterval = setInterval( () => this._fetchVisitorData(), VISITOR_DATA_INTERVAL ) - if (typeof this.visitorDataInterval.unref === 'function') { - this.visitorDataInterval.unref() - } + this.visitorDataInterval.unref?.() + + if (this.failingClientsInterval) clearInterval(this.failingClientsInterval) + this.failingClientsInterval = setInterval( + () => this.failingClientsByTrack.clear(), + 1000 * 60 * 60 * 12 + ) + this.failingClientsInterval.unref?.() logger('info', 'YouTube', 'YouTube source setup complete.') return true @@ -368,8 +405,14 @@ export default class YouTubeSource { this.visitorDataInterval = null } + if (this.failingClientsInterval) { + clearInterval(this.failingClientsInterval) + this.failingClientsInterval = null + } + if (this.oauth) (this.oauth as { cleanup?: () => void }).cleanup?.() ;(this.cipherManager as { cleanup?: () => void })?.cleanup?.() + this.failingClientsByTrack.clear() } /** * Fetches visitor data and player script URL from YouTube embed pages. @@ -384,7 +427,6 @@ export default class YouTubeSource { const cachedPlayerScript = this.nodelink.credentialManager?.get( 'yt_player_script_url' ) - if (cachedPlayerScript) { this.cipherManager.setPlayerScriptUrl(cachedPlayerScript) logger('debug', 'YouTube', 'Player script URL loaded from cache.') @@ -401,7 +443,7 @@ export default class YouTubeSource { } = await makeRequest('https://www.youtube.com/embed', { method: 'GET', headers: { - Cookie: 'YSC=cz5kYp3ZuIE; VISITOR_INFO1_LIVE=U-0T5oUyzf8;' + Cookie: 'YSC=LUAfwHpna4E; VISITOR_INFO1_LIVE=Zuih2uZbq3I;' } }) @@ -410,27 +452,24 @@ export default class YouTubeSource { const visitorMatch = bodyStr?.match(/"VISITOR_DATA":"([^"]+)"/) if (visitorMatch?.[1]) { this.ytContext.client.visitorData = visitorMatch[1] - this.nodelink.credentialManager?.set( - 'yt_visitor_data', - visitorMatch[1], - 60 * 60 * 1000 - ) visitorFound = true - logger('debug', 'YouTube', 'visitorData refreshed and cached.') + logger('debug', 'YouTube', 'visitorData refreshed from embed.') } - const playerScriptMatch = bodyStr?.match(/"jsUrl":"([^"]+)"/) - if (playerScriptMatch?.[1]) { - playerScriptUrl = playerScriptMatch[1].replace( - /\/[a-z]{2}_[A-Z]{2}\//, - '/en_US/' - ) - this.nodelink.credentialManager?.set( - 'yt_player_script_url', - playerScriptUrl, - 12 * 60 * 60 * 1000 - ) - logger('debug', 'YouTube', `Player script URL: ${playerScriptUrl}`) + if (!cachedPlayerScript) { + const playerScriptMatch = bodyStr?.match(/"jsUrl":"([^"]+)"/) + if (playerScriptMatch?.[1]) { + playerScriptUrl = playerScriptMatch[1].replace( + /\/[a-z]{2}_[A-Z]{2}\//, + '/en_US/' + ) + this.nodelink.credentialManager?.set( + 'yt_player_script_url', + playerScriptUrl, + 12 * 60 * 60 * 1000 + ) + logger('debug', 'YouTube', `Player script URL: ${playerScriptUrl}`) + } } } else { logger( @@ -461,23 +500,10 @@ export default class YouTubeSource { ) { this.ytContext.client.visitorData = guideBody.responseContext.visitorData - this.nodelink.credentialManager?.set( - 'yt_visitor_data', - guideBody.responseContext.visitorData, - 60 * 60 * 1000 - ) visitorFound = true - logger( - 'debug', - 'YouTube', - 'visitorData refreshed via guide and cached.' - ) + logger('debug', 'YouTube', 'visitorData refreshed via guide.') } else { - logger( - 'warn', - 'YouTube', - 'Failed to refresh visitorData via guide; using cached fallback if present.' - ) + logger('warn', 'YouTube', 'Failed to refresh visitorData via guide.') } } } catch (e) { @@ -486,11 +512,6 @@ export default class YouTubeSource { 'YouTube', `Error fetching visitor data: ${(e as Error).message}` ) - logger( - 'warn', - 'YouTube', - 'Using cached visitorData fallback (if present).' - ) } if (playerScriptUrl) this.cipherManager.setPlayerScriptUrl(playerScriptUrl) @@ -645,7 +666,7 @@ export default class YouTubeSource { } if ( - (!automixRes || automixRes.loadType !== 'playlist') && + automixRes?.loadType !== 'playlist' && (this.clients.TV || this.clients.TVCast || this.clients.WebRemix) ) { try { @@ -773,7 +794,7 @@ export default class YouTubeSource { if ( result?.loadType === 'error' && - (result.data as { cause?: string })?.cause === 'UpstreamPlayability' + result.exception?.cause === 'UpstreamPlayability' ) { const listIdMatch = url.match(/[?&]list=([\w-]+)/) const videoIdMatch = url.match(/[?&]v=([\w-]+)/) @@ -838,7 +859,7 @@ export default class YouTubeSource { } const errorMessage = - (result?.data as { message?: string })?.message || + result?.exception?.message || `${clientName} client returned empty or failed.` clientErrors.push({ client: clientName, message: errorMessage }) logger( @@ -1056,11 +1077,11 @@ export default class YouTubeSource { info, null, info.sourceName === 'ytmusic' ? 'ytmusic' : 'youtube', - // biome-ignore lint/suspicious/noExplicitAny: buildHoloTrack is dynamically imported from JS with inferred null-typed param - playerBody as any, + playerBody as Record, { fetchChannelInfo: options.fetchChannelInfo ?? false, - resolveExternalLinks: options.resolveExternalLinks ?? false + resolveExternalLinks: options.resolveExternalLinks ?? false, + search: {} } ) @@ -1129,7 +1150,20 @@ export default class YouTubeSource { if (!clientList.length) clientList = ['Web'] const clientErrors: Array<{ client: string; message: string }> = [] + const failingClients = this.failingClientsByTrack.get( + decodedTrack.identifier + ) + for (const clientName of clientList) { + if (failingClients?.has(clientName)) { + logger( + 'debug', + 'YouTube', + `Skipping known failing client ${clientName} for track ${decodedTrack.identifier}` + ) + continue + } + const client = this.clients[clientName] if (!client) continue @@ -1152,6 +1186,18 @@ export default class YouTubeSource { const proxyLatency = Date.now() - proxyStartTime if (urlData.exception) { + const isNoStream = urlData.exception.cause === 'UpstreamNoStream' + const isNotFound = urlData.exception.status === 404 + + if (isNoStream || isNotFound) { + if (!this.failingClientsByTrack.has(decodedTrack.identifier)) { + this.failingClientsByTrack.set(decodedTrack.identifier, new Set()) + } + this.failingClientsByTrack + .get(decodedTrack.identifier) + ?.add(clientName) + } + this.reportProxyStatus( proxyToUse, false, @@ -1230,7 +1276,12 @@ export default class YouTubeSource { ) const result: TrackUrlData = { ...urlData, - additionalData: { contentLength, proxy: proxyToUse } + additionalData: { + contentLength, + proxy: proxyToUse, + itag: urlData.itag, + formats: urlData.formats + } } this.nodelink.trackCacheManager?.set( 'youtube', @@ -1459,10 +1510,11 @@ export default class YouTubeSource { ? this.config.fallbackSources : [] - const opts = this.nodelink.options as Record - const defaultSources = Array.isArray(opts.defaultSearchSource) - ? (opts.defaultSearchSource as string[]) - : [opts.defaultSearchSource as string] + const opts = this.nodelink.options as unknown as Record + const searchConfig = opts.search as Record | undefined + const defaultSources = Array.isArray(searchConfig?.defaultSource) + ? (searchConfig.defaultSource as string[]) + : [searchConfig?.defaultSource as string] const fallbackOrder = [ ...configuredFallbackSources, @@ -1515,8 +1567,7 @@ export default class YouTubeSource { query ) if ( - !search || - search.loadType !== 'search' || + search?.loadType !== 'search' || !Array.isArray(search.data) || search.data.length === 0 ) { @@ -1660,9 +1711,9 @@ export default class YouTubeSource { logger( 'debug', 'YouTube', - `Using range buffering for ${decodedTrack.title} (${Math.round(contentLength / 1024 / 1024)}MB)` + `Using Chunked HTTP buffering for ${decodedTrack.title} (${Math.round(contentLength / 1024 / 1024)}MB)` ) - return this._streamWithRangeRequests( + return this._streamChunkedHttp( url, contentLength, decodedTrack, @@ -1716,35 +1767,17 @@ export default class YouTubeSource { ): Promise { const sabrConfig: SabrStreamConfig = { videoId: decodedTrack.identifier, - accessToken: additionalData.accessToken as string | undefined, - visitorData: additionalData.visitorData as string | undefined, - serverAbrStreamingUrl: additionalData.serverAbrStreamingUrl as - | string - | undefined, - videoPlaybackUstreamerConfig: - additionalData.videoPlaybackUstreamerConfig as - | string - | Uint8Array - | undefined, - poToken: additionalData.poToken as string | Uint8Array | undefined, - clientInfo: additionalData.clientInfo as - | { clientName: number; clientVersion: string } - | undefined, - formats: additionalData.formats as - | Array<{ - itag: number - mimeType?: string - bitrate?: number - audioTrackId?: string - }> - | undefined, - startTime: (additionalData.startTime as number | undefined) ?? 0, - positionCallback: additionalData.positionCallback as - | ((positionMs: number) => void) - | undefined, - previousSession: additionalData.previousSession as - | PreviousSessionState - | undefined + accessToken: additionalData.accessToken, + visitorData: additionalData.visitorData, + serverAbrStreamingUrl: additionalData.serverAbrStreamingUrl, + videoPlaybackUstreamerConfig: additionalData.videoPlaybackUstreamerConfig, + poToken: additionalData.poToken, + clientInfo: additionalData.clientInfo, + formats: additionalData.formats, + startTime: additionalData.startTime ?? 0, + positionCallback: additionalData.positionCallback, + playbackPaused: additionalData.playbackPaused, + previousSession: additionalData.previousSession } const sabr = new SabrStream(sabrConfig) @@ -1757,18 +1790,20 @@ export default class YouTubeSource { readyReject = reject }) let isRecovering = false - let lastRecoverAt = 0 + + sabr.once('mediaProgress', () => { + if (readyResolved) return + readyResolved = true + readyResolve() + }) sabr.on('data', (chunk: Buffer) => { - if (!readyResolved) { - readyResolved = true - readyResolve() - } if (!stream.write(chunk)) { sabr.pause() } }) - stream.on('drain', () => sabr.resume()) + const onSabrDrain = () => sabr.resume() + stream.on('drain', onSabrDrain) sabr.on('end', () => { if (!readyResolved) { @@ -1778,80 +1813,71 @@ export default class YouTubeSource { stream.end() }) sabr.on('finishBuffering', () => stream.emit('finishBuffering')) - sabr.on('stall', async () => { - if (isRecovering || stream.destroyed) return + sabr.on( + 'stall', + async (reason: string = 'starvation', recoveryGeneration?: number) => { + if (isRecovering || stream.destroyed || sabr.destroyed) return + + isRecovering = true + const generation = + recoveryGeneration ?? sabr.getMediaProgressGeneration() + try { + logger( + 'warn', + 'YouTube', + `SABR ${reason} recovery requested for ${decodedTrack.title}. Refreshing session...` + ) + const newUrlData = await this.getTrackUrl(decodedTrack, null, true) + if (newUrlData?.protocol !== 'sabr') { + throw new Error('No SABR session available for recovery') + } - const now = Date.now() - if (now - lastRecoverAt < 2000) return - lastRecoverAt = now + if (!sabr.canCommitRecovery(generation)) { + logger( + 'debug', + 'YouTube', + `Discarding stale SABR replacement for ${decodedTrack.title}; media advanced during recovery.` + ) + sabr.cancelRecovery() + return + } - isRecovering = true - try { - logger( - 'warn', - 'YouTube', - `SABR stall detected for ${decodedTrack.title}. Refreshing session...` - ) - const newUrlData = await this.getTrackUrl(decodedTrack, null, true) - if (!newUrlData || newUrlData.protocol !== 'sabr') { - throw new Error('No SABR session available for recovery') + const ad = (newUrlData.additionalData || {}) as TrackUrlAdditionalData + sabr.clearBuffers() + sabr.updateSession({ + serverAbrStreamingUrl: ad.serverAbrStreamingUrl || newUrlData.url, + videoPlaybackUstreamerConfig: ad.videoPlaybackUstreamerConfig, + poToken: ad.poToken, + visitorData: ad.visitorData, + clientInfo: ad.clientInfo, + formats: ad.formats, + userAgent: ad.userAgent, + playbackCookie: ad.playbackCookie + }) + } catch (err) { + logger( + 'warn', + 'YouTube', + `SABR recovery failed: ${(err as Error).message}` + ) + if (!readyResolved) { + readyResolved = true + readyReject(err as Error) + if (!stream.destroyed) stream.destroy() + } else if (!stream.destroyed) { + stream.destroy(err as Error) + } + } finally { + isRecovering = false } - - const ad = (newUrlData.additionalData || {}) as TrackUrlAdditionalData - sabr.clearBuffers() - sabr.updateSession({ - serverAbrStreamingUrl: (ad.serverAbrStreamingUrl || newUrlData.url) as - | string - | undefined, - videoPlaybackUstreamerConfig: ad.videoPlaybackUstreamerConfig as - | string - | Uint8Array - | undefined, - poToken: ad.poToken as string | Uint8Array | undefined, - visitorData: ad.visitorData as string | undefined, - clientInfo: ad.clientInfo as - | { clientName: number; clientVersion: string } - | undefined, - formats: ad.formats as - | Array<{ - itag: number - mimeType?: string - bitrate?: number - audioTrackId?: string - }> - | undefined, - userAgent: ad.userAgent as string | undefined, - playbackCookie: ad.playbackCookie as string | Uint8Array | undefined - }) - } catch (err) { - logger( - 'warn', - 'YouTube', - `SABR recovery failed: ${(err as Error).message}` - ) - if (!stream.destroyed) stream.destroy(err as Error) - } finally { - isRecovering = false } - }) + ) sabr.on('error', async (err: Error) => { logger('error', 'YouTube', `SABR stream error: ${err.message}`) if (!readyResolved) { readyResolved = true readyReject(err) - } - - if ( - (err.message.includes('sabr.malformed_config') || - err.message.includes('sabr.media_serving_enforcement_id_error')) && - !isRecovering - ) { - logger( - 'info', - 'YouTube', - `Known recoverable error detected (${err.message}), triggering stall recovery...` - ) - sabr.emit('stall') + if (!stream.destroyed) stream.destroy() return } @@ -1863,6 +1889,7 @@ export default class YouTubeSource { stream.destroy = ((err?: Error) => { if (isDestroying) return stream isDestroying = true + stream.removeListener('drain', onSabrDrain) sabr.destroy(err) this.activeStreams.delete(streamKey) originalDestroy(err) @@ -1872,14 +1899,18 @@ export default class YouTubeSource { stream.once('close', () => { if (isDestroying) return isDestroying = true + stream.removeListener('drain', onSabrDrain) sabr.destroy() this.activeStreams.delete(streamKey) }) ;(stream as unknown as Record)._sabrStream = sabr - ;(stream as unknown as Record).getSessionState = () => { - if (isDestroying || stream.destroyed) return null - return sabr.getSessionState() + ;(stream as unknown as Record).beginSeekHandoff = () => { + if (isDestroying || stream.destroyed) return Promise.resolve(null) + return sabr.beginSeekHandoff() + } + ;(stream as unknown as Record).cancelSeekHandoff = () => { + if (!isDestroying && !stream.destroyed) sabr.cancelSeekHandoff() } const bestAudio = (additionalData.formats ?? []) @@ -2018,10 +2049,14 @@ export default class YouTubeSource { responseStream let cleanedUp = false + const onDrain = () => { + if (!responseStream.destroyed) responseStream.resume() + } const cleanup = () => { if (cleanedUp) return cleanedUp = true cancelSignal.aborted = true + stream.removeListener('drain', onDrain) responseStream.removeAllListeners() if (!responseStream.destroyed) responseStream.destroy() this.activeStreams.delete(streamKey) @@ -2034,9 +2069,7 @@ export default class YouTubeSource { } }) - stream.on('drain', () => { - if (!responseStream.destroyed) responseStream.resume() - }) + stream.on('drain', onDrain) responseStream.on('end', () => { cleanup() @@ -2119,6 +2152,10 @@ export default class YouTubeSource { | null = null let recoverTimeout: ReturnType | null = null let currentAdditionalData = additionalData + let currentItag = currentAdditionalData?.itag + let availableFormats = currentAdditionalData?.formats || [] + const failedItags = new Set() + const _isRecovering = false const cleanup = () => { if (destroyed) return @@ -2226,7 +2263,11 @@ export default class YouTubeSource { `Got ${statusCode} at pos ${position} → forcing recovery` ) fetching = false - recover() + recover({ + message: `HTTP ${statusCode}`, + statusCode, + name: 'Error' + }) return } throw new Error(`Range request failed: ${statusCode}`) @@ -2282,7 +2323,7 @@ export default class YouTubeSource { fetchNext, Math.min(1000 * 2 ** (errors - 1), 5000) ) - if (typeof timeout.unref === 'function') timeout.unref() + timeout.unref?.() } } } @@ -2321,7 +2362,7 @@ export default class YouTubeSource { fetchNext, Math.min(1000 * 2 ** (errors - 1), 5000) ) - if (typeof timeout.unref === 'function') timeout.unref() + timeout.unref?.() } } } @@ -2336,7 +2377,7 @@ export default class YouTubeSource { causeError?.message === 'aborted' || (causeError as Error & { code?: string })?.code === 'ECONNRESET' - if (!isForbidden && !isAborted && refreshes === 0) { + if (!isForbidden && refreshes === 0) { logger( 'debug', 'YouTube', @@ -2362,15 +2403,6 @@ export default class YouTubeSource { return } - if (isAborted && stream.writableNeedDrain) { - logger( - 'debug', - 'YouTube', - `Stream is paused/backed up, skipping recovery (cause: ${causeError?.message}). Player will recover on resume.` - ) - return - } - if (isAborted && stream.writableNeedDrain) { logger( 'debug', @@ -2378,30 +2410,62 @@ export default class YouTubeSource { `Stream is paused/backed up, waiting for drain before recovery (cause: ${causeError?.message})` ) await new Promise((resolve) => { - const onDrain = () => { - stream.off('drain', onDrain) + const onDrainOrEnd = () => { + cleanupListeners() resolve() } - stream.once('drain', onDrain) - const timeout = setTimeout(() => { - stream.off('drain', onDrain) - resolve() - }, 60000) - if (typeof timeout.unref === 'function') timeout.unref() + const cleanupListeners = () => { + stream.off('drain', onDrainOrEnd) + stream.off('close', onDrainOrEnd) + stream.off('error', onDrainOrEnd) + } + stream.once('drain', onDrainOrEnd) + stream.once('close', onDrainOrEnd) + stream.once('error', onDrainOrEnd) }) if (destroyed || cancelSignal.aborted || stream.destroyed) return - if (stream.writableNeedDrain) { + } + + try { + let itagToTry: number | null = null + + if (refreshes > 2 && currentItag) { + failedItags.add(currentItag) logger( - 'debug', + 'warn', 'YouTube', - 'Stream still backed up after drain wait, deferring recovery until resume' + `Itag ${currentItag} failed consistently. Attempting quality fallback...` ) - return + + const currentMime = + currentAdditionalData?.formats?.find((f) => f.itag === currentItag) + ?.mimeType || '' + const isWebm = currentMime.includes('webm') + + const otherAudioFormats = availableFormats + .filter( + (f) => + f.itag !== currentItag && + !failedItags.has(f.itag) && + f.mimeType?.includes('audio') && + (isWebm + ? f.mimeType.includes('webm') + : f.mimeType.includes('mp4')) + ) + .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0)) + + const bestFallback = otherAudioFormats[0] + if (bestFallback) { + itagToTry = bestFallback.itag as number + logger( + 'info', + 'YouTube', + `Switching to itag ${itagToTry} (available: ${otherAudioFormats.map((f) => f.itag).join(', ')})` + ) + } } - } - try { - const newUrlData = await this.getTrackUrl(decodedTrack, null, true) + const newUrlData = await this.getTrackUrl(decodedTrack, itagToTry, true) if (destroyed || cancelSignal.aborted) return @@ -2409,14 +2473,43 @@ export default class YouTubeSource { throw new Error('No valid URL from getTrackUrl') } + const oldContentLength = + (currentAdditionalData?.contentLength as number | undefined) || + contentLength + const newAdditionalData = newUrlData.additionalData as + | TrackUrlAdditionalData + | undefined + const newContentLength = newAdditionalData?.contentLength as + | number + | undefined + + if ( + oldContentLength && + newContentLength && + oldContentLength !== newContentLength + ) { + const ratio = newContentLength / oldContentLength + const oldPos = position + position = Math.floor(position * ratio) + contentLength = newContentLength + logger( + 'debug', + 'YouTube', + `Adjusted position for itag switch (${currentItag} -> ${newUrlData.itag || itagToTry}): ${oldPos} -> ${position} bytes (ratio: ${ratio.toFixed(4)})` + ) + } + currentUrl = newUrlData.url currentAdditionalData = newUrlData.additionalData as TrackUrlAdditionalData + currentItag = newUrlData.itag || itagToTry || currentItag + if (newUrlData.formats) availableFormats = newUrlData.formats + errors = 0 logger( 'debug', 'YouTube', - `URL recovered for ${decodedTrack.title} (resume at ${position} bytes, attempt ${refreshes}, cause: ${causeError?.message})` + `URL recovered for ${decodedTrack.title} (resume at ${position} bytes, attempt ${refreshes}, itag ${currentItag}, cause: ${causeError?.message})` ) fetching = false fetchNext() @@ -2431,9 +2524,7 @@ export default class YouTubeSource { () => recover(causeError), 4000 + refreshes * 1000 ) - if (typeof recoverTimeout.unref === 'function') { - recoverTimeout.unref() - } + recoverTimeout.unref?.() } } } @@ -2449,6 +2540,551 @@ export default class YouTubeSource { return { stream } } + /** + * Streams audio using chunked range requests. This tries to "Replicate" on how the browser + * streams audio directly from youtube with code status 206. + * + * Uses dynamic chunk sizing (256 KB – 512 KB) based on per-stream bandwidth + * The limit is around ~570 KB per chunk. But setted to 512KB for better memory efficiency. + * Fast-reconnects on ECONNRESET without refreshing the URL until the third consecutive failure. + * Opens only 1 connection per stream, reusing it for multiple chunks. + * This is the same ideia used for _streamWithRangeRequests, but this tries to limit to 1 connection only. + * + * + * @param url - Initial playback URL. + * @param contentLength - Total content length in bytes. + * @param decodedTrack - Track metadata for URL recovery. + * @param cancelSignal - Shared cancel token for stream abort. + * @param streamKey - Unique key for tracking this stream. + * @param additionalData - Optional proxy and format info. + * @returns StreamResult with the PassThrough stream. + */ + private async _streamChunkedHttp( + url: string, + contentLength: number, + decodedTrack: TrackInfo, + cancelSignal: CancelSignal, + streamKey: string | symbol, + additionalData?: TrackUrlAdditionalData + ): Promise { + const stream = new PassThrough({ + highWaterMark: STREAM_BUFFER_SIZE + }) + + let currentUrl = url + let currentProxy = additionalData?.proxy as unknown as + | HttpProxyConfig + | undefined + if (!currentProxy) { + currentProxy = this.getProxy() as unknown as HttpProxyConfig + } + let urlFetchTime = Date.now() + let isDestroyed = false + let isBackpressured = false + let totalBytesReceived = 0 + let currentItag = additionalData?.itag + let availableFormats = additionalData?.formats || [] + const failedItags = new Set() + let refreshAttempts = 0 + let consecutiveResets = 0 + let activeResponseStream: + | (NodeJS.ReadableStream & { + destroyed: boolean + destroy: () => void + resume: () => void + pause: () => void + }) + | null = null + + let bandwidthEstimate = this.bandwidthEstimate || 128_000 + const updateBandwidthEstimate = ( + bytes: number, + durationMs: number + ): void => { + if (bytes <= 0 || durationMs <= 0) return + const bits = bytes * 8 + const throughput = (bits / durationMs) * 1000 + const alpha = 0.25 + bandwidthEstimate = Math.max( + 128_000, + alpha * throughput + (1 - alpha) * bandwidthEstimate + ) + // this will update the class-level bandwidth estimate for future streams, + // so that it can be used to seed the estimate for new streams and cause less errors hopefully. + this.bandwidthEstimate = bandwidthEstimate + } + + const onDrain = () => { + isBackpressured = false + if (activeResponseStream && !activeResponseStream.destroyed) { + activeResponseStream.resume() + } + } + + let _wakeUp: (() => void) | null = null + const cancelSleep = () => { + _wakeUp?.() + _wakeUp = null + } + const sleep = (ms: number): Promise => + new Promise((r) => { + const t = setTimeout(() => { + _wakeUp = null + r() + }, ms) + t.unref?.() + _wakeUp = () => { + clearTimeout(t) + r() + } + }) + + const cleanup = (err?: Error): void => { + if (isDestroyed) return + isDestroyed = true + cancelSignal.aborted = true + cancelSleep() + stream.removeListener('drain', onDrain) + + if (activeResponseStream && !activeResponseStream.destroyed) { + activeResponseStream.destroy() + activeResponseStream = null + } + + if (!stream.destroyed) stream.destroy(err) + this.activeStreams.delete(streamKey) + } + + // Waits for the PassThrough to drain after a backpressure-caused reset, + // without leaving a dangling listener for whichever event didn't fire. + const waitForDrainOrClose = (): Promise => + new Promise((resolve) => { + const onReady = () => { + stream.removeListener('drain', onReady) + stream.removeListener('close', onReady) + resolve() + } + stream.once('drain', onReady) + stream.once('close', onReady) + }) + + stream.once('close', () => cleanup()) + stream.once('error', (err: Error) => cleanup(err)) + + stream.on('drain', onDrain) + + const refreshUrl = async (reason: string): Promise => { + if (isDestroyed || cancelSignal.aborted) return null + if (++refreshAttempts > MAX_URL_REFRESH) { + logger( + 'error', + 'YouTube', + `Max URL refresh (${MAX_URL_REFRESH}) reached for ${decodedTrack.title}` + ) + return null + } + + logger( + 'debug', + 'YouTube', + `Refreshing URL for "${decodedTrack.title}" (reason: ${reason}, ${refreshAttempts}/${MAX_URL_REFRESH})` + ) + + try { + let itagToTry: number | null = null + if ( + currentItag && + failedItags.has(currentItag) && + availableFormats.length > 0 + ) { + const currentMime = + availableFormats.find((f) => f.itag === currentItag)?.mimeType || '' + const isWebm = currentMime.includes('webm') + const fallback = availableFormats + .filter( + (f) => + f.itag !== currentItag && + !failedItags.has(f.itag) && + f.mimeType?.includes('audio') && + (isWebm + ? f.mimeType.includes('webm') + : f.mimeType.includes('mp4')) + ) + .sort((a, b) => (b.bitrate || 0) - (a.bitrate || 0))[0] + + if (fallback) { + itagToTry = fallback.itag as number + logger( + 'info', + 'YouTube', + `Switching to itag ${itagToTry} for "${decodedTrack.title}"` + ) + } + } + + const newUrlData = await this.getTrackUrl(decodedTrack, itagToTry, true) + if (isDestroyed || cancelSignal.aborted) return null + if (newUrlData.exception || !newUrlData.url) return null + + currentUrl = newUrlData.url + const newAd = newUrlData.additionalData as + | TrackUrlAdditionalData + | undefined + currentProxy = + (newAd?.proxy as unknown as HttpProxyConfig | undefined) || + currentProxy + currentItag = newUrlData.itag || currentItag + if (newUrlData.formats) availableFormats = newUrlData.formats + urlFetchTime = Date.now() + consecutiveResets = 0 + + logger( + 'debug', + 'YouTube', + `URL refreshed for "${decodedTrack.title}" (itag ${currentItag})` + ) + return currentUrl + } catch (err) { + logger( + 'error', + 'YouTube', + `URL refresh failed: ${(err as Error).message}` + ) + return null + } + } + + const startStreaming = async (): Promise => { + const MIN_TARGET_SECONDS = 2 + const MAX_TARGET_SECONDS = 12 + const INITIAL_TARGET_SECONDS = 4 + let targetSeconds = INITIAL_TARGET_SECONDS + + const ABS_MIN_BYTES = 64 * 1024 + const ABS_MAX_BYTES = 512 * 1024 + + const trackBytesPerSecond = + contentLength > 0 && decodedTrack.length > 0 + ? contentLength / (decodedTrack.length / 1000) + : 16_000 + + let chunkCount = 0 + + while ( + !isDestroyed && + !cancelSignal.aborted && + totalBytesReceived < contentLength + ) { + const urlAge = Date.now() - urlFetchTime + if (urlAge > URL_MAX_AGE_MS) { + const refreshed = await refreshUrl('URL age > 4.5h') + if (!refreshed) { + cleanup(new Error('Failed to refresh expired URL')) + return + } + } + + const proxyToUse = currentProxy + const fetchStartTime = Date.now() + + const bytesPerSecond = bandwidthEstimate / 8 + let dynamicChunkSize = Math.floor(bytesPerSecond * targetSeconds) + dynamicChunkSize = Math.max( + ABS_MIN_BYTES, + Math.min(dynamicChunkSize, ABS_MAX_BYTES) + ) + + const start = totalBytesReceived + const end = Math.min(start + dynamicChunkSize - 1, contentLength - 1) + const rangeHeader = `bytes=${start}-${end}` + + try { + const result = await http1makeRequest(currentUrl, { + method: 'GET', + streamOnly: true, + proxy: proxyToUse, + timeout: 30000, + headers: { + Range: rangeHeader, + 'Accept-Encoding': 'identity;q=1, *;q=0', + 'Sec-Fetch-Dest': 'video', + 'Sec-Fetch-Mode': 'no-cors', + 'Sec-Fetch-Site': 'same-origin', + Referer: currentUrl, + Accept: '*/*', + 'Accept-Language': 'en-US,en;q=0.9', + 'Cache-Control': 'no-cache', + Pragma: 'no-cache', + Priority: 'i' + } + }) + + if (isDestroyed || cancelSignal.aborted) { + const s = result.stream as NodeJS.ReadableStream & { + destroyed?: boolean + destroy: () => void + } + if (s && !s.destroyed) { + s.destroy() + } + return + } + + this.reportProxyStatus( + proxyToUse as unknown as ProxySnapshot, + !result.error && result.statusCode === 206, + result.statusCode || 0, + Date.now() - fetchStartTime + ) + + if ( + result.error || + (result.statusCode !== 200 && result.statusCode !== 206) + ) { + if (result.statusCode === 403 || result.statusCode === 404) { + logger( + 'warn', + 'YouTube', + `HTTP ${result.statusCode} for "${decodedTrack.title}" -- refreshing...` + ) + if (currentItag) failedItags.add(currentItag) + const refreshed = await refreshUrl(`HTTP ${result.statusCode}`) + if (refreshed) continue + cleanup( + new Error(`HTTP ${result.statusCode}: max URL refresh reached`) + ) + return + } + + const retryDelay = Math.min( + RECOVER_BASE_DELAY_MS * 2 ** Math.max(0, refreshAttempts - 1), + MAX_RETRY_DELAY_MS + ) + logger( + 'warn', + 'YouTube', + `HTTP ${result.statusCode}, retrying in ${retryDelay}ms...` + ) + await sleep(retryDelay) + continue + } + + const contentRangeHeader = result.headers?.['content-range'] + const contentRange = Array.isArray(contentRangeHeader) + ? contentRangeHeader[0] + : contentRangeHeader == null + ? null + : String(contentRangeHeader) + const rangeMatch = + result.statusCode === 206 + ? /^bytes\s+(\d+)-(\d+)\/(\d+|\*)$/i.exec(contentRange ?? '') + : null + const responseStart = rangeMatch ? Number(rangeMatch[1]) : -1 + const responseEnd = rangeMatch ? Number(rangeMatch[2]) : -1 + + if ( + result.statusCode !== 206 || + responseStart !== start || + responseEnd < responseStart || + responseEnd > end + ) { + const responseStream = result.stream as + | (NodeJS.ReadableStream & { destroy?: () => void }) + | undefined + responseStream?.destroy?.() + logger( + 'warn', + 'YouTube', + `Invalid range response for ${rangeHeader}: HTTP ${result.statusCode}, Content-Range ${contentRange ?? 'missing'}. Refreshing URL...` + ) + const refreshed = await refreshUrl('invalid range response') + if (refreshed) continue + cleanup(new Error('Invalid HTTP range response')) + return + } + + const responseStream = result.stream as NodeJS.ReadableStream & { + destroyed: boolean + destroy: () => void + pause: () => void + resume: () => void + } + + activeResponseStream = responseStream + let bytesThisChunk = 0 + let dataStartTime = 0 + + await new Promise((resolve, reject) => { + if (isDestroyed || cancelSignal.aborted) { + if (!responseStream.destroyed) responseStream.destroy() + return resolve() + } + + const onData = (chunk: Buffer) => { + if (isDestroyed || cancelSignal.aborted) { + responseStream.destroy() + return + } + if (dataStartTime === 0) dataStartTime = Date.now() + bytesThisChunk += chunk.length + totalBytesReceived += chunk.length + if (!stream.write(chunk)) { + isBackpressured = true + responseStream.pause() + } + } + + const onEnd = () => { + responseStream.removeListener('data', onData) + responseStream.removeListener('error', onError) + activeResponseStream = null + resolve() + } + + const onError = (err: Error) => { + responseStream.removeListener('data', onData) + responseStream.removeListener('end', onEnd) + activeResponseStream = null + if (isDestroyed || cancelSignal.aborted) resolve() + else reject(err) + } + + responseStream.once('end', onEnd) + responseStream.once('error', onError) + responseStream.on('data', onData) + }) + + if (!responseStream.destroyed) { + responseStream.destroy() + } + + const transferDuration = dataStartTime + ? Date.now() - dataStartTime + : Date.now() - fetchStartTime + updateBandwidthEstimate(bytesThisChunk, transferDuration) + + chunkCount++ + if (chunkCount <= 2) { + targetSeconds = MIN_TARGET_SECONDS + } else if (chunkCount <= 5) { + targetSeconds = INITIAL_TARGET_SECONDS + } else { + const estimatedSecondsInChunk = bytesThisChunk / trackBytesPerSecond + if (estimatedSecondsInChunk >= targetSeconds * 0.8) { + targetSeconds = Math.min(targetSeconds + 2, MAX_TARGET_SECONDS) + } else { + targetSeconds = Math.max(targetSeconds - 2, MIN_TARGET_SECONDS) + } + } + + /* + logger( + 'debug', + 'YouTube', + `Chunk #${chunkCount} complete: ${bytesThisChunk} bytes in ${Date.now() - fetchStartTime}ms (${totalBytesReceived}/${contentLength} total, target=${targetSeconds}s)` + ) */ + // i was using this for debugging, so i will keep this commented incase i need it later. + + if (totalBytesReceived >= contentLength) { + if (!stream.writableEnded) { + stream.emit('finishBuffering') + stream.end() + } + return + } + + consecutiveResets = 0 + isBackpressured = false + } catch (err) { + if (isDestroyed || cancelSignal.aborted) return + const error = err as Error & { code?: string } + + if ( + error.code === 'ECONNRESET' || + error.code === 'ERR_STREAM_DESTROYED' + ) { + bandwidthEstimate = Math.max(128_000, bandwidthEstimate * 0.7) + + if (isBackpressured) { + consecutiveResets = 0 + isBackpressured = false + logger( + 'debug', + 'YouTube', + `Buffer-drain recovery at ${totalBytesReceived} bytes (consecutive resets cleared).` + ) + if (stream.writableLength > 0) { + await waitForDrainOrClose() + } + continue + } + + logger( + 'warn', + 'YouTube', + `Connection reset at ${totalBytesReceived} bytes.` + ) + + // Try same URL first (it's probably still valid) since it takes ~6 hours for an URL to expire + const retryDelay = Math.min(250 * 2 ** consecutiveResets, 1000) + consecutiveResets++ + logger( + 'warn', + 'YouTube', + `Retrying same URL in ${retryDelay}ms (consecutive reset ${consecutiveResets})...` + ) + await sleep(retryDelay) + + if (consecutiveResets >= 3) { + logger( + 'warn', + 'YouTube', + `Same URL failed ${consecutiveResets} times, refreshing...` + ) + consecutiveResets = 0 + const refreshed = await refreshUrl( + 'multiple ECONNRESET on same URL' + ) + if (refreshed) continue + cleanup(new Error('ECONNRESET: max URL refresh reached')) + return + } else { + continue + } + } + + if ( + error.message?.includes('403') || + error.message?.includes('404') + ) { + if (currentItag) failedItags.add(currentItag) + const refreshed = await refreshUrl('mid-stream 403/404') + if (refreshed) continue + cleanup(new Error('mid-stream 403/404: max URL refresh reached')) + return + } + + const retryDelay = Math.min( + RECOVER_BASE_DELAY_MS * 2 ** Math.max(0, refreshAttempts - 1), + MAX_RETRY_DELAY_MS + ) + logger( + 'warn', + 'YouTube', + `Stream error for "${decodedTrack.title}": ${error.message}. Retrying in ${retryDelay}ms...` + ) + await sleep(retryDelay) + } + } + } + + startStreaming().catch((err: Error) => { + logger('error', 'YouTube', `Fatal streaming error: ${err.message}`) + cleanup(err) + }) + + return { stream } + } /** * Fetches chapter markers for a track using the Web client. * @param trackInfo - Track metadata containing the video identifier. diff --git a/src/sources/youtube/clients/Android.ts b/src/sources/youtube/clients/Android.ts index 52e46f9a..7c9d2197 100644 --- a/src/sources/youtube/clients/Android.ts +++ b/src/sources/youtube/clients/Android.ts @@ -11,7 +11,6 @@ import type { YouTubeContext } from '../../../typings/sources/youtube.types.ts' import type { - YouTubeNextRequestBody, YouTubeNextResponse, YouTubeSearchResponse } from '../../../typings/sources/youtubeClient.types.ts' @@ -216,7 +215,7 @@ export default class Android extends BaseClient { } const maxResults = - (this.config.maxSearchResults as number | undefined) || 10 + (this.config.search.maxResults as number | undefined) || 10 let count = 0 const filteredItems = items.filter((item) => { const isValid = @@ -244,7 +243,7 @@ export default class Android extends BaseClient { sourceName, null, null, - this.config.enableHoloTracks as boolean | undefined + this.config.experimental.enableHoloTracks as boolean | undefined ) if (track) { tracks.push(track) @@ -374,6 +373,7 @@ export default class Android extends BaseClient { const playlistId = playlistIdMatch[1] const videoIdMatch = url.match(/[?&]v=([\w-]+)/) const currentVideoId = videoIdMatch?.[1] ?? null + const isRadio = playlistId.startsWith('RD') logger( 'debug', @@ -381,20 +381,22 @@ export default class Android extends BaseClient { `User-Agent for playlist request: ${this.getClient(context).client.userAgent}` ) - const requestBody: YouTubeNextRequestBody = { - context: this.getClient(context), - playlistId, - contentCheckOk: true, - racyCheckOk: true - } - if (playlistId.startsWith('RD') && currentVideoId) { + const requestBody: Record = isRadio + ? { + context: this.getClient(context), + playlistId, + contentCheckOk: true, + racyCheckOk: true + } + : { context: this.getClient(context), browseId: `VL${playlistId}` } + if (isRadio && currentVideoId) { requestBody.videoId = currentVideoId } const playlistProxy = this.getProxy() const playlistStart = Date.now() const { body: playlistResponseRaw, statusCode } = await makeRequest( - `${apiEndpoint}/youtubei/v1/next`, + `${apiEndpoint}/youtubei/v1/${isRadio ? 'next' : 'browse'}`, { headers: { 'User-Agent': this.getClient(context).client.userAgent, @@ -438,6 +440,15 @@ export default class Android extends BaseClient { const playlistResponse = playlistResponseRaw as YouTubeNextResponse + if (!isRadio) { + return await this._handleBrowsePlaylistResponse( + playlistId, + playlistResponse, + sourceName, + context + ) + } + return await this._handlePlaylistResponse( playlistId, currentVideoId, diff --git a/src/sources/youtube/clients/AndroidVR.ts b/src/sources/youtube/clients/AndroidVR.ts index e774ad50..21dd47b8 100644 --- a/src/sources/youtube/clients/AndroidVR.ts +++ b/src/sources/youtube/clients/AndroidVR.ts @@ -62,11 +62,11 @@ export default class AndroidVR extends BaseClient { clientName: 'ANDROID_VR', clientVersion: '1.65.10', userAgent: - 'Mozilla/5.0 (X11; Linux x86_64; Quest 3) AppleWebKit/537.36 (KHTML, like Gecko) OculusBrowser/39.3.0.11.46.766180192 Chrome/136.0.7103.177 VR Safari/537.36,gzip(gfe);GoogleHypersonic', - deviceMake: 'Google', + 'com.google.android.apps.youtube.vr.oculus/1.65.10 (Linux; U; Android 12L; eureka-user Build/SQ3A.220605.009.A1) gzip', + deviceMake: 'Meta', osName: 'Android', - osVersion: '15', - androidSdkVersion: '35', + osVersion: '12L', + androidSdkVersion: '32', hl: context.client.hl, gl: context.client.gl, visitorData: context.client.visitorData @@ -178,7 +178,7 @@ export default class AndroidVR extends BaseClient { } const maxResults = - (this.config.maxSearchResults as number | undefined) || 10 + (this.config.search.maxResults as number | undefined) || 10 if (videos.length > maxResults) { let count = 0 videos = videos.filter((video) => { @@ -197,7 +197,7 @@ export default class AndroidVR extends BaseClient { sourceName, null, null, - this.config.enableHoloTracks as boolean | undefined + this.config.experimental.enableHoloTracks as boolean | undefined ) if (track) { tracks.push(track) diff --git a/src/sources/youtube/clients/TV.ts b/src/sources/youtube/clients/TV.ts index 50d32656..66725104 100644 --- a/src/sources/youtube/clients/TV.ts +++ b/src/sources/youtube/clients/TV.ts @@ -53,9 +53,11 @@ export default class TV extends BaseClient { return { client: { clientName: 'TVHTML5', - clientVersion: '7.20260113.16.00', + clientVersion: '7.20260708.13.02', + browserVersion: '25.lts.40.1035033-gold', + browserName: 'Cobalt', userAgent: - 'Mozilla/5.0 (Fuchsia) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36 CrKey/1.56.500000', + 'Mozilla/5.0 (SMART-TV; Linux; Tizen 8.0) Cobalt/Version (unlike Gecko) v8/11.4.233.17-gold Starboard/16, Tizen;Samsung;KantM_2024;8.0/2300.0 (Samsung, QN90D_98, Wired', hl: context.client.hl, gl: context.client.gl }, @@ -64,6 +66,17 @@ export default class TV extends BaseClient { } } + /** + * Returns player parameters for TV playback. + * + * @returns Base64-encoded player parameters string + */ + override getPlayerParams(): string | null { + // around D8 03 01 w field 59? or 27? makes me confused. + // will appear betwenn 0AMB ... xxxxxxMIw (-5/6 letters that always updates) + return '2AMB' + } + /** * TV client requires a player script for signature deciphering. * diff --git a/src/sources/youtube/clients/TV_downgraded.ts b/src/sources/youtube/clients/TV_downgraded.ts new file mode 100644 index 00000000..69469e38 --- /dev/null +++ b/src/sources/youtube/clients/TV_downgraded.ts @@ -0,0 +1,307 @@ +/** + * YouTube TV Client + * + * Implements the YouTube TVHTML5 innertube client for smart TV and + * Chromecast emulation. Supports video/playlist resolution with + * OAuth-based authentication for TV devices. + * TV DOWNGRADED does not require POT to work (theorically no SABR too) + * + * + * @packageDocumentation + * @module YouTubeTVClient + */ + +import type { + SourceResult, + TrackInfo, + WorkerNodeLink +} from '../../../typings/sources/source.types.ts' +import type { + ICipherManager, + IOAuth, + YouTubeClientContext, + YouTubeContext +} from '../../../typings/sources/youtube.types.ts' +import type { HttpProxyConfig } from '../../../typings/utils.types.ts' +import { logger, makeRequest } from '../../../utils.ts' +import { BaseClient, checkURLType, YOUTUBE_CONSTANTS } from '../common.ts' + +/** + * YouTube TVHTML5 innertube client. + * + * Emulates a smart TV device for YouTube API requests. + * Requires a player script for signature deciphering. + * + * @public + */ +export default class TV_DOWN extends BaseClient { + /** + * Creates a new TV client instance. + * + * @param nodelink - NodeLink worker instance providing options and source access + * @param oauth - OAuth manager for authenticated requests, or null if unauthenticated + */ + constructor(nodelink: WorkerNodeLink, oauth: IOAuth | null) { + super(nodelink, 'TVHTML5', oauth) + } + + /** + * Builds the YouTube client context for TVHTML5 innertube requests. + * + * @param context - General YouTube context with language, region, and visitor data + * @returns Client context object describing this TVHTML5 client configuration + */ + override getClient(context: YouTubeContext): YouTubeClientContext { + return { + client: { + clientName: 'TVHTML5', + clientVersion: '5.20260713', + browserVersion: '5.150.00-qa', + browserName: 'Cobalt', + userAgent: + 'Mozilla/5.0 (Unknown) Cobalt/5.150.00-qa (unlike Gecko) Starboard/3, Unknown;Unknown;Unknown;0/Unknown (Chromium, Starboard, Wired)', + hl: context.client.hl, + gl: context.client.gl + }, + user: { lockedSafetyMode: false }, + request: { useSsl: true } + } + } + + /** + * Returns player parameters for TV playback. + * + * @returns Base64-encoded player parameters string + */ + override getPlayerParams(): string | null { + // around D8 03 01 w field 59? or 27? makes me confused. + // will appear betwenn 0AMB ... xxxxxxMIw (-5/6 letters that always updates) + return '2AMB' + } + + /** + * TV client requires a player script for signature deciphering. + * + * @returns Always true for the TV client + */ + override requirePlayerScript(): boolean { + return true + } + + /** + * Retrieves OAuth authorization headers for TV device authentication. + * + * @returns Promise resolving to authorization headers, or empty object if no OAuth + */ + override async getAuthHeaders(): Promise> { + if (this.oauth) { + const accessToken = await this.oauth.getAccessToken() + if (accessToken) { + logger( + 'debug', + 'YouTube-TV_DOWN', + 'Successfully acquired access token for authentication.' + ) + return { + Authorization: `Bearer ${accessToken}` + } + } + } + logger( + 'debug', + 'YouTube-TV_DOWN', + 'No access token available. Proceeding without authentication.' + ) + return {} as Record + } + + /** + * Resolves a YouTube URL to track or playlist data. + * + * @param url - YouTube URL to resolve + * @param _type - URL type hint (unused) + * @param context - YouTube context with language and region settings + * @param cipherManager - Cipher manager for signature deciphering + * @returns Resolved track/playlist data or an exception + */ + override async resolve( + url: string, + _type: string, + context: YouTubeContext, + cipherManager: ICipherManager | null + ): Promise { + const sourceName = 'youtube' + const urlType = checkURLType(url, 'youtube') + const apiEndpoint = this.getApiEndpoint() + + switch (urlType) { + case YOUTUBE_CONSTANTS.VIDEO: + case YOUTUBE_CONSTANTS.SHORTS: { + const idPattern = /(?:v=|\/shorts\/|youtu\.be\/)([^&?]+)/ + const videoIdMatch = url.match(idPattern) + if (!videoIdMatch?.[1]) { + logger( + 'error', + 'YouTube-TV_DOWN', + `Could not parse video ID from URL: ${url}` + ) + return { + loadType: 'error', + exception: { + message: 'Invalid video URL.', + severity: 'common', + cause: 'Input' + } + } + } + const videoId = videoIdMatch[1] + + const headers = await this.getAuthHeaders() + const { body: playerResponse, statusCode } = + await this._makePlayerRequest( + videoId, + context, + headers, + cipherManager + ) + + if (statusCode !== 200) { + const message = `Failed to load video/short player data. Status: ${statusCode}` + logger('error', 'YouTube-TV_DOWN_DOWN', message) + return { + loadType: 'error', + exception: { message, severity: 'common', cause: 'Upstream' } + } + } + + return await this._handlePlayerResponse( + playerResponse, + sourceName, + videoId + ) + } + + case YOUTUBE_CONSTANTS.PLAYLIST: { + const playlistIdMatch = url.match(/[?&]list=([\w-]+)/) + if (!playlistIdMatch?.[1]) { + logger( + 'error', + 'YouTube-TV_DOWN', + `Could not parse playlist ID from URL: ${url}` + ) + return { + loadType: 'error', + exception: { + message: 'Invalid playlist URL.', + severity: 'common', + cause: 'Input' + } + } + } + + const playlistId = playlistIdMatch[1] + const videoIdMatch = url.match(/[?&]v=([\w-]+)/) + const currentVideoId = videoIdMatch?.[1] ?? null + + const requestBody: Record = { + context: this.getClient(context), + playlistId, + contentCheckOk: true, + racyCheckOk: true + } + if (playlistId.startsWith('RD') && currentVideoId) { + requestBody.videoId = currentVideoId + } + const { body: playlistResponse, statusCode } = await makeRequest( + `${apiEndpoint}/youtubei/v1/next`, + { + headers: { 'User-Agent': this.getClient(context).client.userAgent }, + body: requestBody, + method: 'POST', + disableBodyCompression: true, + proxy: this.getProxy() + } + ) + + if (statusCode !== 200) { + const errMsg = `Failed to fetch playlist. Status: ${statusCode}` + logger( + 'error', + 'YouTube-TV_DOWN', + `Error loading playlist ${playlistId}: ${errMsg}` + ) + return { + loadType: 'error', + exception: { + message: errMsg, + severity: 'common', + cause: 'Upstream' + } + } + } + + return await this._handlePlaylistResponse( + playlistId, + currentVideoId, + playlistResponse, + sourceName, + context + ) + } + + default: + return { loadType: 'empty', data: {} } + } + } + + /** + * Retrieves a playable stream URL for a track. + * + * @param decodedTrack - Decoded track information with identifier + * @param context - YouTube context with language and region settings + * @param cipherManager - Cipher manager for signature deciphering + * @param itag - Optional specific format itag to request + * @param proxy - Optional proxy override for this request + * @returns Track URL data with protocol info, or an exception + */ + override async getTrackUrl( + decodedTrack: TrackInfo, + context: YouTubeContext, + cipherManager: ICipherManager | null, + itag?: number | string, + proxy?: HttpProxyConfig + ): Promise> { + const sourceName = decodedTrack.sourceName || 'youtube' + logger( + 'debug', + 'YouTube-TV_DOWN', + `Getting stream URL for: ${decodedTrack.title} (ID: ${decodedTrack.identifier}) on ${sourceName}` + ) + + const headers = await this.getAuthHeaders() + const { body: playerResponse, statusCode } = await this._makePlayerRequest( + decodedTrack.identifier, + context, + headers, + cipherManager, + proxy + ) + + if (statusCode !== 200) { + const message = `Failed to get player data for stream. Status: ${statusCode}` + logger('error', 'YouTube-TV_DOWN_DOWN', message) + return { + loadType: 'error', + exception: { message, severity: 'common', cause: 'Upstream' } + } + } + + return await this._extractStreamData( + playerResponse, + decodedTrack, + context, + cipherManager, + itag + ) + } +} diff --git a/src/sources/youtube/clients/Web.ts b/src/sources/youtube/clients/Web.ts index 908b8ec2..fa1a9e2d 100644 --- a/src/sources/youtube/clients/Web.ts +++ b/src/sources/youtube/clients/Web.ts @@ -75,10 +75,10 @@ export default class Web extends BaseClient { return { client: { clientName: 'WEB', - clientVersion: '2.20260114.01.00', + clientVersion: '2.20260706.00.00', platform: 'DESKTOP', userAgent: - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36', + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', hl: context.client.hl, gl: context.client.gl }, @@ -174,7 +174,7 @@ export default class Web extends BaseClient { } const maxResults = - (this.config.maxSearchResults as number | undefined) || 10 + (this.config.search.maxResults as number | undefined) || 10 if (videos.length > maxResults) { let count = 0 videos = videos.filter((video) => { @@ -193,7 +193,7 @@ export default class Web extends BaseClient { sourceName, null, null, - this.config.enableHoloTracks as boolean | undefined + this.config.experimental.enableHoloTracks as boolean | undefined ) if (track) { tracks.push(track) diff --git a/src/sources/youtube/clients/WebEmbedded.ts b/src/sources/youtube/clients/WebEmbedded.ts index 020cfe68..ddc276e2 100644 --- a/src/sources/youtube/clients/WebEmbedded.ts +++ b/src/sources/youtube/clients/WebEmbedded.ts @@ -48,17 +48,22 @@ export default class WebEmbedded extends BaseClient { return { client: { clientName: 'WEB_EMBEDDED_PLAYER', - clientVersion: '1.20260128.01.00', + clientVersion: '2.20260630.09.00', platform: 'DESKTOP', userAgent: - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36,gzip(gfe)', + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36,gzip(gfe)', hl: context.client.hl, gl: context.client.gl, visitorData: context.client.visitorData }, user: { lockedSafetyMode: false }, request: { useSsl: true }, - thirdParty: { embedUrl: 'https://www.google.com/' } + thirdParty: { + embedUrl: 'https://www.google.com/search?q=youtube', + embeddedPlayerContext: { + ancestorOrigins: ['https://www.google.com'] + } + } } } @@ -158,7 +163,7 @@ export default class WebEmbedded extends BaseClient { } const maxResults = - (this.config.maxSearchResults as number | undefined) || 10 + (this.config.search.maxResults as number | undefined) || 10 if (videos.length > maxResults) { let count = 0 videos = videos.filter((video) => { @@ -177,7 +182,7 @@ export default class WebEmbedded extends BaseClient { sourceName, null, null, - this.config.enableHoloTracks as boolean | undefined + this.config.experimental.enableHoloTracks as boolean | undefined ) if (track) { tracks.push(track) diff --git a/src/sources/youtube/clients/Web_Remix.ts b/src/sources/youtube/clients/Web_Remix.ts index 40f67ec3..a46975f3 100644 --- a/src/sources/youtube/clients/Web_Remix.ts +++ b/src/sources/youtube/clients/Web_Remix.ts @@ -52,6 +52,8 @@ export default class WebRemix extends BaseClient { /** * Returns the YouTube Music client context for innertube requests. + * + * This is only used for getting the videoDetails, no playback. * @param context - General YouTube context with language, region, and visitor data * @returns Client context configured for WEB_REMIX */ @@ -59,12 +61,12 @@ export default class WebRemix extends BaseClient { return { client: { clientName: 'WEB_REMIX', - clientVersion: '1.20260302.03.01', + clientVersion: '1.20260721.00.00', userAgent: - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36', + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) YouTubeMusic/3.12.0 Chrome/148.0.7778.271 Electron/42.5.0 Safari/537.36', hl: context.client.hl, gl: context.client.gl, - visitorData: context.client.visitorData + applicationState: 'ACTIVE' }, user: { lockedSafetyMode: false }, request: { useSsl: true } @@ -93,11 +95,11 @@ export default class WebRemix extends BaseClient { ): Promise { const sourceName = 'ytmusic' - let params = 'EgWKAQIIAWoSEAMQBRAEEAkQChAVEBAQDhAR' // Default (Tracks) + let params = 'EgWKAQIIAWoQEAQQAxAJEAUQChAQEBUQEQ%3D%3D' // Default (Tracks) if (type === 'playlist') - params = 'EgeKAQQoAEABahIQAxAFEAQQCRAKEBUQEBAOEBE%3D' - if (type === 'album') params = 'EgWKAQIYAWoSEAMQBRAEEAkQChAVEBAQDhAR' - if (type === 'artist') params = 'EgWKAQIgAWoSEAMQBRAEEAkQChAVEBAQDhAR' + params = 'EgeKAQQoAEABahAQBBADEAkQBRAKEBAQFRAR' + if (type === 'album') params = 'EgWKAQIYAWoQEAQQAxAJEAUQChAQEBUQEQ%3D%3D' + if (type === 'artist') params = 'EgWKAQIgAWoQEAQQAxAJEAUQChAQEBUQEQ%3D%3D' const requestBody = { context: this.getClient(context), diff --git a/src/sources/youtube/common.ts b/src/sources/youtube/common.ts index 5341c677..166d1f39 100644 --- a/src/sources/youtube/common.ts +++ b/src/sources/youtube/common.ts @@ -1242,6 +1242,7 @@ function getRendererFromItemData( { key: 'compactPlaylistRenderer', type: 'playlist' }, { key: 'channelRenderer', type: 'channel' }, { key: 'playlistPanelVideoRenderer', type: 'track' }, + { key: 'playlistVideoRenderer', type: 'track' }, { key: 'gridVideoRenderer', type: 'track' } ] @@ -1282,6 +1283,11 @@ export interface TrackBuildOptions { fetchChannelInfo?: boolean maxAlbumPlaylistLength?: number enableHoloTracks?: boolean + search: { + maxResults?: number + resolveExternalLinks?: boolean + fetchChannelInfo?: boolean + } } /** @@ -1310,7 +1316,7 @@ export async function buildTrack( sourceNameOverride: string | null = null, fullApiResponse: Record | null = null, enableHolo = false, - config: TrackBuildOptions = {}, + config: TrackBuildOptions = { search: {} }, makeRequestFn: MakeRequestFn | null = null ): Promise { if (!itemData) { @@ -1683,7 +1689,7 @@ export async function buildHoloTrack( itemData: YouTubeRenderer | null, itemType: string, fullApiResponse: Record | null = null, - config: TrackBuildOptions = {}, + config: TrackBuildOptions = { search: {} }, makeRequestFn: MakeRequestFn | null = null ): Promise { const duration = formatDuration(trackInfo.length) @@ -1872,7 +1878,7 @@ export async function buildHoloTrack( accessibilityLabel || `${trackInfo.title} by ${(channelData.name as string | undefined) || trackInfo.author}` - if (config.fetchChannelInfo && channelData.id && makeRequestFn) { + if (config.search.fetchChannelInfo && channelData.id && makeRequestFn) { try { const channelInfo = await fetchChannelInfo( channelData.id as string, @@ -1906,7 +1912,7 @@ export async function buildHoloTrack( let externalLinks = extractExternalLinks(description) - if (config.resolveExternalLinks && externalLinks && makeRequestFn) { + if (config.search.resolveExternalLinks && externalLinks && makeRequestFn) { try { externalLinks = await resolveExternalLinks(externalLinks, makeRequestFn) } catch (e: unknown) { @@ -2078,7 +2084,7 @@ export async function fetchEncryptedHostFlags( */ export abstract class BaseClient { nodelink: WorkerNodeLink - config: Record + config: WorkerNodeLink['options'] name: string oauth: IOAuth | null @@ -2173,6 +2179,7 @@ export abstract class BaseClient { context: this.getClient(context), videoId: videoId, contentCheckOk: true, + attestationRequest: { omitBotguardData: true }, racyCheckOk: true } @@ -2342,6 +2349,31 @@ export abstract class BaseClient { } const videoDetails = playerResponse.videoDetails + const playabilityStatus = playerResponse.playabilityStatus?.status + + if ( + playabilityStatus && + playabilityStatus !== 'OK' && + playerResponse.microformat?.microformatDataRenderer.appName !== + 'YouTube Music' + ) { + const message = + playerResponse.playabilityStatus?.reason || 'Video not playable.' + logger( + 'warn', + `youtube-${this.name}`, + `Video/short ${videoId} not playable: ${message}` + ) + return { + loadType: 'error', + exception: { + message, + severity: 'common', + cause: 'UpstreamPlayability' + } + } + } + if (!videoDetails?.videoId) { logger( 'error', @@ -2358,27 +2390,16 @@ export abstract class BaseClient { } } - if (playerResponse.playabilityStatus?.status !== 'OK') { - const message = - playerResponse.playabilityStatus?.reason || 'Video not playable.' - if (this.name !== 'WEB_REMIX') { - logger( - 'warn', - `youtube-${this.name}`, - `Video/short ${videoId} not playable: ${message}. Still returning metadata.` - ) - } - } - const track = await buildTrack( videoDetails as YouTubeRenderer, sourceName, null, playerResponse as Record, - !!this.config.enableHoloTracks, + !!this.config.experimental.enableHoloTracks, { - resolveExternalLinks: !!this.config.resolveExternalLinks, - fetchChannelInfo: !!this.config.fetchChannelInfo + resolveExternalLinks: !!this.config.search.resolveExternalLinks, + fetchChannelInfo: !!this.config.search.fetchChannelInfo, + search: {} } ) @@ -2495,7 +2516,58 @@ export abstract class BaseClient { const tracks: YouTubeTrackData[] = [] let selectedTrack = 0 const maxLength = - (this.config.maxAlbumPlaylistLength as number | undefined) || 100 + (this.config.playback?.maxPlaylistLength as number | undefined) || 100 + + if (sourceName === 'ytmusic') { + playlistContent = playlistContent.filter((item) => + getItemValue(item, ['playlistPanelVideoRenderer.videoId']) + ) + } + + let continuation = getItemValue(playlistResponse, [ + 'contents.singleColumnMusicWatchNextResultsRenderer.tabbedRenderer.watchNextTabbedResultsRenderer.tabs.0.tabRenderer.content.musicQueueRenderer.content.playlistPanelRenderer.continuations.0.nextContinuationData.continuation' + ]) + const seenContinuations = new Set() + + while ( + sourceName === 'ytmusic' && + _context && + continuation && + !seenContinuations.has(continuation) && + playlistContent.length < maxLength + ) { + seenContinuations.add(continuation) + const client = this.getClient(_context) + const { body, statusCode } = await makeRequest( + 'https://music.youtube.com/youtubei/v1/next', + { + method: 'POST', + headers: { + 'User-Agent': client.client.userAgent, + 'X-Goog-Api-Format-Version': '2' + }, + body: { context: client, continuation }, + disableBodyCompression: true, + proxy: this.getProxy() + } + ) + if (statusCode !== 200 || !body) break + + const page = getItemValue>(body, [ + 'continuationContents.playlistPanelContinuation' + ]) + const items = (page?.contents as unknown[] | undefined)?.filter((item) => + getItemValue(item, ['playlistPanelVideoRenderer.videoId']) + ) + if (!items?.length) break + + playlistContent.push( + ...items.slice(0, maxLength - playlistContent.length) + ) + continuation = getItemValue(page, [ + 'continuations.0.nextContinuationData.continuation' + ]) + } for (let i = 0; i < Math.min(playlistContent.length, maxLength); i++) { const item = playlistContent[i] as YouTubeRenderer @@ -2505,10 +2577,11 @@ export abstract class BaseClient { sourceName || 'youtube', null, null, - !!this.config.enableHoloTracks, + !!this.config.experimental.enableHoloTracks, { fetchChannelInfo: false, - resolveExternalLinks: false + resolveExternalLinks: false, + search: {} } ) if (track) { @@ -2628,9 +2701,14 @@ export abstract class BaseClient { const sectionContents = sectionList?.contents as | Record[] | undefined - const shelf = sectionContents?.[0]?.musicPlaylistShelfRenderer as - | Record - | undefined + const section = sectionContents?.[0] + const shelf = + (section?.musicPlaylistShelfRenderer as + | Record + | undefined) || + (section?.playlistVideoListRenderer as + | Record + | undefined) const shelfContentsCheck = shelf?.contents as unknown[] | undefined if (!shelf || !shelfContentsCheck || shelfContentsCheck.length === 0) { @@ -2642,10 +2720,54 @@ export abstract class BaseClient { return { loadType: 'empty', data: {} } } - const tracks: YouTubeTrackData[] = [] const maxLength = - (this.config.maxAlbumPlaylistLength as number | undefined) || 100 - const shelfContents = shelf.contents as unknown[] + (this.config.playback?.maxPlaylistLength as number | undefined) || 100 + const shelfContents = shelfContentsCheck.filter( + (item) => !getItemValue(item, ['messageRenderer']) + ) + let continuation = getItemValue(shelf, [ + 'continuations.0.nextContinuationData.continuation' + ]) + const seenContinuations = new Set() + + while ( + this.name === 'ANDROID' && + _context && + continuation && + !seenContinuations.has(continuation) && + shelfContents.length < maxLength + ) { + seenContinuations.add(continuation) + const client = this.getClient(_context) + const { body, statusCode } = await makeRequest( + `${this.getApiEndpoint()}/youtubei/v1/browse`, + { + method: 'POST', + headers: { + 'User-Agent': client.client.userAgent, + 'X-YouTube-Client-Name': '3', + 'X-YouTube-Client-Version': client.client.clientVersion ?? '' + }, + body: { context: client, continuation }, + disableBodyCompression: true, + proxy: this.getProxy() + } + ) + if (statusCode !== 200 || !body) break + + const page = getItemValue>(body, [ + 'continuationContents.playlistVideoListContinuation' + ]) + const items = page?.contents as unknown[] | undefined + if (!items?.length) break + + shelfContents.push(...items.slice(0, maxLength - shelfContents.length)) + continuation = getItemValue(page, [ + 'continuations.0.nextContinuationData.continuation' + ]) + } + + const tracks: YouTubeTrackData[] = [] for (let i = 0; i < Math.min(shelfContents.length, maxLength); i++) { const item = shelfContents[i] as YouTubeRenderer @@ -2655,10 +2777,11 @@ export abstract class BaseClient { sourceName || 'ytmusic', sourceName, browseResponse, - !!this.config.enableHoloTracks, + !!this.config.experimental.enableHoloTracks, { fetchChannelInfo: false, - resolveExternalLinks: false + resolveExternalLinks: false, + search: {} } ) if (track) { @@ -2686,12 +2809,17 @@ export abstract class BaseClient { const headerRoot = browseResponse.header as | Record | undefined + const pageHeader = headerRoot?.pageHeaderRenderer as + | Record + | undefined const musicDetail = headerRoot?.musicDetailHeaderRenderer as | Record | undefined const musicTitle = musicDetail?.title as YouTubeText | undefined - if (musicTitle?.runs?.[0]?.text) { + if (typeof pageHeader?.pageTitle === 'string') { + playlistTitle = pageHeader.pageTitle + } else if (musicTitle?.runs?.[0]?.text) { playlistTitle = musicTitle.runs[0].text } else { const editableHeaderRoot = @@ -2768,7 +2896,7 @@ export abstract class BaseClient { targetItags = [Number(targetItag)] } else { const qualityPriority = this._getQualityPriority() - const audioConfig = this.config.audio as + const audioConfig = this.config.playback?.audio as | Record | undefined const audioQuality = @@ -3100,6 +3228,8 @@ export abstract class BaseClient { format: resolveFormatStr(resolvedFormat?.mimeType as string | undefined), + itag: resolvedFormat?.itag, + hlsUrl: (streamingData.hlsManifestUrl as string | undefined) || null, formats @@ -3307,4 +3437,50 @@ export abstract class BaseClient { itag ) } + + /** + * Fetches the initial visitor data by making a GET request to YouTube. + * This is used to initialize the session context. + * + * @returns The extracted visitor data string, or null if it could not be found. + */ + async getVisitorData(): Promise { + try { + const response = await makeRequest('https://www.youtube.com', { + method: 'GET', + headers: { + 'User-Agent': + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' + }, + proxy: this.getProxy() + }) + + if (response.statusCode !== 200 || !response.body) { + return null + } + + const body = response.body as string + const match = body.match(/ytcfg\.set\((\{.*?\})\);/) + if (match?.[1]) { + try { + const ytcfg = JSON.parse(match[1]) + if (ytcfg.VISITOR_DATA) { + return ytcfg.VISITOR_DATA as string + } + } catch { + // Fallback to regex if JSON parse fails + } + } + + const visitorDataMatch = body.match(/"visitorData":"([^"]+)"/) + return visitorDataMatch?.[1] || null + } catch (err) { + logger( + 'debug', + `youtube-${this.name}`, + `Failed to fetch visitor data: ${err instanceof Error ? err.message : String(err)}` + ) + return null + } + } } diff --git a/src/sources/youtube/sabr/nativeDOM.ts b/src/sources/youtube/sabr/nativeDOM.ts new file mode 100644 index 00000000..2621fee8 --- /dev/null +++ b/src/sources/youtube/sabr/nativeDOM.ts @@ -0,0 +1,1273 @@ +import { Buffer } from 'node:buffer' + +// biome-ignore lint/suspicious/noExplicitAny: internal DOM state uses unknown shapes +type AnyObj = Record + +let _ready = false + +// These are populated by _init() and referenced by NativeDOM constructor. +let EMPTY_ARRAY: readonly never[] +// biome-ignore lint/suspicious/noExplicitAny: constructor cache holds arbitrary constructor functions +let dynamicClassCache: Map +// biome-ignore lint/suspicious/noExplicitAny: event ctor protos hold arbitrary prototype shapes +let EVENT_CTOR_PROTOS: Map +let EVENT_TYPE_MAP: Record +let EVENT_TYPE_KEYS: string[] +let ELEMENT_STRING_PROPS: Set +let ELEMENT_BOOL_PROPS: Set +let ELEMENT_ZERO_PROPS: Set +let SHADOW_ROOT_PROTO: AnyObj +let ANIMATION_OBJ: AnyObj +let CANVAS_2D_CTX: AnyObj +let DEFERRED_REQUEST_OBJ: AnyObj + +// Class references — set by _init() +// biome-ignore lint/suspicious/noExplicitAny: DOM class stubs are untyped by design +let _classes: Record = {} + +function _init() { + if (_ready) return + _ready = true + + EMPTY_ARRAY = Object.freeze([]) as never[] + + dynamicClassCache = new Map() + + function getDummyConstructor(name: string) { + const cached = dynamicClassCache.get(name) + if (cached !== undefined) return cached + + const dummy = () => {} + Object.defineProperty(dummy, 'name', { value: name }) + Object.defineProperty(dummy, 'toString', { + value: () => `function ${name}() { [native code] }` + }) + const proto = Object.create(null) + Object.defineProperty(proto, 'constructor', { + value: dummy, + writable: true, + configurable: true + }) + Object.defineProperty(proto, Symbol.toStringTag, { + value: name, + configurable: true + }) + Object.defineProperty(dummy, 'prototype', { + value: proto, + writable: true, + configurable: true + }) + dynamicClassCache.set(name, dummy) + return dummy + } + + class EventTarget {} + Object.assign(EventTarget.prototype, { + addEventListener() {}, + removeEventListener() {}, + dispatchEvent() { + return true + } + }) + + const NODE_CONSTANTS = Object.freeze({ + ELEMENT_NODE: 1, + ATTRIBUTE_NODE: 2, + TEXT_NODE: 3, + CDATA_SECTION_NODE: 4, + ENTITY_REFERENCE_NODE: 5, + ENTITY_NODE: 6, + PROCESSING_INSTRUCTION_NODE: 7, + COMMENT_NODE: 8, + DOCUMENT_NODE: 9, + DOCUMENT_TYPE_NODE: 10, + DOCUMENT_FRAGMENT_NODE: 11, + NOTATION_NODE: 12, + DOCUMENT_POSITION_DISCONNECTED: 1, + DOCUMENT_POSITION_PRECEDING: 2, + DOCUMENT_POSITION_FOLLOWING: 4, + DOCUMENT_POSITION_CONTAINS: 8, + DOCUMENT_POSITION_CONTAINED_BY: 16, + DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32 + }) + + class Node extends EventTarget {} + Object.assign(Node, NODE_CONSTANTS) + Object.assign(Node.prototype, NODE_CONSTANTS) + + class Element extends Node {} + class HTMLElement extends Element { + get [Symbol.toStringTag]() { + return 'HTMLElement' + } + } + class HTMLIFrameElement extends HTMLElement { + override get [Symbol.toStringTag]() { + return 'HTMLIFrameElement' + } + } + class HTMLCanvasElement extends HTMLElement { + override get [Symbol.toStringTag]() { + return 'HTMLCanvasElement' + } + } + class HTMLImageElement extends HTMLElement { + override get [Symbol.toStringTag]() { + return 'HTMLImageElement' + } + } + class HTMLDivElement extends HTMLElement { + override get [Symbol.toStringTag]() { + return 'HTMLDivElement' + } + } + class HTMLBodyElement extends HTMLElement { + override get [Symbol.toStringTag]() { + return 'HTMLBodyElement' + } + } + class HTMLHtmlElement extends HTMLElement { + override get [Symbol.toStringTag]() { + return 'HTMLHtmlElement' + } + } + class Window extends EventTarget { + get [Symbol.toStringTag]() { + return 'Window' + } + } + class Document extends EventTarget { + get [Symbol.toStringTag]() { + return 'HTMLDocument' + } + } + class HTMLDocument extends Document {} + class Navigator { + get [Symbol.toStringTag]() { + return 'Navigator' + } + } + class Location { + get [Symbol.toStringTag]() { + return 'Location' + } + } + class Performance { + get [Symbol.toStringTag]() { + return 'Performance' + } + } + class Screen { + get [Symbol.toStringTag]() { + return 'Screen' + } + } + class CSSStyleDeclaration { + getPropertyValue() { + return '' + } + setProperty() {} + removeProperty() { + return '' + } + item() { + return '' + } + get [Symbol.toStringTag]() { + return 'CSSStyleDeclaration' + } + } + class PluginArray { + get length() { + return 0 + } + item() { + return null + } + namedItem() { + return null + } + get [Symbol.toStringTag]() { + return 'PluginArray' + } + } + class MimeTypeArray { + get length() { + return 0 + } + item() { + return null + } + namedItem() { + return null + } + get [Symbol.toStringTag]() { + return 'MimeTypeArray' + } + } + class Scheduler { + postTask( + // biome-ignore lint/suspicious/noExplicitAny: BotGuard passes arbitrary callbacks + callback: any, + // biome-ignore lint/suspicious/noExplicitAny: BotGuard options are untyped + options?: any + ) { + const delay = options?.delay || 0 + return new Promise((resolve, reject) => { + const t = setTimeout(async () => { + try { + resolve(await callback()) + } catch (err) { + reject(err) + } + }, delay) + if (options?.signal) { + options.signal.addEventListener('abort', () => { + clearTimeout(t) + // biome-ignore lint/suspicious/noExplicitAny: globalThis DOM extension + const g = globalThis as any + const AbortError = g.DOMException + ? new g.DOMException('The user aborted a request.', 'AbortError') + : new Error('The user aborted a request.') + reject(AbortError) + }) + } + }) + } + get [Symbol.toStringTag]() { + return 'Scheduler' + } + } + + SHADOW_ROOT_PROTO = (() => { + const ShadowRoot = getDummyConstructor('ShadowRoot') + const p = Object.create(ShadowRoot.prototype) + Object.assign(p, { + nodeType: 11, + nodeName: '#document-fragment', + innerHTML: '', + querySelector() { + return null + }, + querySelectorAll() { + return EMPTY_ARRAY + }, + get childNodes() { + return EMPTY_ARRAY + }, + hasChildNodes() { + return false + }, + appendChild(child: unknown) { + return child + }, + removeChild(child: unknown) { + return child + } + }) + return p + })() + + ANIMATION_OBJ = Object.freeze({ + cancel() {}, + finish() {}, + play() {}, + pause() {} + }) + + CANVAS_2D_CTX = Object.freeze({ + fillRect() {}, + clearRect() {}, + getImageData() { + return { data: new Uint8ClampedArray(4) } + }, + putImageData() {}, + measureText() { + return { width: 0 } + }, + createLinearGradient() { + return { addColorStop() {} } + } + }) + + const DeferredRequest = getDummyConstructor('DeferredRequest') + DEFERRED_REQUEST_OBJ = Object.freeze( + Object.assign(Object.create(DeferredRequest.prototype), { activated: true }) + ) + + ELEMENT_STRING_PROPS = new Set([ + 'name', + 'id', + 'className', + 'title', + 'lang', + 'dir', + 'width', + 'height', + 'autocapitalize', + 'elementTiming', + 'border', + 'align', + 'virtualKeyboardPolicy', + 'longDesc', + 'srcset', + 'enterKeyHint', + 'accessKey', + 'innerHTML' + ]) + + ELEMENT_BOOL_PROPS = new Set([ + 'disabled', + 'hidden', + 'checked', + 'isMap', + 'sharedStorageWritable', + 'inert' + ]) + + ELEMENT_ZERO_PROPS = new Set([ + 'scrollTop', + 'scrollLeft', + 'scrollHeight', + 'scrollWidth', + 'clientTop', + 'clientLeft', + 'offsetWidth', + 'offsetHeight', + 'clientWidth', + 'clientHeight', + 'offsetTop', + 'offsetLeft', + 'hspace' + ]) + + EVENT_CTOR_PROTOS = new Map() + + EVENT_TYPE_MAP = { + Mouse: 'MouseEvent', + Keyboard: 'KeyboardEvent', + Touch: 'TouchEvent', + UI: 'UIEvent', + Custom: 'CustomEvent', + Mutation: 'MutationEvent', + Message: 'MessageEvent' + } + EVENT_TYPE_KEYS = Object.keys(EVENT_TYPE_MAP) + + function getEventCtorProto(constructorName: string): AnyObj { + const cached = EVENT_CTOR_PROTOS.get(constructorName) + if (cached !== undefined) return cached + + const dummyCtor = getDummyConstructor(constructorName) + const proto: AnyObj = Object.create(dummyCtor.prototype) + proto.bubbles = false + proto.cancelable = false + proto.eventPhase = 0 + proto.defaultPrevented = false + proto.composed = false + proto.isTrusted = true + proto.target = null + proto.currentTarget = null + proto.srcElement = null + proto.returnValue = true + proto.cancelBubble = false + proto.screenX = 0 + proto.screenY = 0 + proto.clientX = 0 + proto.clientY = 0 + proto.ctrlKey = false + proto.shiftKey = false + proto.altKey = false + proto.metaKey = false + proto.button = 0 + proto.buttons = 0 + proto.which = 0 + proto.pageX = 0 + proto.pageY = 0 + proto.detail = 0 + proto.initEvent = function ( + type: string, + bubbles: boolean, + cancelable: boolean + ) { + this.type = type + this.bubbles = bubbles + this.cancelable = cancelable + } + proto.initMouseEvent = function ( + type: string, + bubbles: boolean, + cancelable: boolean, + _view: unknown, + detail: number, + screenX: number, + screenY: number, + clientX: number, + clientY: number, + ctrlKey: boolean, + altKey: boolean, + shiftKey: boolean, + metaKey: boolean, + button: number, + _relatedTarget: unknown + ) { + this.type = type + this.bubbles = bubbles + this.cancelable = cancelable + this.detail = detail + this.screenX = screenX + this.screenY = screenY + this.clientX = clientX + this.clientY = clientY + this.ctrlKey = ctrlKey + this.altKey = altKey + this.shiftKey = shiftKey + this.metaKey = metaKey + this.button = button + } + proto.initUIEvent = function ( + type: string, + bubbles: boolean, + cancelable: boolean, + _view: unknown, + detail: number + ) { + this.type = type + this.bubbles = bubbles + this.cancelable = cancelable + this.detail = detail + } + proto.stopPropagation = () => {} + proto.preventDefault = () => {} + proto.stopImmediatePropagation = () => {} + + EVENT_CTOR_PROTOS.set(constructorName, proto) + return proto + } + + Object.defineProperties(Node.prototype, { + ownerDocument: { + get() { + // biome-ignore lint/suspicious/noExplicitAny: globalThis DOM extension + return (globalThis as any).document + }, + configurable: true, + enumerable: true + }, + childNodes: { + get() { + return EMPTY_ARRAY + }, + configurable: true, + enumerable: true + }, + nodeValue: { value: null, writable: true, configurable: true }, + textContent: { value: '', writable: true, configurable: true }, + parentNode: { value: null, writable: true, configurable: true }, + hasChildNodes: { + value() { + return false + }, + writable: true, + configurable: true + }, + compareDocumentPosition: { + value() { + return 0 + }, + writable: true, + configurable: true + }, + appendChild: { + value(child: unknown) { + return child + }, + writable: true, + configurable: true + }, + removeChild: { + value(child: unknown) { + return child + }, + writable: true, + configurable: true + }, + insertBefore: { + value(newChild: unknown) { + return newChild + }, + writable: true, + configurable: true + }, + replaceChild: { + value(_newChild: unknown, oldChild: unknown) { + return oldChild + }, + writable: true, + configurable: true + }, + cloneNode: { + value() { + const tag = (this.tagName || '').toLowerCase() || 'div' + // biome-ignore lint/suspicious/noExplicitAny: globalThis DOM extension + return (globalThis as any).document.createElement(tag) + }, + writable: true, + configurable: true + }, + addEventListener: { value() {}, writable: true, configurable: true }, + removeEventListener: { value() {}, writable: true, configurable: true }, + dispatchEvent: { + value() { + return true + }, + writable: true, + configurable: true + }, + moveBefore: { + value(node: unknown) { + return node + }, + writable: true, + configurable: true + }, + lookupPrefix: { + value() { + return null + }, + writable: true, + configurable: true + }, + lookupNamespaceURI: { + value() { + return null + }, + writable: true, + configurable: true + }, + isDefaultNamespace: { + value() { + return false + }, + writable: true, + configurable: true + } + }) + + Object.defineProperties(Element.prototype, { + nodeType: { value: 1, writable: true, configurable: true }, + localName: { + get() { + return (this.tagName || '').toLowerCase() + }, + configurable: true, + enumerable: true + }, + namespaceURI: { + get() { + return 'http://www.w3.org/1999/xhtml' + }, + configurable: true, + enumerable: true + }, + prefix: { value: null, writable: true, configurable: true }, + hasAttribute: { + value() { + return false + }, + writable: true, + configurable: true + }, + getAttribute: { + value() { + return null + }, + writable: true, + configurable: true + }, + setAttribute: { value() {}, writable: true, configurable: true }, + removeAttribute: { value() {}, writable: true, configurable: true }, + hasAttributeNS: { + value() { + return false + }, + writable: true, + configurable: true + }, + getAttributeNS: { + value() { + return null + }, + writable: true, + configurable: true + }, + setAttributeNS: { value() {}, writable: true, configurable: true }, + removeAttributeNS: { value() {}, writable: true, configurable: true }, + releasePointerCapture: { value() {}, writable: true, configurable: true }, + setPointerCapture: { value() {}, writable: true, configurable: true }, + hasPointerCapture: { + value() { + return false + }, + writable: true, + configurable: true + }, + getAttributeNode: { + value() { + return null + }, + writable: true, + configurable: true + }, + getAttributeNodeNS: { + value() { + return null + }, + writable: true, + configurable: true + }, + getElementsByTagName: { + value() { + return EMPTY_ARRAY + }, + writable: true, + configurable: true + }, + getElementsByTagNameNS: { + value() { + return EMPTY_ARRAY + }, + writable: true, + configurable: true + }, + querySelector: { + value() { + return null + }, + writable: true, + configurable: true + }, + querySelectorAll: { + value() { + return EMPTY_ARRAY + }, + writable: true, + configurable: true + }, + scrollTop: { value: 0, writable: true, configurable: true }, + scrollLeft: { value: 0, writable: true, configurable: true }, + scrollHeight: { value: 0, writable: true, configurable: true }, + scrollWidth: { value: 0, writable: true, configurable: true }, + clientTop: { value: 0, writable: true, configurable: true }, + clientLeft: { value: 0, writable: true, configurable: true }, + firstElementChild: { value: null, writable: true, configurable: true }, + lastElementChild: { value: null, writable: true, configurable: true }, + nextElementSibling: { value: null, writable: true, configurable: true }, + previousElementSibling: { value: null, writable: true, configurable: true }, + children: { + get() { + return EMPTY_ARRAY + }, + configurable: true, + enumerable: true + }, + prepend: { value() {}, writable: true, configurable: true }, + append: { value() {}, writable: true, configurable: true }, + replaceWith: { value() {}, writable: true, configurable: true }, + hasAttributes: { + value() { + return false + }, + writable: true, + configurable: true + }, + scrollIntoViewIfNeeded: { value() {}, writable: true, configurable: true }, + removeAttributeNode: { value() {}, writable: true, configurable: true }, + setAttributeNode: { value() {}, writable: true, configurable: true }, + normalize: { value() {}, writable: true, configurable: true }, + dispatchEvent: { + value() { + return true + }, + writable: true, + configurable: true + }, + animate: { + value() { + return ANIMATION_OBJ + }, + writable: true, + configurable: true + }, + browsingTopics: { + async value() { + return EMPTY_ARRAY + }, + writable: true, + configurable: true + }, + ariaNotify: { value() {}, writable: true, configurable: true }, + checkVisibility: { + value() { + return true + }, + writable: true, + configurable: true + }, + webkitMatchesSelector: { + value() { + return false + }, + writable: true, + configurable: true + }, + attachShadow: { + value(init?: { mode?: string }) { + const shadowRoot: AnyObj = Object.create(SHADOW_ROOT_PROTO) + shadowRoot.mode = init?.mode || 'open' + shadowRoot.host = this + return shadowRoot + }, + writable: true, + configurable: true + } + }) + + Object.defineProperties(HTMLElement.prototype, { + dir: { value: '', writable: true, configurable: true }, + id: { value: '', writable: true, configurable: true }, + className: { value: '', writable: true, configurable: true }, + title: { value: '', writable: true, configurable: true }, + lang: { value: '', writable: true, configurable: true }, + offsetHeight: { value: 0, writable: true, configurable: true }, + offsetWidth: { value: 0, writable: true, configurable: true }, + clientHeight: { value: 0, writable: true, configurable: true }, + clientWidth: { value: 0, writable: true, configurable: true }, + click: { value() {}, writable: true, configurable: true }, + blur: { value() {}, writable: true, configurable: true }, + focus: { value() {}, writable: true, configurable: true } + }) + + // ts was so annonying to test and make holy. its not perfect, but it works :p + + Object.defineProperties(Document.prototype, { + defaultCharset: { value: 'UTF-8', writable: true, configurable: true }, + readyState: { value: 'complete', writable: true, configurable: true }, + hidden: { value: false, writable: true, configurable: true }, + hasFocus: { + value() { + return true + }, + writable: true, + configurable: true + }, + getElementsByTagNameNS: { + value() { + return EMPTY_ARRAY + }, + writable: true, + configurable: true + }, + getElementById: { + value() { + return null + }, + writable: true, + configurable: true + }, + querySelector: { + value() { + return null + }, + writable: true, + configurable: true + }, + querySelectorAll: { + value() { + return EMPTY_ARRAY + }, + writable: true, + configurable: true + }, + createTextNode: { + value(text: string) { + return { nodeValue: text, textContent: text } + }, + writable: true, + configurable: true + }, + createDocumentFragment: { + value() { + const frag: AnyObj = Object.create(Node.prototype) + frag.nodeType = 11 + return frag + }, + writable: true, + configurable: true + } + }) + + Object.assign(HTMLIFrameElement.prototype, { + width: '', + height: '', + contentDocument: null, + contentWindow: null + }) + Object.assign(HTMLCanvasElement.prototype, { width: 300, height: 150 }) + Object.assign(HTMLImageElement.prototype, { + width: 0, + height: 0, + src: '', + alt: '', + useMap: '', + complete: true, + hspace: 0, + vspace: 0 + }) + + _classes = { + EventTarget, + Node, + Element, + HTMLElement, + HTMLIFrameElement, + HTMLCanvasElement, + HTMLImageElement, + HTMLDivElement, + HTMLBodyElement, + HTMLHtmlElement, + Window, + Document, + HTMLDocument, + Navigator, + Location, + Performance, + Screen, + CSSStyleDeclaration, + PluginArray, + MimeTypeArray, + Scheduler, + getDummyConstructor, + getEventCtorProto + } +} + +function isConstructorName(prop: string): boolean { + const c0 = prop.charCodeAt(0) + if (c0 >= 65 && c0 <= 90) return true + if ( + c0 === 119 && + prop.length > 6 && + prop.charCodeAt(1) === 101 && + prop.charCodeAt(2) === 98 && + prop.charCodeAt(3) === 107 && + prop.charCodeAt(4) === 105 && + prop.charCodeAt(5) === 116 + ) { + const c6 = prop.charCodeAt(6) + return c6 >= 65 && c6 <= 90 + } + if ( + c0 === 109 && + prop.length > 3 && + prop.charCodeAt(1) === 111 && + prop.charCodeAt(2) === 122 + ) { + const c3 = prop.charCodeAt(3) + return c3 >= 65 && c3 <= 90 + } + if (c0 === 109 && prop.length > 2 && prop.charCodeAt(1) === 115) { + const c2 = prop.charCodeAt(2) + return c2 >= 65 && c2 <= 90 + } + return false +} +export class NativeDOM { + // biome-ignore lint/suspicious/noExplicitAny: window shape is arbitrary BotGuard-facing object + public window: any + + constructor(options: { url: string; referrer: string; userAgent: string }) { + _init() + + const { + EventTarget, + Node, + Element, + HTMLElement, + HTMLIFrameElement, + HTMLCanvasElement, + HTMLImageElement, + HTMLDivElement, + HTMLBodyElement, + HTMLHtmlElement, + Window, + Document, + HTMLDocument, + Navigator, + Location, + Performance, + Screen, + CSSStyleDeclaration, + PluginArray, + MimeTypeArray, + Scheduler, + getDummyConstructor, + getEventCtorProto + } = _classes + + const urlObj = new URL(options.url) + + const performanceMock: AnyObj = Object.create(Performance.prototype) + performanceMock.now = () => performance.now() + performanceMock.timeOrigin = performance.timeOrigin + + const locationMock: AnyObj = Object.create(Location.prototype) + locationMock.href = options.url + locationMock.origin = urlObj.origin + locationMock.protocol = urlObj.protocol + locationMock.host = urlObj.host + locationMock.hostname = urlObj.hostname + locationMock.pathname = urlObj.pathname + locationMock.search = urlObj.search + locationMock.hash = urlObj.hash + locationMock.ancestorOrigins = EMPTY_ARRAY + locationMock.toString = () => options.url + locationMock.valueOf = () => locationMock + + const navigatorMock: AnyObj = Object.create(Navigator.prototype) + navigatorMock.userAgent = options.userAgent + navigatorMock.languages = ['en-US', 'en'] + navigatorMock.platform = 'Win32' + navigatorMock.appName = 'Netscape' + navigatorMock.appCodeName = 'Mozilla' + navigatorMock.plugins = Object.create(PluginArray.prototype) + navigatorMock.mimeTypes = Object.create(MimeTypeArray.prototype) + navigatorMock.cookieEnabled = true + navigatorMock.onLine = true + navigatorMock.hardwareConcurrency = 8 + navigatorMock.deviceMemory = 8 + navigatorMock.maxTouchPoints = 0 + navigatorMock.javaEnabled = () => false + + const TAG_PROTO_MAP: Record = { + iframe: HTMLIFrameElement.prototype, + canvas: HTMLCanvasElement.prototype, + img: HTMLImageElement.prototype, + div: HTMLDivElement.prototype, + body: HTMLBodyElement.prototype, + html: HTMLHtmlElement.prototype + } + + const cssProxyHandler: ProxyHandler = { + get(target, prop, receiver) { + if (typeof prop === 'symbol') return Reflect.get(target, prop, receiver) + if (prop === 'toString') return () => '[object CSSStyleDeclaration]' + if (Reflect.has(target, prop) || Reflect.has(Object.prototype, prop)) { + return Reflect.get(target, prop, receiver) + } + return '' + }, + set() { + return true + } + } + + const elementProxyHandler: ProxyHandler = { + get(target, prop, receiver) { + if (typeof prop !== 'string') return Reflect.get(target, prop, receiver) + if (Reflect.has(target, prop)) + return Reflect.get(target, prop, receiver) + if (ELEMENT_STRING_PROPS.has(prop)) { + const tag = target.tagName?.toLowerCase() + if (prop === 'width' || prop === 'height') { + if (tag === 'canvas') return prop === 'width' ? 300 : 150 + if (tag === 'img') return 0 + return '' + } + return '' + } + if (ELEMENT_BOOL_PROPS.has(prop)) return false + if (ELEMENT_ZERO_PROPS.has(prop)) return 0 + if (prop === 'tabIndex') return -1 + return Reflect.get(target, prop, receiver) + } + } + + const createElement = (tagName: string): AnyObj => { + const tag = tagName.toLowerCase() + const proto = TAG_PROTO_MAP[tag] ?? HTMLElement.prototype + + const styleMock = new Proxy( + Object.create(CSSStyleDeclaration.prototype), + cssProxyHandler + ) + + const element: AnyObj = Object.create(proto) + element.tagName = tag.toUpperCase() + element.nodeName = element.tagName + element.style = styleMock + element.attributes = EMPTY_ARRAY + + if (tag === 'iframe') { + let _contentWindow: AnyObj | null = null + const buildIframe = () => { + if (_contentWindow) return + const subDocument: AnyObj = Object.create(HTMLDocument.prototype) + subDocument.URL = 'about:blank' + subDocument.referrer = options.url + subDocument.readyState = 'complete' + subDocument.defaultCharset = 'UTF-8' + subDocument.hidden = false + subDocument.createElement = createElement + subDocument.createEvent = (type: string) => + documentMock.createEvent(type) + subDocument.body = createElement('body') + subDocument.documentElement = createElement('html') + subDocument.getElementsByTagName = () => EMPTY_ARRAY + subDocument.addEventListener = () => {} + subDocument.removeEventListener = () => {} + subDocument.hasFocus = () => true + + const subWindow: AnyObj = Object.create(Window.prototype) + subWindow.document = subDocument + subWindow.location = locationMock + subWindow.origin = urlObj.origin + subWindow.navigator = navigatorMock + subWindow.performance = performanceMock + subWindow.length = 0 + subWindow.TEMPORARY = 0 + subWindow.PERSISTENT = 1 + subWindow.scrollY = 0 + subWindow.scrollX = 0 + subWindow.btoa = windowMock.btoa + subWindow.atob = windowMock.atob + subWindow.close = () => {} + Object.setPrototypeOf(subWindow, globalThis) + subWindow.window = subWindow + subWindow.self = subWindow + subWindow.top = windowProxy + subWindow.parent = windowProxy + subWindow.frames = subWindow + subDocument.defaultView = subWindow + + _contentWindow = makeWindowProxy(subWindow) + } + Object.defineProperty(element, 'contentWindow', { + get() { + buildIframe() + return _contentWindow + }, + configurable: true, + enumerable: true + }) + Object.defineProperty(element, 'contentDocument', { + get() { + buildIframe() + return _contentWindow?.document ?? null + }, + configurable: true, + enumerable: true + }) + } else if (tag === 'canvas') { + element.getContext = (type: string) => + type === '2d' ? CANVAS_2D_CTX : null + } + + return new Proxy(element, elementProxyHandler) + } + + const createEvent = (type: string): AnyObj => { + let constructorName = 'Event' + for (let i = 0; i < EVENT_TYPE_KEYS.length; i++) { + const key = EVENT_TYPE_KEYS[i] + if (key !== undefined && type.includes(key)) { + constructorName = EVENT_TYPE_MAP[key] ?? 'Event' + break + } + } + const event: AnyObj = Object.create(getEventCtorProto(constructorName)) + event.type = type + event.timeStamp = performance.now() + return event + } + + const documentMock: AnyObj = Object.create(HTMLDocument.prototype) + documentMock.URL = options.url + documentMock.referrer = options.referrer + documentMock.readyState = 'complete' + documentMock.defaultCharset = 'UTF-8' + documentMock.hidden = false + documentMock.location = locationMock + documentMock.body = createElement('body') + documentMock.documentElement = createElement('html') + documentMock.createElement = createElement + documentMock.createEvent = createEvent + documentMock.getElementsByTagName = (name: string) => { + const tag = name.toLowerCase() + if (tag === 'head' || tag === 'body' || tag === 'html') + return [createElement(tag)] + return EMPTY_ARRAY + } + documentMock.getElementsByTagNameNS = (_ns: string, name: string) => + documentMock.getElementsByTagName(name) + documentMock.addEventListener = () => {} + documentMock.removeEventListener = () => {} + documentMock.hasFocus = () => true + + const windowMock: AnyObj = Object.create(Window.prototype) + windowMock.document = documentMock + windowMock.location = locationMock + windowMock.origin = urlObj.origin + windowMock.navigator = navigatorMock + windowMock.performance = performanceMock + windowMock.name = '' + windowMock.innerHeight = 1080 + windowMock.innerWidth = 1920 + windowMock.outerHeight = 1080 + windowMock.outerWidth = 1920 + windowMock.screenX = 0 + windowMock.screenY = 0 + windowMock.screenLeft = 0 + windowMock.screenTop = 0 + windowMock.devicePixelRatio = 1 + windowMock.screen = Object.assign(Object.create(Screen.prototype), { + width: 1920, + height: 1080, + availWidth: 1920, + availHeight: 1080, + colorDepth: 24, + pixelDepth: 24 + }) + windowMock.length = 0 + windowMock.TEMPORARY = 0 + windowMock.PERSISTENT = 1 + windowMock.scrollY = 0 + windowMock.scrollX = 0 + windowMock.btoa = (str: string) => + Buffer.from(str, 'binary').toString('base64') + windowMock.atob = (str: string) => + Buffer.from(str, 'base64').toString('binary') + windowMock.close = () => {} + windowMock.getComputedStyle = (el: AnyObj) => el.style || {} + windowMock.cancelIdleCallback = () => {} + windowMock.requestIdleCallback = (cb: () => void) => setTimeout(cb, 1) + windowMock.credentialless = false + windowMock.offscreenBuffering = true + windowMock.isSecureContext = true + windowMock.reportError = (err: unknown) => { + console.error(err) + } + windowMock.history = { + length: 1, + scrollRestoration: 'auto', + state: null, + back() {}, + forward() {}, + go() {}, + pushState() {}, + replaceState() {} + } + windowMock.sharedStorage = {} + windowMock.scheduler = new Scheduler() + windowMock.fetchLater = () => DEFERRED_REQUEST_OBJ + + Object.assign(windowMock, { + EventTarget, + Window, + Document, + HTMLDocument, + Navigator, + Location, + Performance, + PluginArray, + MimeTypeArray, + CSSStyleDeclaration, + Screen, + Node, + Element, + HTMLElement, + HTMLIFrameElement, + HTMLCanvasElement, + HTMLImageElement, + HTMLDivElement, + HTMLBodyElement, + HTMLHtmlElement, + Scheduler + }) + + const makeWindowProxy = (winTarget: AnyObj) => + new Proxy(winTarget, { + has(target, prop) { + if (typeof prop !== 'string') return Reflect.has(target, prop) + if (Reflect.has(target, prop) || Reflect.has(globalThis, prop)) + return true + if (isConstructorName(prop)) return true + return ( + prop.length > 2 && + prop.charCodeAt(0) === 111 && + prop.charCodeAt(1) === 110 + ) + }, + getOwnPropertyDescriptor(target, prop) { + if (typeof prop !== 'string') + return Reflect.getOwnPropertyDescriptor(target, prop) + if (Reflect.has(target, prop)) + return Reflect.getOwnPropertyDescriptor(target, prop) + if (isConstructorName(prop)) { + return { + value: getDummyConstructor(prop), + writable: true, + enumerable: true, + configurable: true + } + } + if ( + prop.length > 2 && + prop.charCodeAt(0) === 111 && + prop.charCodeAt(1) === 110 + ) { + return { + value: null, + writable: true, + enumerable: true, + configurable: true + } + } + if (Reflect.has(globalThis, prop)) + return Reflect.getOwnPropertyDescriptor(globalThis, prop) + return Reflect.getOwnPropertyDescriptor(target, prop) + }, + get(target, prop, receiver) { + if (typeof prop !== 'string') + return Reflect.get(target, prop, receiver) + if ( + prop === 'window' || + prop === 'self' || + prop === 'top' || + prop === 'parent' || + prop === 'frames' + ) { + return receiver + } + if (Reflect.has(target, prop)) + return Reflect.get(target, prop, receiver) + if (isConstructorName(prop)) return getDummyConstructor(prop) + if ( + prop.length > 2 && + prop.charCodeAt(0) === 111 && + prop.charCodeAt(1) === 110 + ) + return null + if (Reflect.has(globalThis, prop)) + return Reflect.get(globalThis, prop) + return Reflect.get(target, prop, receiver) + } + }) + + // windowProxy must exist before iframe sub-windows reference it. + let windowProxy: AnyObj + windowProxy = makeWindowProxy(windowMock) + documentMock.defaultView = windowProxy + this.window = windowProxy + } +} diff --git a/src/sources/youtube/sabr/potoken.ts b/src/sources/youtube/sabr/potoken.ts index 549dbf25..2668a29e 100644 --- a/src/sources/youtube/sabr/potoken.ts +++ b/src/sources/youtube/sabr/potoken.ts @@ -17,7 +17,7 @@ const TOKENS_LOG_PATH = path.join(process.cwd(), 'po_tokens.jsonl') const PO_CONFIG = { apiKey: 'AIzaSyDyT5W0Jh49F30Pqqtyfdf7pDLFKLJoAnw', userAgent: - 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36', + 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150.0.0.0 Safari/537.36', ytBaseUrl: 'https://www.youtube.com', googBaseUrl: 'https://jnn-pa.googleapis.com' } @@ -299,7 +299,7 @@ export class PoTokenManager { private _idleTimer: NodeJS.Timeout | null = null /** - * Refreshes the idle timeout for JSDOM resources. + * Refreshes the idle timeout for NativeDOM resources. * @internal */ private _refreshIdleTimer(): void { @@ -309,7 +309,7 @@ export class PoTokenManager { logger( 'debug', 'PoToken', - 'Idle timeout reached. Cleaning up JSDOM resources.' + 'Idle timeout reached. Cleaning up NativeDOM resources.' ) this.reset() }, @@ -319,8 +319,8 @@ export class PoTokenManager { } /** - * Applies JSDOM environment to globalThis. - * @param dom - JSDOM instance. + * Applies NativeDOM environment to globalThis. + * @param dom - NativeDOM instance. * @internal */ private _applyDomGlobals(dom: { @@ -358,7 +358,7 @@ export class PoTokenManager { } /** - * Cleans up JSDOM and restores previous globals. + * Cleans up NativeDOM and restores previous globals. * @internal */ private _cleanupDom(): void { @@ -426,13 +426,13 @@ export class PoTokenManager { 'user-agent': PO_CONFIG.userAgent, 'x-goog-api-key': PO_CONFIG.apiKey, 'x-youtube-client-name': '1', - 'x-youtube-client-version': '2.20260114.01.00' + 'x-youtube-client-version': '2.20260706.00.00' }, body: JSON.stringify({ context: { client: { clientName: 'WEB', - clientVersion: '2.20260114.01.00', + clientVersion: '2.20260706.00.00', visitorData } }, @@ -509,16 +509,28 @@ export class PoTokenManager { `VisitorData: ${this.visitorData?.slice(0, 20)}...` ) - this._cleanupDom() - const { JSDOM } = await import('jsdom') - this._dom = new JSDOM( - '', - { - url: 'https://www.youtube.com/', - referrer: 'https://www.youtube.com/', - userAgent: PO_CONFIG.userAgent - } + await this._initializeWithDom() + logger( + 'debug', + 'PoToken', + 'BotGuard initialization with NativeDOM complete' ) + } + + /** + * Internal helper to perform BotGuard initialization with NativeDOM. + * @internal + */ + private async _initializeWithDom(): Promise { + this._cleanupDom() + + const { NativeDOM } = await import('./nativeDOM.ts') + this._dom = new NativeDOM({ + url: 'https://www.youtube.com/', + referrer: 'https://www.youtube.com/', + userAgent: PO_CONFIG.userAgent + }) + this._applyDomGlobals(this._dom) logger('debug', 'PoToken', 'Fetching attestation challenge...') @@ -562,11 +574,17 @@ export class PoTokenManager { body: JSON.stringify([requestKey, botguardResponse]) }) - const response = (await integrityTokenResponse.json()) as [string, unknown] - if (typeof response[0] !== 'string') - throw new Error('Could not get integrity token') + const response = (await integrityTokenResponse.json()) as unknown[] + let token = '' + if (response && typeof response[0] === 'string') { + token = response[0] + } else if (response && typeof response[3] === 'string') { + token = response[3] + } + + if (!token) throw new Error('Could not get integrity token') - this.integrityToken = response[0] + this.integrityToken = token logger( 'debug', 'PoToken', diff --git a/src/sources/youtube/sabr/sabr.ts b/src/sources/youtube/sabr/sabr.ts index bfe181e1..33c8bb48 100644 --- a/src/sources/youtube/sabr/sabr.ts +++ b/src/sources/youtube/sabr/sabr.ts @@ -77,6 +77,13 @@ const MAX_BUFFER_BYTES = 512 * 1024 */ const MIN_REQUEST_INTERVAL_MS = 500 +type RecoveryReason = + | 'protection' + | 'reload' + | 'starvation' + | 'http' + | 'session' + /** * Computes the SHA-256 hash of a byte array as a hex string. * @param u8 - Input byte array. @@ -541,9 +548,6 @@ export class SabrStream extends PassThrough { /** Current request sequence number. */ requestNumber: number - /** Whether media headers have been processed. */ - private mediaHeadersProcessed: boolean - /** Flag indicating the stream has been aborted. */ private _aborted: boolean @@ -583,17 +587,41 @@ export class SabrStream extends PassThrough { /** Position callback for reporting playback progress. */ private positionCallback: ((positionMs: number) => void) | undefined + /** Callback used to stop the SABR playhead while playback is paused. */ + private playbackPaused: (() => boolean) | undefined + /** User-Agent header for HTTP requests. */ private userAgent: string /** Whether a recovery operation is pending. */ private recoveryPending: boolean + /** Whether the current session is paused for transfer to a seek stream. */ + private seekHandoffPending: boolean + + /** Whether this stream started by continuing a transferred seek session. */ + private usingTransferredSession: boolean + + /** Currently active UMP request, awaited before exporting seek state. */ + private activeRequest: Promise | null + /** Flag to prevent duplicate PO token generation. */ private poTokenGenerated: boolean - /** Flag to prevent repeated stall emissions. */ - private stallEmitted: boolean + /** Monotonic counter advanced whenever a media segment completes. */ + private mediaProgressGeneration: number + + /** Status-2 observations made without intervening media progress. */ + private limitedPlaybackCount: number + + /** Media generation associated with the current status-2 streak. */ + private limitedPlaybackGeneration: number + + /** Recovery requested while the current UMP response is still being read. */ + private pendingRecoveryReason: RecoveryReason | null + + /** SABR error deferred until the complete UMP response has been processed. */ + private pendingResponseError: Error | null /** Total downloaded duration in milliseconds. */ totalDownloadedMs: number @@ -714,7 +742,6 @@ export class SabrStream extends PassThrough { this.sabrContexts = new Map() this.activeSabrContextTypes = new Set() this.requestNumber = 0 - this.mediaHeadersProcessed = false this._aborted = false this.formatSequenceCounters = new Map() this.downloadedSegmentsByItag = new Map() @@ -737,10 +764,18 @@ export class SabrStream extends PassThrough { this.formatIds = config.formats ?? [] this.startTime = config.startTime ?? 0 this.positionCallback = config.positionCallback + this.playbackPaused = config.playbackPaused this.userAgent = config.userAgent ?? USER_AGENT this.recoveryPending = false + this.seekHandoffPending = false + this.usingTransferredSession = config.previousSession != null + this.activeRequest = null this.poTokenGenerated = false - this.stallEmitted = false + this.mediaProgressGeneration = 0 + this.limitedPlaybackCount = 0 + this.limitedPlaybackGeneration = 0 + this.pendingRecoveryReason = null + this.pendingResponseError = null this.totalDownloadedMs = 0 this.virtualPlayerTimeMs = 0 @@ -750,7 +785,7 @@ export class SabrStream extends PassThrough { this.cachedBufferedRanges = null this.lastReportedRanges = new Set() - this.enableTrafficLog = true + this.enableTrafficLog = false this.trafficLogPath = path.join(process.cwd(), 'sabr_traffic.jsonl') this.enableTrafficDump = true this.trafficDumpMaxBytes = 64 * 1024 @@ -772,12 +807,23 @@ export class SabrStream extends PassThrough { } else if (config.poToken instanceof Uint8Array) { this.poToken = config.poToken } + this.poTokenGenerated = (this.poToken?.length ?? 0) > 0 if (config.previousSession) { const ps = config.previousSession this.requestNumber = ps.requestNumber ?? 0 this.bandwidthEstimate = ps.bandwidthEstimate ?? 5_000_000 this.nextRequestPolicy = ps.nextRequestPolicy + this.sabrContexts = new Map( + (ps.sabrContexts ?? []).map((context) => [ + context.type, + { + ...context, + value: context.value.slice() + } + ]) + ) + this.activeSabrContextTypes = new Set(ps.activeSabrContextTypes ?? []) logger( 'info', 'SABR', @@ -807,9 +853,53 @@ export class SabrStream extends PassThrough { requestNumber: this.requestNumber, bandwidthEstimate: this.bandwidthEstimate, nextRequestPolicy: this.nextRequestPolicy + ? { + ...this.nextRequestPolicy, + playbackCookie: this.nextRequestPolicy.playbackCookie?.slice() + } + : undefined, + sabrContexts: Array.from(this.sabrContexts.values(), (context) => ({ + ...context, + value: context.value.slice() + })), + activeSabrContextTypes: Array.from(this.activeSabrContextTypes) } } + /** Pauses new requests and exports continuity state for a seek replacement. */ + async beginSeekHandoff(): Promise { + if ( + this._aborted || + this.destroyed || + this.recoveryPending || + this.seekHandoffPending + ) + return null + + this.seekHandoffPending = true + const request = this.activeRequest + if (request) { + try { + await request + } catch { + this.seekHandoffPending = false + return null + } + } + + if (this._aborted || this.destroyed || this.recoveryPending) { + this.seekHandoffPending = false + return null + } + + return this.getSessionState() + } + + /** Resumes the current session when a prepared seek stream could not commit. */ + cancelSeekHandoff(): void { + this.seekHandoffPending = false + } + /** * Writes a traffic log entry to the log file. * @param entry - Log entry to write. @@ -860,6 +950,62 @@ export class SabrStream extends PassThrough { this.loop(audioFormat) } + /** Returns the current media-progress generation for recovery validation. */ + getMediaProgressGeneration(): number { + return this.mediaProgressGeneration + } + + /** Returns whether a prepared replacement still matches the stalled state. */ + canCommitRecovery(generation: number): boolean { + return ( + this.recoveryPending && + !this._aborted && + !this.destroyed && + this.mediaProgressGeneration === generation + ) + } + + /** Resumes the existing session when recovery became stale while resolving. */ + cancelRecovery(): void { + this.recoveryPending = false + } + + /** Emits one recovery request and records the media generation it protects. */ + private signalRecovery(reason: RecoveryReason): void { + if (this.recoveryPending || this._aborted || this.destroyed) return + this.recoveryPending = true + this.emit('stall', reason, this.mediaProgressGeneration) + } + + /** Defers recovery until all parts in the current UMP response are handled. */ + private queueRecovery(reason: RecoveryReason): void { + if (this.pendingRecoveryReason === 'reload') return + if (reason === 'reload' || !this.pendingRecoveryReason) { + this.pendingRecoveryReason = reason + } + } + + /** Records completed media and invalidates protection-only recovery evidence. */ + private recordMediaProgress(): void { + if (this.mediaProgressGeneration === 0) { + this.lastVirtualAdvanceAt = Date.now() + } + this.mediaProgressGeneration++ + this.emit('mediaProgress', this.mediaProgressGeneration) + this.limitedPlaybackCount = 0 + this.limitedPlaybackGeneration = this.mediaProgressGeneration + if (this.pendingRecoveryReason === 'protection') { + this.pendingRecoveryReason = null + } + } + + /** Emits any recovery collected while parsing the response. */ + private flushPendingRecovery(): void { + const reason = this.pendingRecoveryReason + this.pendingRecoveryReason = null + if (reason) this.signalRecovery(reason) + } + /** * Main streaming loop that fetches and processes segments. * @param audioFormat - Audio format configuration. @@ -867,10 +1013,8 @@ export class SabrStream extends PassThrough { private async loop(audioFormat: FormatEntry): Promise { const signal = this.abortController.signal try { - if (this.lastVirtualAdvanceAt === 0) - this.lastVirtualAdvanceAt = Date.now() while (!this._aborted && !this.destroyed && !this.streamFinished) { - if (this.recoveryPending) { + if (this.recoveryPending || this.seekHandoffPending) { await wait(500, signal) continue } @@ -902,24 +1046,20 @@ export class SabrStream extends PassThrough { const now = Date.now() const prevPlayerTime = this.virtualPlayerTimeMs + const paused = this.playbackPaused?.() ?? false - if (this.totalDownloadedMs > this.virtualPlayerTimeMs) { - if (this.lastVirtualAdvanceAt > 0) { - this.virtualPlayerTimeMs += now - this.lastVirtualAdvanceAt - } - this.lastVirtualAdvanceAt = now - } else { - if (this.totalDownloadedMs > 0) { - if (this.lastVirtualAdvanceAt > 0) { - const advance = now - this.lastVirtualAdvanceAt - this.virtualPlayerTimeMs = Math.min( - this.virtualPlayerTimeMs + advance, - this.totalDownloadedMs - ) - } - this.lastVirtualAdvanceAt = now - } + if ( + !paused && + this.mediaProgressGeneration > 0 && + this.lastVirtualAdvanceAt > 0 && + this.totalDownloadedMs > this.virtualPlayerTimeMs + ) { + this.virtualPlayerTimeMs = Math.min( + this.virtualPlayerTimeMs + (now - this.lastVirtualAdvanceAt), + this.totalDownloadedMs + ) } + this.lastVirtualAdvanceAt = now if ( Math.floor(this.virtualPlayerTimeMs / 1000) !== @@ -936,16 +1076,22 @@ export class SabrStream extends PassThrough { const reportedPlayerTime = Math.floor( this.virtualPlayerTimeMs + baseTimeMs ) + const requestCursorMs = Math.floor(this.totalDownloadedMs + baseTimeMs) if (this.readableLength > MAX_BUFFER_BYTES) { await wait(250, signal) continue } - if (this.mediaHeadersProcessed && this.positionCallback) { + if (this.mediaProgressGeneration > 0 && this.positionCallback) { this.positionCallback(reportedPlayerTime) } + if (paused && this.mediaProgressGeneration > 0) { + await wait(250, signal) + continue + } + if (this.lastRequestAt) { const since = now - this.lastRequestAt if (since < MIN_REQUEST_INTERVAL_MS) @@ -953,63 +1099,44 @@ export class SabrStream extends PassThrough { } this.lastRequestAt = Date.now() + const request = this.fetchAndProcessSegments( + { + playerTimeMs: requestCursorMs, + bandwidthEstimate: Math.max( + Math.floor(this.bandwidthEstimate), + 500_000 + ), + enabledTrackTypesBitfield: 1, + audioTrackId: audioFormat.audioTrackId ?? '', + playerState: 1n, + visibility: 1, + playbackRate: 1.0, + stickyResolution: 1080, + lastManualSelectedResolution: 1080, + clientViewportIsFlexible: false + }, + audioFormat + ) + this.activeRequest = request try { - await this.fetchAndProcessSegments( - { - playerTimeMs: Math.floor(this.totalDownloadedMs + baseTimeMs), - bandwidthEstimate: Math.max( - Math.floor(this.bandwidthEstimate), - 500_000 - ), - enabledTrackTypesBitfield: 1, - audioTrackId: audioFormat.audioTrackId ?? '', - playerState: 1n, - visibility: 1, - playbackRate: 1.0, - stickyResolution: 1080, - lastManualSelectedResolution: 1080, - clientViewportIsFlexible: false - }, - audioFormat - ) + await request } catch (e) { if (this._aborted || this.destroyed) break const message = e instanceof Error ? e.message : String(e) - if ( - message.includes('sabr.malformed_config') || - message.includes('sabr.media_serving_enforcement_id_error') - ) { + if (message.startsWith('HTTP ')) { logger( 'warn', 'SABR', - `Recoverable error detected: ${message}. Triggering recovery signal...` + `HTTP failure detected: ${message}. Triggering session recovery...` ) - - if (message.includes('media_serving_enforcement_id_error')) { - logger( - 'warn', - 'SABR', - 'Enforcement ID error detected. Clearing SABR contexts to force fresh state.' - ) - this.sabrContexts.clear() - this.activeSabrContextTypes.clear() - } - - this.emit('stall') - - const currentRn = this.requestNumber - while ( - this.requestNumber === currentRn && - !this._aborted && - !this.destroyed - ) { - await wait(500, signal) - } + this.signalRecovery('http') continue } throw e + } finally { + if (this.activeRequest === request) this.activeRequest = null } if ( @@ -1033,6 +1160,22 @@ export class SabrStream extends PassThrough { if (this._aborted) return this this._aborted = true this.abortController.abort() + this.initializedFormatsMap.clear() + this.partialSegmentQueue.clear() + this.sabrContexts.clear() + this.activeSabrContextTypes.clear() + this.formatSequenceCounters.clear() + this.downloadedSegmentsByItag.clear() + this.endSegmentNumbers.clear() + this.pendingRangesHeaders.clear() + this.cachedBufferedRanges = null + this.lastReportedRanges.clear() + this.nextRequestPolicy = undefined + this.formatIds = [] + this.poToken = null + this.videoPlaybackUstreamerConfig = undefined + this.clientInfo = undefined + this.config = {} as SabrStreamConfig super.destroy(err) return this } @@ -1056,7 +1199,7 @@ export class SabrStream extends PassThrough { if (config.videoPlaybackUstreamerConfig) { this.videoPlaybackUstreamerConfig = config.videoPlaybackUstreamerConfig } - if (config.poToken) { + if (config.poToken != null) { try { this.poToken = typeof config.poToken === 'string' @@ -1069,6 +1212,7 @@ export class SabrStream extends PassThrough { 'SABR', `Failed to decode PO token (session update): ${message}` ) + this.poToken = null } } if (config.visitorData) { @@ -1096,8 +1240,13 @@ export class SabrStream extends PassThrough { this.noMediaStreak = 0 this.pendingRangesHeaders.clear() this.recoveryPending = false - this.poTokenGenerated = false - this.stallEmitted = false + this.poTokenGenerated = + config.poToken != null && (this.poToken?.length ?? 0) > 0 + this.pendingRecoveryReason = null + this.pendingResponseError = null + this.limitedPlaybackCount = 0 + this.limitedPlaybackGeneration = this.mediaProgressGeneration + this.usingTransferredSession = false logger( 'info', @@ -1113,11 +1262,8 @@ export class SabrStream extends PassThrough { */ clearBuffers(): void { this.initializedFormatsMap.clear() - this.downloadedSegmentsByItag.clear() - this.formatSequenceCounters.clear() this.partialSegmentQueue.clear() - this.mediaHeadersProcessed = false this.pendingRangesHeaders.clear() this.cachedBufferedRanges = null this.lastReportedRanges.clear() @@ -1132,57 +1278,6 @@ export class SabrStream extends PassThrough { ) } - /** - * Seeks to a specific position in the stream. - * - * Clears segment buffers and resets tracking state while preserving - * session state (request number, bandwidth estimate, playback cookie). - * - * @param positionMs - Target position in milliseconds. - * @returns True if the seek was initiated successfully. - */ - seekTo(positionMs: number): boolean { - if (this._aborted || this.destroyed) { - logger('warn', 'SABR', 'Cannot seek: stream is destroyed or aborted') - return false - } - - logger( - 'info', - 'SABR', - `Seeking to ${positionMs}ms (from startTime=${this.startTime}ms)` - ) - - this.startTime = positionMs - - this.downloadedSegmentsByItag.clear() - this.formatSequenceCounters.clear() - this.partialSegmentQueue.clear() - this.initializedFormatsMap.clear() - - this.totalDownloadedMs = 0 - this.virtualPlayerTimeMs = 0 - this.cumulativeDownloadedMs = positionMs - this.lastVirtualAdvanceAt = Date.now() - - this.pendingRangesHeaders.clear() - this.cachedBufferedRanges = null - this.lastReportedRanges.clear() - - this.mediaHeadersProcessed = false - this.streamFinished = false - - this.noMediaStreak = 0 - - logger( - 'debug', - 'SABR', - `Seek to ${positionMs}ms complete. Session preserved (rn=${this.requestNumber})` - ) - - return true - } - /** * Decodes a UMP part using a protobuf decoder. * @param part - UMP part to decode. @@ -1288,7 +1383,7 @@ export class SabrStream extends PassThrough { ;(error as Error & { code?: number; type?: string }).code = err.code ;(error as Error & { code?: number; type?: string }).type = err.type if (this._aborted || this.destroyed) return - throw error + this.pendingResponseError ??= error } } @@ -1319,6 +1414,34 @@ export class SabrStream extends PassThrough { now - this.lastStreamProtectionLogAt > 5000 this.lastStreamProtectionStatus = status.status + // extra for me: mostly of this time this is cause by poToken, + // related to the DOM generation ^^ + // but it can also be other reasons (PMD:undefined for example, which is also from DOM generation) + if (status.status === 2) { + if (this.limitedPlaybackGeneration !== this.mediaProgressGeneration) { + this.limitedPlaybackGeneration = this.mediaProgressGeneration + this.limitedPlaybackCount = 0 + } + this.limitedPlaybackCount++ + + if (shouldLog) { + this.lastStreamProtectionLogAt = now + logger( + 'warn', + 'SABR', + `Stream Protection Status: ${status.status} (Limited Playback), observation ${this.limitedPlaybackCount} without media progress.` + ) + } + + if (this.limitedPlaybackCount >= 2) { + poTokenManager.reset() + this.queueRecovery('protection') + } + return + } + + this.limitedPlaybackCount = 0 + this.limitedPlaybackGeneration = this.mediaProgressGeneration if (!shouldLog) return this.lastStreamProtectionLogAt = now @@ -1331,20 +1454,6 @@ export class SabrStream extends PassThrough { return } - if (status.status === 2) { - if (this.stallEmitted) return - this.stallEmitted = true - logger( - 'warn', - 'SABR', - `Stream Protection Status: ${status.status} (Limited Playback). Triggering token refresh...` - ) - poTokenManager.reset() - this.recoveryPending = true - this.emit('stall') - return - } - logger('warn', 'SABR', `Stream Protection Status: ${status.status}`) } @@ -1374,6 +1483,8 @@ export class SabrStream extends PassThrough { const bytes = dataToPush.getLength() s.loadedBytes = (s.loadedBytes ?? 0) + bytes + if (s.discard) return + for (const c of dataToPush.chunks) this.push(c) } } @@ -1390,9 +1501,11 @@ export class SabrStream extends PassThrough { const bytes = d.getLength() s.loadedBytes = (s.loadedBytes ?? 0) + bytes - for (const c of d.chunks) this.push(c) + if (!s.discard) { + for (const c of d.chunks) this.push(c) + } - if (bytes > 0) { + if (bytes > 0 && !s.discard) { logger( 'debug', 'SABR', @@ -1436,16 +1549,22 @@ export class SabrStream extends PassThrough { const mediaHeader = h const formatIdKey = key - - if (!this.pendingRangesHeaders.has(formatIdKey)) { - this.pendingRangesHeaders.set(formatIdKey, []) + const itag = h.itag ?? h.formatId?.itag + const discard = + itag !== undefined && + this.downloadedSegmentsByItag.get(itag)?.has(segmentNumber) === true + + if (!discard) { + if (!this.pendingRangesHeaders.has(formatIdKey)) { + this.pendingRangesHeaders.set(formatIdKey, []) + } + this.pendingRangesHeaders.get(formatIdKey)?.push(mediaHeader) } - this.pendingRangesHeaders.get(formatIdKey)?.push(mediaHeader) logger( - 'debug', + discard ? 'trace' : 'debug', 'SABR', - `MediaHeader: id=${headerId} itag=${h.itag} seq=${segmentNumber} dur=${h.durationMs}ms` + `${discard ? 'Duplicate media header' : 'MediaHeader'}: id=${headerId} itag=${h.itag} seq=${segmentNumber} dur=${h.durationMs}ms` ) this.partialSegmentQueue.set(headerId, { @@ -1453,7 +1572,8 @@ export class SabrStream extends PassThrough { segmentNumber, mediaHeader: h, durationMs: h.durationMs, - loadedBytes: 0 + loadedBytes: 0, + discard }) } else { logger('warn', 'SABR', 'Failed to decode MediaHeader') @@ -1476,6 +1596,16 @@ export class SabrStream extends PassThrough { const itag = s.mediaHeader?.itag ?? s.mediaHeader?.formatId?.itag + if (s.discard) { + logger( + 'debug', + 'SABR', + `Discarded duplicate segment ${s.segmentNumber} for itag ${itag ?? 'unknown'} (${s.loadedBytes} bytes)` + ) + this.partialSegmentQueue.delete(id) + return + } + let segmentDuration = 0 if (s.durationMs) { segmentDuration = Number(s.durationMs) @@ -1492,7 +1622,7 @@ export class SabrStream extends PassThrough { if (segmentDuration > 0) { this.totalDownloadedMs += segmentDuration - this.mediaHeadersProcessed = true + if ((s.loadedBytes ?? 0) > 0) this.recordMediaProgress() logger( 'debug', 'SABR', @@ -1678,7 +1808,7 @@ export class SabrStream extends PassThrough { 'SABR', `Reload requested by server. Reason: ${reason ?? 'unknown'}` ) - this.emit('stall') + this.queueRecovery('reload') } } @@ -1705,32 +1835,28 @@ export class SabrStream extends PassThrough { const cookieLen = this.nextRequestPolicy?.playbackCookie?.length ?? 0 const initKeys = Array.from(this.initializedFormatsMap.keys()).slice(0, 5) - const segMap = audioFormat - ? this.downloadedSegmentsByItag.get(audioFormat.itag) - : undefined - const segs = segMap ? Array.from(segMap.values()) : [] - const downloadedMs = segs.reduce( - (sum, s) => sum + parseInt(s.durationMs?.toString() ?? '0', 10), - 0 + const playbackTimeMs = Math.floor( + this.virtualPlayerTimeMs + (this.startTime ?? 0) + ) + const bufferedAheadMs = Math.max( + 0, + Math.floor(this.totalDownloadedMs - this.virtualPlayerTimeMs) ) - const aheadMs = - abrState?.playerTimeMs !== undefined - ? downloadedMs - abrState.playerTimeMs - : undefined const fmt = (f: FormatEntry | undefined): string => f ? `${f.itag}:${f.xtags ?? ''}` : 'none' + const fmtId = (f: FormatIdMsg): string => `${f.itag ?? ''}:${f.xtags ?? ''}` logger( 'debug', 'SABR', - `State rn=${this.requestNumber} playerTimeMs=${abrState?.playerTimeMs} startTime=${this.startTime} readable=${this.readableLength}/${MAX_BUFFER_BYTES} initKeys=[${initKeys.join(',')}] downloadedMs=${downloadedMs} aheadMs=${aheadMs}` + `State rn=${this.requestNumber} requestCursorMs=${abrState?.playerTimeMs} playbackTimeMs=${playbackTimeMs} startTime=${this.startTime} readable=${this.readableLength}/${MAX_BUFFER_BYTES} initKeys=[${initKeys.join(',')}] downloadedMs=${Math.floor(this.totalDownloadedMs)} bufferedAheadMs=${bufferedAheadMs}` ) logger( 'debug', 'SABR', - `Req formats audio=${fmt(audioFormat)} video=${fmt(videoFormat)} selected=[${(selectedFormatIds ?? []).map(String).join(',')}] preferredA=[${(preferredAudioFormatIds ?? []).map(String).join(',')}] bufferedRanges=${bufferedRanges?.length ?? 0} ctx=${contexts?.length ?? 0} unsentCtx=${unsent?.length ?? 0} backoff=${this.nextRequestPolicy?.backoffTimeMs ?? 0} cookieLen=${cookieLen}` + `Req formats audio=${fmt(audioFormat)} video=${fmt(videoFormat)} selected=[${(selectedFormatIds ?? []).map(fmtId).join(',')}] preferredA=[${(preferredAudioFormatIds ?? []).map(fmtId).join(',')}] bufferedRanges=${bufferedRanges?.length ?? 0} ctx=${contexts?.length ?? 0} unsentCtx=${unsent?.length ?? 0} backoff=${this.nextRequestPolicy?.backoffTimeMs ?? 0} cookieLen=${cookieLen}` ) if (bufferedRanges?.length) { @@ -1998,12 +2124,24 @@ export class SabrStream extends PassThrough { } const t0 = Date.now() - const res = await fetch(url.toString(), { - method: 'POST', - headers, - body: Buffer.from(requestBody), - signal: this.abortController.signal - }) + let res: Response + try { + res = await fetch(url.toString(), { + method: 'POST', + headers, + body: Buffer.from(requestBody), + signal: this.abortController.signal + }) + } catch (error) { + if ( + this._aborted || + this.destroyed || + this.abortController.signal.aborted + ) + throw error + const message = error instanceof Error ? error.message : String(error) + throw new Error(`HTTP request failed: ${message}`, { cause: error }) + } if (!res.ok) { let errorText = '' @@ -2060,7 +2198,8 @@ export class SabrStream extends PassThrough { streamProtectionStatus: false } - this.mediaHeadersProcessed = false + this.pendingResponseError = null + const responseStartGeneration = this.mediaProgressGeneration let activePartial: ActivePartial | null = null @@ -2295,8 +2434,9 @@ export class SabrStream extends PassThrough { `Traffic <- rn=${rn} status=${res.status} bytes=${responseBytes} parts=${Object.keys(partCounts).length} hasMedia=${saw.media} backoff=${trafficRes.policy?.backoffTimeMs} cookieLen=${trafficRes.policy?.cookieLen}` ) - if (saw.media) { - this.mediaHeadersProcessed = true + const mediaAdvanced = this.mediaProgressGeneration > responseStartGeneration + + if (mediaAdvanced) { this.cachedBufferedRanges = null this.noMediaStreak = 0 } else if (trafficRes.policy && trafficRes.policy.backoffTimeMs > 0) { @@ -2309,9 +2449,29 @@ export class SabrStream extends PassThrough { 'SABR', `Stall detected (noMediaStreak=${this.noMediaStreak}). Signaling for re-resolution.` ) - this.emit('stall') + this.queueRecovery('starvation') this.noMediaStreak = 0 } } + + const responseError = this.pendingResponseError + this.pendingResponseError = null + const responseErrorType = ( + responseError as (Error & { type?: string }) | null + )?.type + if ( + responseError && + this.usingTransferredSession && + responseErrorType === 'sabr.media_serving_enforcement_id_error' + ) { + logger( + 'warn', + 'SABR', + 'Transferred session was rejected by media enforcement. Requesting a fresh session.' + ) + this.queueRecovery('session') + } + this.flushPendingRecovery() + if (responseError && !this.recoveryPending) throw responseError } } diff --git a/src/typings/config/config.types.ts b/src/typings/config/config.types.ts index 4ff12a0b..12062382 100644 --- a/src/typings/config/config.types.ts +++ b/src/typings/config/config.types.ts @@ -1,518 +1,670 @@ /** - * Nodelink configuration type based on config.default.js - * @public + * Selection of the internal engine used for networking and protocol handling. */ -export type NodelinkConfig = typeof import('../../../config.default.js').default +export type ServerEngine = 'default' | 'bun' /** - * Server configuration options + * Represents any valid JSON value. * @public */ -export interface ServerConfig { - /** - * Port number for the server to listen on - * @remarks Must be between 1 and 65535 - */ - port: number +export type JsonValue = + | string + | number + | boolean + | null + | { [key: string]: JsonValue } + | JsonValue[] - /** - * Host address to bind the server to - * @remarks Use "0.0.0.0" to listen on all interfaces - */ - host: string +/** + * Threshold configuration for a specific rolling time window. + */ +export interface LimitRule { + /** The maximum numerical threshold allowed within the window. */ + count: number - /** - * Authentication password for client connections - */ - password: string + /** The duration of the rolling sliding time window in milliseconds. */ + windowMs: number +} - /** - * Whether to use Bun's native server instead of Node.js HTTP server - * @defaultValue false - * @experimental - */ - useBunServer?: boolean +/** + * Technical parameters for a smooth audio ramp, volume fade, or filter transition. + */ +export interface AudioTransition { + /** The total duration of the transition effect in milliseconds. */ + duration: number + + /** The identifier of the mathematical curve applied to the transition. */ + curve: string + + /** The technical logic type applied during the transition. */ + type: string } /** - * Cluster configuration for multi-process deployment - * @public + * Connection and authentication details for an external proxy server. */ -export interface ClusterConfig { - /** - * Whether cluster mode is enabled - * @defaultValue false - */ - enabled: boolean +export interface ProxyEndpoint { + /** The full destination URL of the proxy server. */ + url: string - /** - * Number of worker processes to spawn - * @remarks Set to 0 for automatic (CPU count) - */ - workers: number + /** The username required for proxies using authentication. */ + username?: string - /** - * Runtime node flags for playback/source worker processes - */ - runtime?: { - /** - * Max old space size (MB) for playback workers (0 disables override) - */ - workerMaxOldSpaceMb?: number - /** - * Enables --expose-gc for playback workers - */ - workerExposeGc?: boolean - /** - * Extra Node.js argv for playback workers - */ - workerExecArgv?: string[] | string - /** - * Max old space size (MB) for source workers (0 disables override) - */ - sourceWorkerMaxOldSpaceMb?: number - /** - * Enables --expose-gc for source workers - */ - sourceWorkerExposeGc?: boolean - /** - * Extra Node.js argv for source workers - */ - sourceWorkerExecArgv?: string[] | string - } + /** The secret password associated with the username for proxy authentication. */ + password?: string +} - /** - * Specialized worker configuration for audio sources - */ - specializedSourceWorker?: { - /** - * Whether specialized source worker is enabled - * @defaultValue false - */ - enabled: boolean - } +/** + * A standard boolean toggle for enabling or disabling internal system components. + */ +export interface FeatureToggle { + /** Set to 'true' to activate the component or 'false' to completely bypass it. */ + enabled: boolean } /** - * Audio source configuration base - * @public + * Shared runtime fields consumed by several source implementations. */ export interface SourceConfigBase { - /** - * Whether this audio source is enabled - */ + /** Master switch for the source plugin. */ enabled: boolean + + /** Shared network/proxy options read by source internals. */ + network?: { + proxy?: ProxyEndpoint + } + + /** Global search options read by source internals. */ + search?: { + maxResults?: number + defaultSource?: string | string[] + unifiedSources?: string[] + resolveExternalLinks?: boolean + fetchChannelInfo?: boolean + } + + /** Shared playback options read by source internals. */ + playback?: { + maxPlaylistLength?: number + trackStuckThresholdMs?: number + playerUpdateInterval?: number + eventTimeoutMs?: number + audio?: Record + sponsorblock?: Record + } + + /** Allow additional source-specific properties. */ + [key: string]: unknown } /** - * YouTube source configuration - * @public + * Configuration for the YouTube and YouTube Music provider. */ -export interface YouTubeSourceConfig extends SourceConfigBase { - /** - * Playlist load limit - */ - playlistLoadLimit: number +export interface YouTubeSourceConfig { + /** Master switch for the YouTube source plugin. */ + enabled: boolean + + /** List of specific YouTube 'itag' numbers allowed for audio selection. */ + allowItag: number[] + + /** Hard-code a specific 'itag' for all audio streams. */ + targetItag: number | null + + /** If true, utilize OAuth2 refresh tokens for private content access. */ + getOAuthToken: boolean + + /** The 'hl' (Host Language) parameter for metadata localization. */ + hl: string + + /** The 'gl' (Geographic Location) parameter for regional content availability. */ + gl: string + + /** Pool of proxy endpoints used exclusively for YouTube traffic. */ + proxies: ProxyEndpoint[] + + /** Ordered list of alternative sources tried if YouTube resolution fails. */ + fallbackSources: string[] + + /** Configuration for InnerTube clients. */ + clients: { + /** Ordered priority of clients used for search. */ + search: string[] + + /** Ordered priority of clients used for audio streaming. */ + playback: string[] + + /** Ordered priority of clients used for metadata resolution. */ + resolve: string[] + + /** Granular settings for individual client groups. */ + settings: { + /** Settings for the 'YouTube on TV' client. */ + TV: { + /** OAuth2 refresh tokens for session rotation. */ + refreshToken: string[] + } + } + } + + /** Configuration for signature deciphering. */ + cipher: { + /** Base URL of the deciphering service. */ + url: string + + /** Optional private access token. */ + token: string | null + } + + /** Initial visitor data for InnerTube requests. */ + visitorData?: string /** - * Album load limit + * Allow additional unknown configuration keys. */ - albumLoadLimit: number + [key: string]: unknown } /** - * Spotify source configuration - * @public + * Configuration for the Spotify metadata resolution provider. */ -export interface SpotifySourceConfig extends SourceConfigBase { - /** - * Client ID for official API access. - */ - clientId?: string +export interface SpotifySourceConfig { + /** Enables the Spotify resolution plugin. */ + enabled: boolean - /** - * Client secret for official API access. - */ - clientSecret?: string + /** Official Spotify Application Client ID. */ + clientId: string - /** - * Optional external URL for anonymous token generation. - */ - externalAuthUrl?: string + /** Official Spotify Application Client Secret. */ + clientSecret: string - /** - * Spotify sp_dc cookie for mobile token generation. - */ - sp_dc?: string + /** URL of an external service for automated token generation. */ + externalAuthUrl: string - /** - * Market code for search and resolution. - * @defaultValue "US" - */ - market?: string + /** Default market code (ISO 3166-1 alpha-2) for track availability. */ + market: string - /** - * Playlist load limit. - */ + /** Maximum pages to load from a playlist (0 = no limit). */ playlistLoadLimit: number - /** - * Album load limit. - */ - albumLoadLimit: number + /** Simultaneous requests allowed when fetching playlist pages. */ + playlistPageLoadConcurrency: number - /** - * Maximum concurrent requests during playlist loading. - */ - playlistPageLoadConcurrency?: number + /** Maximum pages to load from an album. */ + albumLoadLimit: number - /** - * Maximum concurrent requests during album loading. - */ - albumPageLoadConcurrency?: number + /** Simultaneous requests allowed when fetching album pages. */ + albumPageLoadConcurrency: number - /** - * Whether to allow explicit tracks in search/recommendations. - */ - allowExplicit?: boolean + /** If false, attempts to resolve a non-explicit version of the track. */ + allowExplicit: boolean - /** - * Whether Spotify playlist local files should be included. - */ + /** If true, keeps 'Local Files' as placeholder tracks. */ allowLocalFiles: boolean + + /** The 'sp_dc' cookie for mobile token generation. */ + sp_dc: string } /** - * Audius source configuration - * @public + * Configuration for the Apple Music resolution provider. */ -export interface AudiusSourceConfig extends SourceConfigBase { - /** - * App name - */ - appName: string +export interface AppleMusicSourceConfig { + /** Enables the Apple Music resolution plugin. */ + enabled: boolean - /** - * API key - */ - apiKey: string + /** Developer Media API Token. */ + mediaApiToken: string - /** - * API secret - */ - apiSecret: string + /** Target storefront market code (ISO 3166-1 alpha-2). */ + market: string - /** - * Playlist load limit - */ + /** Hard limit for tracks from a playlist. */ playlistLoadLimit: number - /** - * Album load limit - */ + /** Hard limit for tracks from an album. */ albumLoadLimit: number + + /** Simultaneous connections for playlist fetching. */ + playlistPageLoadConcurrency: number + + /** Simultaneous connections for album fetching. */ + albumPageLoadConcurrency: number + + /** Whether to allow tracks marked as explicit. */ + allowExplicit: boolean } /** - * Yandex Music source configuration - * @public + * Configuration for the VK Music provider. */ -export interface YandexMusicSourceConfig extends SourceConfigBase { - /** - * Access token - */ - accessToken: string +export interface VKMusicSourceConfig extends SourceConfigBase { + /** Enables the VK Music source plugin. */ + enabled: boolean - /** - * Playlist load limit - */ - playlistLoadLimit: number + /** API User Token for authenticated requests. */ + userToken: string - /** - * Album load limit - */ - albumLoadLimit: number + /** Full session cookie string for browser emulation. */ + userCookie: string - /** - * Artist load limit - */ - artistLoadLimit: number + /** Dedicated proxy for VK-related requests. */ + proxy: ProxyEndpoint - /** - * Whether to include unavailable tracks - */ - allowUnavailable: boolean + /** Runtime-compatible network proxy wrapper. */ + network: { + proxy: ProxyEndpoint + } +} - /** - * Whether to allow explicit content - */ - allowExplicit: boolean +/** + * Configuration for the Deezer media provider. + */ +export interface DeezerSourceConfig { + /** Enables the Deezer source plugin. */ + enabled: boolean - /** - * Proxy settings for the request. - */ - proxy?: import('../utils.types.ts').HttpProxyConfig + /** User 'arl' cookie for authenticated requests. */ + arl: string + + /** Optional manual decryption key for streams. */ + decryptionKey: string } /** - * VK Music source configuration - * @public + * Configuration for the Tidal high-fidelity music provider. */ -export interface VKMusicSourceConfig extends SourceConfigBase { - /** - * Access token for the user - */ - userToken?: string +export interface TidalSourceConfig { + /** Enables the Tidal source plugin. */ + enabled: boolean - /** - * User cookie for authentication fallback - */ - userCookie?: string + /** Personal API Access Token. */ + token: string - /** - * Proxy settings for the request. - */ - proxy?: import('../utils.types.ts').HttpProxyConfig + /** ISO 3166-1 alpha-2 country code for availability. */ + countryCode: string + + /** Maximum pages loaded per playlist resolution. */ + playlistLoadLimit: number + + /** Number of simultaneous page downloads. */ + playlistPageLoadConcurrency: number + + /** Array of private Hi-Fi API endpoint URLs. */ + hifiApis: string[] + + /** Ordered list of preferred audio quality tiers. */ + hifiQualities: string[] } /** - * Bilibili source configuration - * @public + * Configuration for the JioSaavn Indian music provider. */ -export interface BilibiliSourceConfig extends SourceConfigBase { - /** - * SESSDATA cookie for authentication - */ - sessdata?: string +export interface JioSaavnSourceConfig extends SourceConfigBase { + /** Enables the JioSaavn source plugin. */ + enabled: boolean - /** - * Proxy settings for the request. - */ - proxy?: import('../utils.types.ts').HttpProxyConfig + /** Maximum tracks to load from a playlist. */ + playlistLoadLimit: number + + /** Maximum tracks to load for a single artist. */ + artistLoadLimit: number + + /** Proxy settings for regional access. */ + proxy: ProxyEndpoint + + /** Runtime-compatible network proxy wrapper. */ + network: { + proxy: ProxyEndpoint + } + + /** Optional custom decryption key for streams. */ + secretKey: string } /** - * Eternalbox source configuration - * @public + * Configuration for the Gaana Indian music provider. */ -export interface EternalboxSourceConfig extends SourceConfigBase { - /** - * Base URL for the Eternalbox mirror - * @defaultValue 'https://eternalboxmirror.xyz' - */ - baseUrl: string +export interface GaanaSourceConfig extends SourceConfigBase { + /** Enables the Gaana source plugin. */ + enabled: boolean - /** - * Whether to enable the eternal (infinite) stream loop - * @defaultValue true - */ - eternalStream: boolean + /** Target stream quality profile ('high', 'medium', 'low'). */ + streamQuality: string - /** - * Whether to signal the stream as infinite to the client - * @defaultValue true - */ - infiniteStream: boolean + /** Maximum tracks from a Gaana playlist. */ + playlistLoadLimit: number - /** - * Whether to enrich the track with Spotify metadata if available - * @defaultValue false - */ - enrichSpotify: boolean + /** Maximum tracks from a Gaana album. */ + albumLoadLimit: number - /** - * Maximum search results to return - * @defaultValue 10 - */ + /** Maximum tracks for a single Gaana artist. */ + artistLoadLimit: number + + /** Proxy configuration for gaana requests. */ + proxy: ProxyEndpoint + + /** Runtime-compatible network proxy wrapper. */ + network: { + proxy: ProxyEndpoint + } +} + +/** + * Configuration for the Yandex Music (Russia) provider. + */ +export interface YandexMusicSourceConfig extends SourceConfigBase { + /** Master switch for the Yandex Music source plugin. */ + enabled: boolean + + /** User Access Token retrieved from an authenticated Yandex session. */ + accessToken: string + + /** If true, includes tracks even if marked as unavailable in the region. */ + allowUnavailable: boolean + + /** Whether to include explicit content in results. */ + allowExplicit: boolean + + /** Track limit for artist-based loading. */ + artistLoadLimit: number + + /** Track limit for album-based loading. */ + albumLoadLimit: number + + /** Track limit for playlist-based loading. */ + playlistLoadLimit: number + + /** Proxy configuration for regional Yandex access. */ + proxy: ProxyEndpoint + + /** Runtime-compatible network proxy wrapper. */ + network: { + proxy: ProxyEndpoint + } +} + +/** + * Configuration for the EternalBox loop and remix engine. + */ +export interface EternalBoxSourceConfig { + /** Enables the EternalBox infinite looping plugin. */ + enabled: boolean + + /** The base URL for the EternalBox mirror API. */ + baseUrl: string + + /** Number of search results analyzed to find the best matching track. */ searchResults: number - /** - * Maximum size of the internal audio cache in bytes - * @defaultValue 20MB - */ - cacheMaxBytes: number + /** If true, fetches additional audio feature metrics from Spotify. */ + enrichSpotify: boolean - /** - * Whether to include full audio analysis in pluginInfo - * @defaultValue true - */ + /** If true, includes full segment-by-segment audio analysis. */ includeAnalysis: boolean - /** - * Whether to include a summary of audio analysis in pluginInfo - * @defaultValue true - */ + /** If true, includes only a summarized version of the audio analysis. */ includeAnalysisSummary: boolean - /** - * Algorithm parameter: Maximum branches per beat - */ + /** Master switch for the automated eternal stream handler. */ + eternalStream: boolean + + /** Maximum memory (in bytes) for the in-memory analysis cache. */ + cacheMaxBytes: number + + /** Maximum simultaneous alternative branch paths per segment. */ maxBranches: number - /** - * Algorithm parameter: Maximum branch similarity threshold - */ + /** Maximum similarity value for a valid branch. */ maxBranchThreshold: number - /** - * Algorithm parameter: Minimum branch similarity threshold - */ + /** Initial discovery threshold for branch discovery. */ branchThresholdStart: number - /** - * Algorithm parameter: Branch threshold iteration step - */ + /** Step size when expanding the similarity search. */ branchThresholdStep: number - /** - * Algorithm parameter: Target divisor for branch count - */ + /** Divisor factor to normalize branch scores. */ branchTargetDivisor: number - /** - * Algorithm parameter: Whether to force a branch at the end - */ + /** If true, forces a branch connection at the end of the track. */ addLastEdge: boolean - /** - * Algorithm parameter: Only branch backwards - */ + /** If true, only allows branches that jump backwards in time. */ justBackwards: boolean - /** - * Algorithm parameter: Only branch to distant beats - */ + /** If true, filters out very short jump distances. */ justLongBranches: boolean - /** - * Algorithm parameter: Remove sequential (duplicate) branches - */ + /** If true, prevents repetitive A-B-A branch loops. */ removeSequentialBranches: boolean - /** - * Algorithm parameter: Filter segments for smoother branching - */ + /** If true, uses segment filtering for higher rhythmic accuracy. */ useFilteredSegments: boolean - /** - * Weight for timbre similarity - */ + /** Minimum baseline chance for a random jump. */ + minRandomBranchChance: number + + /** Maximum potential chance for a random jump. */ + maxRandomBranchChance: number + + /** Random variance delta applied per cycle. */ + randomBranchChanceDelta: number + + /** Importance of timbre/texture matching. */ timbreWeight: number - /** - * Weight for pitch similarity - */ + /** Importance of musical pitch/chroma matching. */ pitchWeight: number - /** - * Weight for loudness start similarity - */ + /** Importance of the segment start volume envelope. */ loudStartWeight: number - /** - * Weight for loudness max similarity - */ + /** Importance of the segment peak volume level. */ loudMaxWeight: number - /** - * Weight for duration similarity - */ + /** Importance of the segment duration/length. */ durationWeight: number - /** - * Weight for confidence similarity - */ + /** Importance of the algorithm's confidence score. */ confidenceWeight: number - /** - * Minimum random branch probability - */ - minRandomBranchChance: number - - /** - * Maximum random branch probability - */ - maxRandomBranchChance: number - - /** - * Random branch probability increment per beat - */ - randomBranchChanceDelta: number + /** Enables persistent infinite streaming mode. */ + infiniteStream: boolean - /** - * Maximum reconnect attempts for the stream - */ + /** Maximum reconnection attempts before giving up. */ maxReconnects: number - /** - * Delay between reconnect attempts in ms - */ + /** Delay in milliseconds between retry attempts. */ reconnectDelayMs: number } +/** @deprecated use EternalBoxSourceConfig */ +export type EternalboxSourceConfig = EternalBoxSourceConfig + /** - * JioSaavn source configuration - * @public + * Configuration for the Amazon Music provider. */ -export interface JioSaavnSourceConfig extends SourceConfigBase { - /** - * Playlist load limit - */ +export interface AmazonMusicSourceConfig extends SourceConfigBase { + enabled: boolean playlistLoadLimit: number + albumLoadLimit: number +} - /** - * Artist load limit - */ - artistLoadLimit: number +/** + * Configuration for the Bilibili provider. + */ +export interface BilibiliSourceConfig extends SourceConfigBase { + enabled: boolean + sessdata: string + network: { + proxy: ProxyEndpoint + } } /** - * Apple Music source configuration - * @public + * Configuration for the Google Drive provider. */ -export interface AppleMusicSourceConfig extends SourceConfigBase { - /** - * Media API token for authentication - */ - mediaApiToken?: string +export interface GoogleDriveSourceConfig extends SourceConfigBase { + enabled: boolean + /** Raw cookie header used to access private or restricted Drive files/folders. */ + cookies: string +} - /** - * Market/country code - */ - market?: string +/** + * Configuration for the Songlink metadata bridge. + */ +export interface SonglinkSourceConfig { + /** Master switch for the Songlink plugin. */ + enabled: boolean - /** - * Playlist load limit - */ - playlistLoadLimit: number + /** Your private API Key for the Odesli platform. */ + apiKey: string - /** - * Album load limit - */ - albumLoadLimit: number + /** ISO 3166-1 alpha-2 country code for resolution market. */ + userCountry: string - /** - * Whether to allow explicit content - */ - allowExplicit: boolean + /** If true, returns only the original song if only one match is found. */ + songIfSingle: boolean + + /** Use the official Odesli REST API. */ + useApi: boolean + + /** Use web scraping as a fallback if the API fails or is disabled. */ + useScrapeFallback: boolean + + /** Ordered list of platforms to prefer during link resolution. */ + preferredPlatforms: string[] + + /** If true, falls back to any available platform if preferred ones fail. */ + fallbackToAny: boolean } /** - * Amazon Music source configuration - * @public + * Direct HTTP/HTTPS stream resolver configuration. */ -export interface AmazonMusicSourceConfig extends SourceConfigBase { - /** - * Playlist load limit - */ +export interface HttpSourceConfig { + /** Enables the direct URL resolution plugin. */ + enabled: boolean + + /** Custom 'User-Agent' string sent with every outgoing request. */ + userAgent: string +} + +/** + * Configuration for the Flowery Text-to-Speech provider. + */ +export interface FlowerySourceConfig { + /** Enables the Flowery TTS plugin. */ + enabled: boolean + + /** Identifier of the default voice used for synthesis. */ + voice: string + + /** If true, automatically translates input text before synthesis. */ + translate: boolean + + /** Duration of trailing silence (ms) added to the end of the clip. */ + silence: number + + /** Playback speed multiplier (e.g., 1.0 = normal). */ + speed: number + + /** If true, ignores user-provided synthesis overrides. */ + enforceConfig: boolean +} + +/** + * Configuration for the LazyPy Text-to-Speech aggregator. + */ +export interface LazyPySourceConfig { + /** Enables the LazyPy TTS plugin. */ + enabled: boolean + + /** Identifier of the underlying synthesis service. */ + service: string + + /** Identifier of the default voice for the selected service. */ + voice: string + + /** Hard character limit per synthesis request. */ + maxTextLength: number + + /** If true, forces server-side configuration over user requests. */ + enforceConfig: boolean +} + +/** + * Configuration for the local Piper neural Text-to-Speech engine. + */ +export interface PiperSourceConfig { + /** Enables the local Piper neural TTS plugin. */ + enabled: boolean + + /** The HTTP/WebSocket URL of the local Piper server instance. */ + url: string + + /** Identifier of the neural voice model file (ONNX). */ + voice: string + + /** Speaker index for models containing multiple different voices. */ + speaker: number + + /** Optional speaker identifier for backends that expect string IDs. */ + speaker_id?: string | number + + /** Tempo/Speed multiplier (e.g., 1.0 is normal). */ + length_scale: number + + /** Phoneme-level noise variation for more 'human' expression. */ + noise_scale: number + + /** Duration-level noise variation for rhythmic naturalness. */ + noise_w_scale: number +} + +/** + * Configuration for the Audius decentralized music provider. + */ +export interface AudiusSourceConfig { + /** Enables the Audius source plugin. */ + enabled: boolean + + /** Unique application name for Audius API identification. */ + appName: string + + /** Public API service key. */ + apiKey: string + + /** Private API service secret. */ + apiSecret: string + + /** Maximum tracks loaded from an Audius playlist. */ playlistLoadLimit: number - /** - * Album load limit - */ + /** Maximum tracks loaded from an Audius album. */ albumLoadLimit: number } +/** + * Configuration for the Qobuz high-resolution music provider. + */ +export interface QobuzSourceConfig { + /** Master switch for the Qobuz source plugin. */ + enabled: boolean + + /** Personal User Token retrieved from an authenticated Qobuz session. */ + userToken: string + + /** Preferred audio format/quality identifier. */ + formatId: string + + /** Whether to include tracks marked with explicit content. */ + allowExplicit: boolean +} + +/** + * Configuration for the Monochrome decentralized music API. + */ /** * Monochrome source configuration * @public @@ -522,13 +674,19 @@ export interface MonochromeSourceConfig extends SourceConfigBase { * List of API instances to use for metadata and search. * @remarks These instances handle track info, search queries, and collection metadata. */ - instances?: string[] + instances: string[] /** * List of streaming instances used for manifest resolution. * @remarks These instances are specifically used to resolve playable stream URIs. */ - streamingInstances?: string[] + streamingInstances: string[] + + /** + * List of Qobuz proxy instances used as fallback for stream resolution. + * @remarks These endpoints expose `/api/get-music` and `/api/download-music` to resolve Qobuz tracks. + */ + qobuzInstances?: string[] /** * Preferred audio quality. @@ -538,7 +696,7 @@ export interface MonochromeSourceConfig extends SourceConfigBase { * - `HIGH`: High quality compressed (AAC 320kbps). * - `LOW`: Low quality compressed (AAC 96kbps). */ - quality?: 'HI_RES_LOSSLESS' | 'LOSSLESS' | 'HIGH' | 'LOW' + quality: 'HI_RES_LOSSLESS' | 'LOSSLESS' | 'HIGH' | 'LOW' | string } /** @@ -553,44 +711,605 @@ export interface VoiceReceiveConfig { enabled: boolean /** - * Audio format for received voice data - * @remarks - * - `pcm`: Raw PCM audio data - * - `opus`: Opus-encoded audio data + * The format to receive audio in + * @defaultValue 'pcm' */ format: 'pcm' | 'opus' } /** - * Rate limiting configuration - * @public + * Configuration for the Deezer media provider. */ -export interface RateLimitConfig { - /** - * Duration of the rate limit window in milliseconds - */ - duration: number +export interface DeezerSourceConfig { + /** Master switch for the Deezer source plugin. */ + enabled: boolean - /** - * Maximum number of requests allowed within the window - */ - maxRequests: number + /** User 'arl' cookie for authenticated Deezer requests. */ + arl: string + + /** Optional manual decryption key for Deezer audio streams. */ + decryptionKey: string } /** - * Metrics collection configuration - * @public + * Configuration for the Pandora music provider. */ -export interface MetricsConfig { - /** - * Whether metrics collection is enabled - * @defaultValue false - */ +export interface PandoraSourceConfig { + /** Master switch for the Pandora source plugin. */ enabled: boolean - /** - * Interval for collecting metrics in milliseconds - * @defaultValue 5000 - */ - interval?: number + /** Manual session/CSRF token for bypassing regional gatekeeping. */ + csrfToken: string + + /** URL of a remote microservice for token rotation. */ + remoteTokenUrl: string +} + +/** + * Registry of all available content provider configurations. + */ +export interface SourcesRegistry { + /** YouTube and YouTube Music. */ + youtube: YouTubeSourceConfig + + /** Spotify metadata resolution. */ + spotify: SpotifySourceConfig + + /** Apple Music resolution. */ + applemusic: AppleMusicSourceConfig + + /** VK Music resolution. */ + vkmusic: VKMusicSourceConfig + + /** Deezer resolution. */ + deezer: DeezerSourceConfig + + /** Tidal resolution. */ + tidal: TidalSourceConfig + + /** JioSaavn resolution. */ + jiosaavn: JioSaavnSourceConfig + + /** Gaana resolution. */ + gaana: GaanaSourceConfig + + /** Yandex Music resolution. */ + yandexmusic: YandexMusicSourceConfig + + /** EternalBox loop engine. */ + eternalbox: EternalBoxSourceConfig + + /** Songlink bridge. */ + songlink: SonglinkSourceConfig + + /** Direct HTTP/HTTPS. */ + http: HttpSourceConfig + + /** Flowery TTS. */ + flowery: FlowerySourceConfig + + /** LazyPy TTS aggregator. */ + lazypytts: LazyPySourceConfig + + /** Local Piper neural TTS. */ + pipertts: PiperSourceConfig + + /** Audius decentralized music. */ + audius: AudiusSourceConfig + + /** Qobuz high-resolution. */ + qobuz: QobuzSourceConfig + + /** Monochrome API. */ + monochrome: MonochromeSourceConfig + + /** Pandora resolution. */ + pandora: PandoraSourceConfig + + /** Amazon Music resolution. */ + amazonmusic: AmazonMusicSourceConfig + + /** BlueSky post-audio. */ + bluesky: FeatureToggle & { + /** Optional source-local override for search result limit. */ + maxSearchResults?: number + } + + /** MENA region resolution. */ + anghami: FeatureToggle & { + /** Session cookies for anghami. */ + cookies: string + } + + /** RSS feed extractor. */ + rss: FeatureToggle + + /** Mixcloud resolution. */ + mixcloud: FeatureToggle + + /** Audiomack resolution. */ + audiomack: FeatureToggle + + /** Bandcamp resolution. */ + bandcamp: FeatureToggle + + /** Newgrounds Audio Portal resolution. */ + newgrounds: FeatureToggle + + /** SoundCloud resolution. */ + soundcloud: FeatureToggle & { + /** Optional SoundCloud API Client ID. */ + clientId: string + } + + /** Local filesystem. */ + local: FeatureToggle & { + /** Local root path for music scanning. */ + basePath: string + } + + /** Vimeo video-audio. */ + vimeo: FeatureToggle + + /** iHeartRadio resolution. */ + iheartradio: FeatureToggle + + /** Telegram file resolution. */ + telegram: FeatureToggle + + /** Shazam recognition. */ + shazam: FeatureToggle & { + /** Filter explicit content in Shazam results. */ + allowExplicit: boolean + } + + /** Bilibili video-audio. */ + bilibili: BilibiliSourceConfig + + /** Genius metadata. */ + genius: FeatureToggle + + /** Pinterest video-audio. */ + pinterest: FeatureToggle + + /** Google Text-to-Speech. */ + 'google-tts': FeatureToggle & { + /** Google TTS language tag. */ + language: string + } + + /** Instagram post-audio. */ + instagram: FeatureToggle + + /** Kwai video-audio. */ + kwai: FeatureToggle + + /** Twitch stream/clip. */ + twitch: FeatureToggle + + /** NicoVideo resolution. */ + nicovideo: FeatureToggle + + /** Reddit video-audio. */ + reddit: FeatureToggle + + /** Tumblr post-audio. */ + tumblr: FeatureToggle + + /** Twitter (X) post-audio. */ + twitter: FeatureToggle + + /** Last.fm enrichment. */ + lastfm: FeatureToggle & { + /** Last.fm API Key. */ + apiKey: string + } + + /** NetEase resolution. */ + netease: FeatureToggle + + /** Letras.mus.br lyrics. */ + letrasmus: FeatureToggle + + /** Google Drive files. */ + googledrive: GoogleDriveSourceConfig + + /** TikTok video-audio. */ + tiktok: FeatureToggle + + /** Allow dynamic indexing of sources. */ + [key: string]: FeatureToggle | SourceConfigBase | undefined +} + +/** + * Infrastructure settings for the core server. + */ +export interface ServerSection { + /** Bind host address. */ + host: string + + /** API/WebSocket port. */ + port: number + + /** Master auth password. */ + password?: string + + /** Enable experimental Bun server engine. */ + useBunServer: boolean +} + +/** + * System-wide security and mitigations. + */ +export interface SecuritySection { + /** Master auth password. */ + password?: string + + /** Trust X-Forwarded-For headers. */ + trustProxy: boolean + + /** Anti-flooding protection. */ + dosProtection: { + enabled: boolean + thresholds: { + /** Max requests in window. */ + burstRequests: number + /** Sliding window size (ms). */ + timeWindowMs: number + } + mitigation: { + /** Artificial response delay (ms). */ + delayMs: number + /** access block duration (ms). */ + blockDurationMs: number + } + ignore: { + userIds: string[] + guildIds: string[] + ips: string[] + } + } + + /** fair-use API throttling. */ + rateLimit: { + enabled: boolean + maxEntries: number + global: { + maxRequests: number + timeWindowMs: number + } + perIp: { + maxRequests: number + timeWindowMs: number + } + perUserId: { + maxRequests: number + timeWindowMs: number + } + perGuildId: { + maxRequests: number + timeWindowMs: number + } + /** Paths that bypass rate limiting. */ + ignorePaths: string[] + ignore: { + userIds: string[] + guildIds: string[] + ips: string[] + } + } + + /** Allow additional security-specific properties. */ + [key: string]: unknown +} + +/** + * Multi-process cluster and scaling settings. + */ +export interface ClusterSection { + /** Active cluster mode. */ + enabled: boolean + + /** Dedicated playback workers count (0 = auto). */ + workers: number + + /** Standby workers pool size. */ + minWorkers: number + + /** Runtime flags for worker processes. */ + runtime: { + workerMaxOldSpaceMb: number + workerExposeGc: boolean + workerExecArgv: string[] + sourceWorkerMaxOldSpaceMb: number + sourceWorkerExposeGc: boolean + sourceWorkerExecArgv: string[] + } + + /** Offloads heavy metadata tasks to dedicated processes. */ + specializedSourceWorker: { + enabled: boolean + count: number + microWorkers: number + tasksPerWorker: number + silentLogs: boolean + } + + /** Heavy command timeout (ms). */ + commandTimeout: number + + /** Player control command timeout (ms). */ + fastCommandTimeout: number + + /** Hierarchical timeout aliases for migration compatibility. */ + timeouts?: { + heavyMs: number + fastMs: number + } + + /** IPC retry attempts. */ + maxRetries: number + + /** Process suspension logic. */ + hibernation: { + enabled: boolean + timeoutMs: number + } + + /** Load balancer orchestration. */ + scaling: { + maxPlayersPerWorker: number + targetUtilization: number + scaleUpThreshold: number + scaleDownThreshold: number + checkIntervalMs: number + idleWorkerTimeoutMs: number + queueLengthScaleUpFactor: number + lagPenaltyLimit: number + cpuPenaltyLimit: number + } + + /** cluster control API. */ + endpoint: { + patchEnabled: boolean + allowExternalPatch: boolean + code: string + } +} + +/** + * System-wide logging and debugging engine. + */ +export interface LoggingSection { + /** log level (e.g. 'info', 'debug'). */ + level: string + + /** Disk logging settings. */ + file: { + enabled: boolean + path: string + rotation: string + ttlDays: number + } + + /** Granular debug flags. */ + debug: { + all: boolean + request: boolean + session: boolean + player: boolean + filters: boolean + sources: boolean + lyrics: boolean + youtube: boolean + 'youtube-cipher': boolean + sabr: boolean + potoken: boolean + } +} + +/** + * Connectivity health and multi-IP rotation. + */ +export interface NetworkSection { + /** Shared outbound proxy for sources and internals. */ + proxy: { + enabled: boolean + strategy: string + retries: number + timeout: number + shuffleOnStart: boolean + list: ProxyEndpoint[] + } + + /** Background connection probing. */ + connection: { + logAllChecks: boolean + interval: number + timeout: number + thresholds: { + bad: number + average: number + } + } + + /** Outbound IP rotation. */ + routePlanner: { + strategy: string + bannedIpCooldown: number + ipBlocks: Array + } +} + +/** + * Configuration for audio filters. + */ +export interface FilterConfig { + /** + * Toggles for individual audio filters. + */ + enabled: { + /** tremolo filter. */ + tremolo: boolean + /** vibrato filter. */ + vibrato: boolean + /** lowpass filter. */ + lowpass: boolean + /** highpass filter. */ + highpass: boolean + /** rotation filter. */ + rotation: boolean + /** karaoke filter. */ + karaoke: boolean + /** distortion filter. */ + distortion: boolean + /** channelMix filter. */ + channelMix: boolean + /** equalizer filter. */ + equalizer: boolean + /** chorus filter. */ + chorus: boolean + /** compressor filter. */ + compressor: boolean + /** echo filter. */ + echo: boolean + /** phaser filter. */ + phaser: boolean + /** timescale filter. */ + timescale: boolean + } +} + +/** + * The consolidated NodeLink configuration schema. + */ +export interface NodelinkConfig { + server: ServerSection + cluster: ClusterSection + logging: LoggingSection + connection: NetworkSection['connection'] + rateLimit: SecuritySection['rateLimit'] + dosProtection: SecuritySection['dosProtection'] + trustProxy: boolean + network: NetworkSection + search: { + maxResults: number + defaultSource: string | string[] + unifiedSources: string[] + resolveExternalLinks: boolean + fetchChannelInfo: boolean + } + playback: { + maxPlaylistLength: number + playerUpdateInterval: number + statsUpdateInterval: number + trackStuckThresholdMs: number + eventTimeoutMs: number + zombieThresholdMs: number + sponsorblock: { + enabled: boolean + api: string + categories: string[] + actionTypes: string[] + skipMarginMs: number + } + filters: FilterConfig + audio: { + quality: string + encryption: string + resamplingQuality: string + loudnessNormalizer: boolean + lookaheadMs: number + gateThresholdLUFS: number + fading: { + enabled: boolean + trackStart: AudioTransition + trackEnd: AudioTransition + trackStop: AudioTransition + seek: AudioTransition + pause: AudioTransition + resume: AudioTransition + ducking: { + enabled: boolean + duration: number + targetVolume: number + curve: string + } + } + crossfade: { + enabled: boolean + duration: number + curve: string + mode: 'preload' | 'stream' + minBufferMs: number + bufferMs: number + } + } + voiceReceive: VoiceReceiveConfig + mix: { + enabled: boolean + defaultVolume: number + maxLayersMix: number + autoCleanup: boolean + } + } + api: { + enableTrackStreamEndpoint: boolean + enableLoadStreamEndpoint: boolean + metrics: { + enabled: boolean + authorization: { + type: 'Bearer' | 'Basic' + username: string + password: string + } + } + } + experimental: { + enableHoloTracks: boolean + } + + /** provider-specific configurations. */ + sources: SourcesRegistry + + /** Lyrics extraction settings. */ + lyrics: { + fallbackSource: string + /** Ordered lyrics providers tried after the track's native provider. */ + preferredSources?: string[] + [source: string]: unknown + } + + /** track meaning providers. */ + meanings: { + [key: string]: FeatureToggle | undefined + } + + /** scraper metrics endpoint. */ + metrics: { + enabled: boolean + authorization: { + type: 'Bearer' | 'Basic' | string + username: string + password: string + } + } + + /** Multi-audio layering mixer. */ + mix: { + enabled: boolean + defaultVolume: number + maxLayersMix: number + autoCleanup: boolean + } + + /** Registry of addons to load. */ + plugins: Array<{ + name: string + source: string + path?: string + }> + + /** Passthrough addon settings. */ + pluginConfig: Record> } diff --git a/src/typings/index.types.ts b/src/typings/index.types.ts index f0fa8ffd..1309b31e 100644 --- a/src/typings/index.types.ts +++ b/src/typings/index.types.ts @@ -46,7 +46,28 @@ export interface BunSocketData { * Socket wrapper instance for event handling * @internal */ - wrapper?: BunSocketWrapper + wrapper?: IBunSocketWrapper + + /** + * Pre-parsed pathname from the upgrade request URL + * @internal + */ + pathname?: string + + /** + * Pre-resolved event name to emit on the internal socket bus + * (`/v4/websocket`, `/v4/websocket/voice`, `/v4/websocket/youtube/live`, + * or `/v4/profiler/socket`) + * @internal + */ + eventName?: string + + /** + * Pre-extracted route identifier (guildId for voice, videoId/encoded track + * for live chat); null when not applicable + * @internal + */ + routeId?: string | null } /** @@ -877,6 +898,11 @@ export interface Session { */ players: PlayerManagerInstance + /** + * Group manager for multi-guild player synchronization + */ + groups: import('../managers/groupManager.ts').default + /** * Event queue for reconnection */ @@ -1230,6 +1256,9 @@ export interface ConnectionManagerContext { */ options: { connection?: import('./voice/connection.types.ts').ConnectionConfig + network?: { + connection?: import('./voice/connection.types.ts').ConnectionConfig + } } /** @@ -1337,19 +1366,3 @@ export interface NodelinkServer { */ extensions?: NodelinkExtensions } - -/** - * BunSocketWrapper class declaration for type exports - * @public - */ -export class BunSocketWrapper { - ws!: ServerWebSocket - remoteAddress!: string - - send!: (data: string | Buffer) => boolean - ping!: (data?: string | Buffer) => boolean - close!: (code?: number, reason?: string) => void - terminate!: () => void - _handleMessage!: (message: string | Buffer) => void - _handleClose!: (code: number, reason: string) => void -} diff --git a/src/typings/meanings/meaning.types.ts b/src/typings/meanings/meaning.types.ts index aa63483d..8e597729 100644 --- a/src/typings/meanings/meaning.types.ts +++ b/src/typings/meanings/meaning.types.ts @@ -1,3 +1,5 @@ +import type { NodelinkConfig } from '../config/config.types.ts' + /** * Minimal track info used by meaning providers. * @public @@ -110,9 +112,7 @@ export interface MeaningSourceInstance { * @public */ export interface MeaningManagerContext { - options: Record & { - meanings?: Record - } + options: NodelinkConfig } /** diff --git a/src/typings/performanc.d.ts b/src/typings/performanc.d.ts index f6798a0e..607e4bf5 100644 --- a/src/typings/performanc.d.ts +++ b/src/typings/performanc.d.ts @@ -104,27 +104,28 @@ declare module '@performanc/voice' { import type { Readable } from 'node:stream' export interface VoiceConnectionState { - status: - | 'connecting' - | 'connected' - | 'disconnected' - | 'destroyed' - | 'reconnecting' + status: 'connecting' | 'connected' | 'disconnected' | 'destroyed' + reason?: string code?: number closeReason?: string } export interface VoicePlayerState { - status: 'idle' | 'playing' | 'paused' + status: 'idle' | 'playing' reason?: string } export interface VoiceStatistics { packetsExpected: number + packetsSent: number + packetsLost: number [key: string]: number | undefined } export interface VoiceUdpInfo { + ssrc?: number + ip?: string + port?: number secretKey?: Uint8Array | Buffer } @@ -135,20 +136,27 @@ declare module '@performanc/voice' { setFilters(filters: unknown): void setFadeVolume?(volume: number): void fadeTo?(volume: number, durationMs: number, curve?: string): void + tapeTo?(durationMs: number, type: 'start' | 'stop', curve?: string): void + scratchTo?(durationMs: number, style: string): void + checkTapeRampCompleted?(): boolean + checkScratchEffectCompleted?(): boolean + getEffectiveRate?(): number setLoudnessNormalizer?(enabled: boolean): void + canStop?: boolean destroy(): void - pause?(reason?: string): void - unpause?(reason?: string): void - stop?(reason?: string): void read?(): unknown } export interface VoiceConnection extends EventEmitter { + guildId: string + userId: string channelId?: string | null - udpInfo?: VoiceUdpInfo + udpInfo?: VoiceUdpInfo | null statistics?: VoiceStatistics - ping?: number + ping: number audioStream?: VoiceAudioStream | null + voiceServer: { token: string; endpoint: string } | null + stuckTimeout: number on( event: 'stateChange', @@ -165,7 +173,7 @@ declare module '@performanc/voice' { ) => void ): this on(event: 'error', listener: (error: Error) => void): this - on(event: 'audioStream', listener: (stream: VoiceAudioStream) => void): this + on(event: 'stuck', listener: () => void): this on( event: 'speakStart', listener: (userId: string, ssrc: number) => void @@ -178,18 +186,27 @@ declare module '@performanc/voice' { play(resource: unknown): VoiceAudioStream | null | undefined stop(reason?: string): void - pause?(reason?: string): void - unpause?(reason?: string): void + pause(reason?: string): void + unpause(reason?: string): void destroy(): void - voiceStateUpdate(state: { session_id: string }): void - voiceServerUpdate(update: { token: string; endpoint: string }): void - connect(callback?: () => void): void + voiceStateUpdate(state: { session_id: string; channel_id?: string }): void + voiceServerUpdate(update: { + token: string + endpoint: string + channel_id?: string + }): void + connect(callback?: () => void, reconnection?: boolean): void + getSpeakStream?(ssrc: number): Readable | null + + // Internal @performanc/voice state + mlsSession?: { _pendingKeyPackage?: Uint8Array | null } + ssrcs?: Map } export interface JoinVoiceChannelOptions { guildId: string userId: string - channelId: string + channelId?: string | null encryption?: string | null } diff --git a/src/typings/playback/ducking.types.ts b/src/typings/playback/ducking.types.ts new file mode 100644 index 00000000..6927fbdb --- /dev/null +++ b/src/typings/playback/ducking.types.ts @@ -0,0 +1,24 @@ +import type { VoiceConnection } from '@performanc/voice' + +/** + * Configuration options for the DuckingController. + */ +export interface DuckingConfig { + /** Whether ducking is currently enabled. */ + enabled: boolean + /** Fade duration in milliseconds when ducking activates/deactivates. */ + duration: number + /** Target volume multiplier when someone is speaking (0.0 to 1.0). */ + targetVolume: number + /** Fade curve name to use for transitions. */ + curve: string +} + +/** + * Callback interface for the DuckingController to control audio stream volume. + */ +export interface DuckingStreamControl { + /** Fades the audio stream to a target volume over a duration. */ + fadeTo: (volume: number, durationMs: number, curve?: string) => void +} + diff --git a/src/typings/playback/filters.types.ts b/src/typings/playback/filters.types.ts index a6aad2ee..37aa697b 100644 --- a/src/typings/playback/filters.types.ts +++ b/src/typings/playback/filters.types.ts @@ -137,6 +137,16 @@ export interface RotationSettings { alpha?: number } +/** + * Configuration for the Tesseract (4D Rotation) filter. + * @public + */ +export interface TesseractSettings { + rotationHz?: number + transition?: AnimationTransition + alpha?: number +} + /** * Configuration for the LowPass filter. * @public @@ -325,6 +335,7 @@ export interface FilterSettings { compressor?: CompressorSettings phonograph?: PhonographSettings tape?: TapeSettings + tesseract?: TesseractSettings [key: string]: unknown } @@ -366,6 +377,11 @@ export interface FilterInstance { * Returns true if the filter is currently active or animating back to its disabled state. */ isActive?: () => boolean + + /** + * Releases any internal resources. + */ + destroy?: () => void } /** diff --git a/src/typings/playback/group.types.ts b/src/typings/playback/group.types.ts new file mode 100644 index 00000000..6ae77bc5 --- /dev/null +++ b/src/typings/playback/group.types.ts @@ -0,0 +1,39 @@ +/** + * Represents a group of synchronized players. + */ +export interface PlayerGroup { + /** + * Unique group identifier. + */ + id: string + + /** + * Set of guild IDs belonging to this group. + */ + guildIds: Set + + /** + * Timestamp of group creation. + */ + createdAt: number +} + +/** + * JSON-serializable representation of a player group. + */ +export interface GroupStateJSON { + /** + * Group identifier. + */ + id: string + + /** + * Array of guild IDs in this group. + */ + guildIds: string[] + + /** + * Timestamp of group creation. + */ + createdAt: number +} diff --git a/src/typings/playback/hls.types.ts b/src/typings/playback/hls.types.ts index b4ae4919..6e76abf2 100644 --- a/src/typings/playback/hls.types.ts +++ b/src/typings/playback/hls.types.ts @@ -38,6 +38,8 @@ export interface HLSSegmentKey { export interface HLSSegmentMap { /** URI of the initialization segment */ uri?: string + /** Byte range when the initialization segment shares a media file */ + byteRange?: HLSByteRange | null } /** @@ -241,6 +243,14 @@ export interface HLSHandlerOptions { username?: string password?: string } | null + /** Backward-compatible network block used by some callers. */ + network?: { + proxy?: { + url: string + username?: string + password?: string + } | null + } /** Callback for URL resolution (e.g., signature decryption) */ onResolveUrl?: ((url: string) => Promise) | null /** Fetch strategy: 'segmented' | 'streaming' | 'sequential' */ @@ -282,6 +292,14 @@ export interface SegmentFetcherOptions { username?: string password?: string } | null + /** Backward-compatible network block used by some callers. */ + network?: { + proxy?: { + url: string + username?: string + password?: string + } | null + } /** URL resolution callback */ onResolveUrl?: ((url: string) => Promise) | null } diff --git a/src/typings/playback/opus.types.ts b/src/typings/playback/opus.types.ts index d44e181c..18ae60b9 100644 --- a/src/typings/playback/opus.types.ts +++ b/src/typings/playback/opus.types.ts @@ -19,6 +19,14 @@ export interface OpusEncoderInstance { */ encode(buffer: Buffer, frameSize?: number): Buffer + /** + * Encodes PCM into a caller-owned output buffer. + * @param buffer - PCM audio buffer to encode. + * @param output - Destination for the encoded Opus packet. + * @returns Number of bytes written to the destination. + */ + encodeInto?(buffer: Buffer, output: Buffer): number + /** * Sets the encoding bitrate. * @param bitrate - Bitrate in bits per second. @@ -50,6 +58,14 @@ export interface OpusDecoderInstance { */ decode(buffer: Buffer): Buffer + /** + * Decodes an Opus packet into a caller-owned PCM buffer. + * @param buffer - Opus packet to decode. + * @param output - Destination for decoded PCM audio. + * @returns Number of bytes written to the destination. + */ + decodeInto?(buffer: Buffer, output: Buffer): number + /** * Releases resources associated with the decoder. */ diff --git a/src/typings/playback/player.types.ts b/src/typings/playback/player.types.ts index 2dc3219d..c1409337 100644 --- a/src/typings/playback/player.types.ts +++ b/src/typings/playback/player.types.ts @@ -1,4 +1,8 @@ -import type { VoiceAudioStream, VoiceConnection } from '@performanc/voice' +import type { + VoiceAudioStream, + VoiceConnection, + VoicePlayerState +} from '@performanc/voice' import type { TrackData } from '../index.types.ts' import type { TrackStreamResult, @@ -34,6 +38,7 @@ export interface FadingConfig { seek?: FadingSection pause?: FadingSection resume?: FadingSection + ducking?: import('./ducking.types.ts').DuckingConfig } /** @@ -132,28 +137,30 @@ export interface AudioResource { style: import('./processing.types.ts').ScratchStyle ): void checkScratchEffectCompleted?(): boolean - /** - * Reports the current effective playback rate (combining all filters and effects). - */ getEffectiveRate?: () => number - /** - * Returns the current RMS level of the audio stream. - */ getRMS?: () => number - /** - * Returns true if the audio stream is currently silent. - */ isSilent?: () => boolean + setLoudnessNormalizer?(enabled: boolean): void destroy(): void stream?: VoiceAudioStream | null } +export interface ExtendedVoiceConnection extends VoiceConnection { + audioStream?: VoiceAudioStream | null + udp?: { flush?: () => void } + playerState?: VoicePlayerState & { reason?: string } +} + export interface TrackEnergy { rms: number } export interface ExtendedAudioStream extends AudioResource { getMainEnergy?: () => TrackEnergy | null + destroyed?: boolean + _cleanupListeners?: () => void + pipes?: Array<{ destroy?: () => void }> + isPipelineFinished?: () => boolean } export interface FilterTransitionsConfig { @@ -222,6 +229,7 @@ export interface AudioMixer { layersPCM: Map ) => Buffer hasActiveLayers: () => boolean + destroy: () => this on: ( event: 'mixStarted' | 'mixEnded' | 'mixError', listener: (data: { @@ -308,6 +316,47 @@ export interface NodeLinkOptions { autoCleanup?: boolean } connection?: import('../voice/connection.types.ts').ConnectionConfig + search: { + maxResults?: number + defaultSource?: string | string[] + unifiedSources?: string[] + resolveExternalLinks?: boolean + fetchChannelInfo?: boolean + [key: string]: unknown + } + playback: { + maxPlaylistLength?: number + playerUpdateInterval?: number + statsUpdateInterval?: number + trackStuckThresholdMs?: number + eventTimeoutMs?: number + zombieThresholdMs?: number + sponsorblock?: NodeLinkOptions['sponsorblock'] + filters?: { enabled?: Record } + audio?: NodeLinkOptions['audio'] + voiceReceive?: { enabled?: boolean; format?: string } + mix?: NodeLinkOptions['mix'] + [key: string]: unknown + } + experimental: { + enableHoloTracks?: boolean + [key: string]: unknown + } + network: { + proxy?: { + enabled?: boolean + list?: unknown[] + [key: string]: unknown + } + connection?: import('../voice/connection.types.ts').ConnectionConfig + routePlanner?: { + strategy?: string + bannedIpCooldown?: number + ipBlocks?: Array + [key: string]: unknown + } + [key: string]: unknown + } } export type AudioOptionsWithTransitions = NonNullable< @@ -383,7 +432,7 @@ export type LoggerFn = (level: string, ...args: unknown[]) => void * NodeLink runtime context required by the player. */ export interface NodeLink { - options: Partial & { + options: NodeLinkOptions & { trackStuckThresholdMs: number playerUpdateInterval: number } @@ -391,6 +440,7 @@ export interface NodeLink { statsManager: StatsManagerLike voiceRelay?: { attach?: (connection: VoiceConnection, guildId: string) => void + detach?: (connection: VoiceConnection) => void } sources: SourceManagerLike lyrics: LyricsManagerLike | null @@ -399,6 +449,9 @@ export interface NodeLink { audioInterceptors?: Array<() => import('node:stream').Transform> } & Record pluginManager?: import('../../managers/pluginManager.ts').default | null + trackCacheManager?: + | import('../../managers/trackCacheManager.ts').default + | null getLyricsManager?: () => Promise [key: string]: unknown } diff --git a/src/typings/playback/processing.types.ts b/src/typings/playback/processing.types.ts index a0ab807b..2d1e4229 100644 --- a/src/typings/playback/processing.types.ts +++ b/src/typings/playback/processing.types.ts @@ -50,6 +50,7 @@ export interface IVolumeTransformer extends Transform { readonly channels: number setVolume(volume: number): void process(chunk: Buffer): Buffer + setAGCEnabled?(enabled: boolean): void } /** diff --git a/src/typings/playback/streamProcessor.types.ts b/src/typings/playback/streamProcessor.types.ts index 64e7e485..c35a8b87 100644 --- a/src/typings/playback/streamProcessor.types.ts +++ b/src/typings/playback/streamProcessor.types.ts @@ -239,8 +239,8 @@ export interface SymphoniaDecoderLike { isProbed: boolean /** Pushes new data to the decoder buffer. */ push(chunk: Buffer): void - /** Initializes the decoder after probing. */ - initialize(): boolean + /** Initializes the decoder once enough compressed input is buffered. */ + initialize(codecRegistryHint?: string | null): boolean /** Decodes the next available frame. */ decode(): DecodeResult | null /** Closes the input handle. */ @@ -414,6 +414,8 @@ export interface FadeTransformerOptions { export interface SymphoniaDecoderStreamOptions extends TransformOptions { /** Desired resampling quality. */ resamplingQuality?: string + /** Optional file-extension hint for Symphonia probing. */ + codecRegistryHint?: string | null /** Stream high water mark in bytes. */ highWaterMark?: number } @@ -424,6 +426,7 @@ export interface SymphoniaDecoderStreamOptions extends TransformOptions { export interface AACDecoderStreamOptions extends TransformOptions { /** Desired resampling quality. */ resamplingQuality?: ResamplingQuality + state?: { isAlac: boolean } } /** diff --git a/src/typings/sources/bandcamp.types.ts b/src/typings/sources/bandcamp.types.ts new file mode 100644 index 00000000..239cad0b --- /dev/null +++ b/src/typings/sources/bandcamp.types.ts @@ -0,0 +1,113 @@ +/** + * Type definitions for Bandcamp source payloads. + * @module typings/sources/bandcamp.types + */ + +/** + * Single result returned by the Bandcamp autocomplete search API. + */ +export interface BandcampApiSearchResult { + /** Item type, e.g. `"t"` for track, `"a"` for album. */ + type?: string + /** Internal Bandcamp identifier. */ + id?: number + /** Artwork identifier for building image URLs. */ + art_id?: number | null + /** Track or album title. */ + name?: string + /** Artist or band name. */ + band_name?: string + /** Album name when the result is a track within an album. */ + album_name?: string | null + /** Full canonical URL of the item. */ + item_url_path?: string + /** Pre-built thumbnail URL. */ + img?: string | null +} + +/** + * Envelope returned by the Bandcamp autocomplete search API. + */ +export interface BandcampApiSearchResponse { + /** Autocomplete results bucket. */ + auto?: { + /** Matched items. */ + results?: BandcampApiSearchResult[] + } +} + +/** + * Minimal Bandcamp track payload used by `data-tralbum`. + */ +export interface BandcampTralbumTrack { + /** Internal track identifier exposed by Bandcamp. */ + track_id?: string | number + /** Secondary internal identifier used by some pages. */ + id?: string | number + /** Relative per-track page URL when the payload represents an album. */ + title_link?: string + /** Human-readable track title. */ + title?: string + /** Duration in seconds. */ + duration?: number + /** Stream file mapping keyed by format (e.g. `"mp3-128"`). */ + file?: Record +} + +/** + * Minimal Bandcamp page payload used by the source. + */ +export interface BandcampTralbumData { + /** Artist name extracted from the page payload. */ + artist?: string + /** Artwork identifier used to build the public image URL. */ + art_id?: string | number + /** Current page metadata. */ + current?: { + /** Album or track title. */ + title?: string + /** ISRC when exposed by Bandcamp. */ + isrc?: string | null + } + /** Track list present on the page. */ + trackinfo?: BandcampTralbumTrack[] +} + +/** + * Structured data extracted from the JSON-LD `MusicRecording` block. + */ +export interface BandcampJsonLdData { + /** Track or album title. */ + name?: string + /** ISO 8601 duration string (e.g. `"P00H05M20S"`). */ + duration?: string + /** ISRC code when available. */ + isrcCode?: string | null + /** Artwork URL from the structured data. */ + image?: string | null + /** Nested artist metadata. */ + byArtist?: { + /** Human-readable artist name. */ + name?: string + } + /** Additional properties containing `track_id`, `art_id`, etc. */ + additionalProperty?: Array<{ + name?: string + value?: string | number + }> +} + +/** + * Track fields required to build an encoded Bandcamp track. + */ +export interface BandcampTrackBuildInput { + identifier?: string | null + isSeekable?: boolean + author?: string | null + length?: number + isStream?: boolean + title?: string | null + uri: string + artworkUrl: string | null + isrc?: string | null +} diff --git a/src/typings/sources/monochrome.types.ts b/src/typings/sources/monochrome.types.ts index 80d7a0b7..51333a1e 100644 --- a/src/typings/sources/monochrome.types.ts +++ b/src/typings/sources/monochrome.types.ts @@ -9,8 +9,12 @@ export interface MonochromeSourceConfig { instances?: string[] /** List of streaming instances used for manifest resolution. */ streamingInstances?: string[] + /** List of Qobuz proxy instances used as fallback for stream resolution. */ + qobuzInstances?: string[] /** Preferred audio quality. */ quality?: 'HI_RES_LOSSLESS' | 'LOSSLESS' | 'HIGH' | 'LOW' + /** Quality level for Qobuz proxy downloads (5 = MP3 320kbps, 6 = Default FLAC, 7 = FLAC 24bit, 27 = HiRes FLAC 24bit). */ + qobuzQuality?: number } /** diff --git a/src/typings/sources/sabr.types.ts b/src/typings/sources/sabr.types.ts index 9b104144..71263b20 100644 --- a/src/typings/sources/sabr.types.ts +++ b/src/typings/sources/sabr.types.ts @@ -133,10 +133,13 @@ export interface SabrStreamConfig { */ positionCallback?: (positionMs: number) => void + /** Returns whether playback is currently paused. */ + playbackPaused?: () => boolean + /** * Previous session state for session continuation across seek operations. - * Transfers request number, bandwidth estimate, and next request policy - * to avoid the session recreation penalty. + * Transfers request ordering, policy, bandwidth, and SABR contexts to avoid + * the session recreation penalty. */ previousSession?: PreviousSessionState @@ -212,6 +215,16 @@ export interface PreviousSessionState { * Contains backoff timing and playback cookie for session continuity. */ nextRequestPolicy?: NextRequestPolicyMsg + + /** SABR contexts required to continue the existing server session. */ + sabrContexts?: Array<{ + type: number + value: Uint8Array + sendByDefault?: boolean + }> + + /** Context types currently enabled by the server sending policy. */ + activeSabrContextTypes?: number[] } /** @@ -348,6 +361,9 @@ export interface PartialSegmentQueueEntry { /** Number of bytes received so far for this segment. */ loadedBytes: number + + /** Whether this segment overlaps media already forwarded downstream. */ + discard?: boolean } /** diff --git a/src/typings/sources/source.types.ts b/src/typings/sources/source.types.ts index 4de73796..a729b7fc 100644 --- a/src/typings/sources/source.types.ts +++ b/src/typings/sources/source.types.ts @@ -10,6 +10,7 @@ import type { StatsSnapshot, WorkerMetricsPayload } from '../api/stats.types.ts' +import type { NodelinkConfig } from '../config/config.types.ts' import type { CredentialEntry, CredentialManagerStats @@ -544,16 +545,7 @@ export interface SourceInstance { */ export interface WorkerNodeLink { /** Configuration options */ - options: Record & { - sources?: Record - audio?: { - loudnessNormalizer?: boolean - resamplingQuality?: string - } - metrics?: { - enabled?: boolean - } - } + options: NodelinkConfig /** Logger function */ logger: LoggerFn /** Source manager instance */ @@ -568,6 +560,8 @@ export interface WorkerNodeLink { trackCacheManager?: TrackCacheManager /** Route planner manager instance */ routePlanner?: RoutePlannerManager + /** Proxy manager instance */ + proxyManager?: import('../../managers/proxyManager.ts').default /** Stats manager instance */ statsManager?: StatsManager /** Global plugin manager for hook execution. */ @@ -819,7 +813,7 @@ export interface RoutePlannerManager { /** Initialize route planner */ initialize?: () => Promise /** Dispose route planner */ - dispose?: () => Promise + dispose?: () => void | Promise /** Get an IP address */ getIP?: () => string | null | undefined } diff --git a/src/typings/sources/vimeo.types.ts b/src/typings/sources/vimeo.types.ts index 7dbaa7e4..bf5d25cd 100644 --- a/src/typings/sources/vimeo.types.ts +++ b/src/typings/sources/vimeo.types.ts @@ -7,7 +7,6 @@ * @packageDocumentation */ -import type { PassThrough } from 'node:stream' import type { SourceResult, TrackInfo, @@ -286,24 +285,6 @@ export interface VimeoConfig { } } -/** - * Segment URL build parameters. - * - * Combines playlist directory, base path, track path, and segment - * path into a fully-qualified segment URL. - * @public - */ -export interface VimeoSegmentUrlParts { - /** Resolved playlist directory URL. */ - playlistDir: string - /** Base path prefix from playlist JSON. */ - basePath: string - /** Track-level path prefix. */ - trackPath: string - /** Individual segment relative path. */ - segmentPath: string -} - /** * Parsed playlist data consumed by the segment streamer. * @public @@ -331,6 +312,8 @@ export interface VimeoPlaylistData { clipId?: number | string /** Whether this is DASH format (affects init segment handling). */ isDashFormat?: boolean + /** Container type passed to the playback demuxer. */ + streamType?: 'fmp4' | 'mp4' } /** @@ -365,7 +348,7 @@ export interface VimeoSegmentedResult { /** Stream protocol identifier. */ protocol: 'segmented' | 'hls' | 'https' /** Container format. */ - format: 'mp4' | 'mpegts' + format: 'fmp4' | 'mp4' | 'mpegts' /** Parsed playlist data for segmented streams. */ playlistData?: VimeoPlaylistData /** Additional metadata. */ @@ -412,47 +395,6 @@ export type VimeoStreamResult = | VimeoSegmentedResult | VimeoHlsResult -/** - * Internal HTTP response shape used by Vimeo source helpers. - * @public - */ -export interface VimeoHttpResponse { - /** HTTP status code. */ - statusCode: number - /** Response headers. */ - headers: Record - /** Response body as Buffer. */ - body: Buffer -} - -/** - * Options for internal HTTP request helper. - * @public - */ -export interface VimeoHttpRequestOptions { - /** Maximum number of redirects to follow. @defaultValue 5 */ - maxRedirects?: number - /** Request timeout in milliseconds. @defaultValue 15000 */ - timeout?: number - /** Additional request headers. */ - headers?: Record - /** Maximum buffered response body size in bytes. */ - maxSize?: number - /** HTTP method. @defaultValue 'GET' */ - method?: string -} - -/** - * Options for the curl subprocess request helper. - * @public - */ -export interface VimeoCurlOptions { - /** Referer header value. */ - referer?: string - /** Origin header value. */ - origin?: string -} - /** * Handoff cache entry storing a playlist result with expiration. * @public @@ -547,12 +489,6 @@ export interface VimeoSourceState { patterns: RegExp[] /** Source priority for URL pattern matching. */ priority: number - /** Cached curl availability check result. */ - _curlAvailable: boolean | null - /** Set of active PassThrough streams for cleanup tracking. */ - _activeStreams: Set - /** Handoff cache for passing playlist data between getTrackUrl and loadStream. */ - _handoff: Map } /** diff --git a/src/typings/sources/youtube.types.ts b/src/typings/sources/youtube.types.ts index 728c130b..13bae796 100644 --- a/src/typings/sources/youtube.types.ts +++ b/src/typings/sources/youtube.types.ts @@ -11,6 +11,7 @@ import type { HttpRequestResult, NodelinkRuntime } from '../utils.types.ts' +import type { ClientInfoMsg, PreviousSessionState } from './sabr.types.ts' import type { TrackInfo } from './source.types.ts' /** @@ -194,11 +195,49 @@ export interface YouTubeContext { */ platform?: string + /** + * Operating system name identifier. + * @example 'Windows', 'Android', 'iOS', 'Linux' + */ + osName?: string + + /** + * UTC offset in minutes relative to GMT. + * @example 0, -180, 120 + */ + utcOffsetMinutes?: number + + /** + * Operating system version string. + * @example '10.0', '13', '14.1' + */ + osVersion?: string + /** * User agent string sent with API requests. * @example 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...' */ userAgent?: string + + /** + * Client form factor. + */ + clientFormFactor?: string + + /** + * User interface theme. + */ + userInterfaceTheme?: string + + /** + * Browser name. + */ + browserName?: string + + /** + * Browser version string. + */ + browserVersion?: string } } @@ -561,6 +600,38 @@ export interface YouTubePlayerResponse { likeCount?: string | number [key: string]: unknown } + microformatDataRenderer: { + urlCanonical: string + title: string + description: string + thumbnail: unknown[] + siteName: string + appName: string + androidPackage: string + iosAppStoreId: string + iosAppArguments: string + ogType: string + urlApplinksIos: string + urlApplinksAndroid: string + urlTwitterIos: string + urlTwitterAndroid: string + twitterCardType: string + twitterSiteHandle: string + schemaDotOrgType: string + noindex: boolean + unlisted: boolean + paid: boolean + familySafe: boolean + availableCountries: unknown[] + pageOwnerDetails: Record + videoDetails: Record + linkAlternates: unknown[] + viewCount: string + publishDate: string + category: string + uploadDate: string + [key: string]: unknown + } } /** Playability status for the video */ @@ -910,6 +981,8 @@ export interface TrackUrlData { hlsUrl?: string | null /** Array of available format entries with their metadata. */ formats?: FormatEntry[] + /** The specific itag used for this track URL. */ + itag?: number /** Additional metadata attached to the track URL (content length, proxy info, access tokens, etc.). */ additionalData?: Record /** New track information when resolution redirects to a different track (e.g., fallback sources). */ @@ -945,6 +1018,8 @@ export interface FormatEntry { mimeType?: string /** Average bitrate in bits per second for this format variant. */ bitrate?: number + /** Audio track identifier for multilingual audio. */ + audioTrackId?: string /** Allow additional format-specific properties for forward compatibility. */ [key: string]: unknown } @@ -966,8 +1041,10 @@ export interface StreamResult { responseStream?: Readable /** Underlying SABR stream instance (SABR protocol only). */ _sabrStream?: unknown - /** Returns the current SABR session state for reconnection (SABR protocol only). */ - getSessionState?: () => unknown + /** Pauses SABR requests and returns state for a seek replacement. */ + beginSeekHandoff?: () => Promise + /** Resumes SABR requests when a seek replacement fails. */ + cancelSeekHandoff?: () => void /** Destroys the stream and releases all associated resources. */ destroy: (err?: Error) => void } @@ -1004,25 +1081,29 @@ export interface TrackUrlAdditionalData { /** Server-side ABR streaming URL used to establish SABR sessions. */ serverAbrStreamingUrl?: string /** Video playback ustreamer configuration blob used by SABR for media serving. */ - videoPlaybackUstreamerConfig?: unknown + videoPlaybackUstreamerConfig?: string | Uint8Array /** Proof-of-origin token required by SABR for bot-detection bypass. */ - poToken?: string + poToken?: string | Uint8Array /** Client identification metadata passed to SABR session initialization. */ - clientInfo?: unknown + clientInfo?: ClientInfoMsg /** Available format entries used by SABR to select audio quality. */ formats?: FormatEntry[] + /** The specific itag used for this track URL. */ + itag?: number /** Start time offset in seconds for SABR stream initialization. */ startTime?: number /** Position callback used by SABR to report playback progress. */ - positionCallback?: unknown + positionCallback?: (positionMs: number) => void + /** Callback used by SABR to stop its playhead while playback is paused. */ + playbackPaused?: () => boolean /** Previous SABR session state for session continuation. */ - previousSession?: unknown + previousSession?: PreviousSessionState /** Unique key identifying this stream in the active streams map. */ streamKey?: string | symbol /** User-Agent header value for SABR HTTP requests. */ userAgent?: string /** Playback cookie used for authenticated SABR sessions. */ - playbackCookie?: unknown + playbackCookie?: string | Uint8Array /** Allow additional properties for future extensibility. */ [key: string]: unknown } diff --git a/src/typings/utils.types.ts b/src/typings/utils.types.ts index c73c0f9e..944e0db8 100644 --- a/src/typings/utils.types.ts +++ b/src/typings/utils.types.ts @@ -119,6 +119,10 @@ export interface HttpRequestOptions { maxRetries?: number /** Proxy settings for the request. */ proxy?: HttpProxyConfig + /** Backward-compatible network block used by some callers. */ + network?: { + proxy?: HttpProxyConfig + } } /** diff --git a/src/typings/voice/voice.types.ts b/src/typings/voice/voice.types.ts index 1eb19eef..663f656f 100644 --- a/src/typings/voice/voice.types.ts +++ b/src/typings/voice/voice.types.ts @@ -87,6 +87,11 @@ export interface VoiceRelay { * @param guildId - The guild ID for context. */ attach: (connection: VoiceConnection, guildId: string) => void + /** + * Detaches the relay from a voice connection. + * @param connection - The voice connection to detach from. + */ + detach: (connection: VoiceConnection) => void } /** @@ -110,4 +115,6 @@ export interface ActiveStreamEntry { */ export type ExtendedVoiceConnection = VoiceConnection & { _voiceRelayAttached?: boolean + _voiceRelaySpeakStart?: (userId: string, ssrc: number) => void + _voiceRelaySpeakEnd?: (userId: string, ssrc: number) => void } diff --git a/src/utils.ts b/src/utils.ts index 79ce29b7..66206de2 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -17,6 +17,7 @@ import { REDIRECT_STATUS_CODES, SEMVER_PATTERN } from './constants.ts' +import type CredentialManager from './managers/credentialManager.ts' import type { ApiHttpMethod, ApiRequest, @@ -43,8 +44,6 @@ import type { declare const __BUILD_GIT_INFO__: GitInfo | undefined -const isBun = typeof process !== "undefined" && process.versions?.bun; - /** * Reference to the runtime NodeLink instance stored on the global object. * @@ -175,7 +174,7 @@ function getLogFileName(): string { * Failures are reported to stderr but do not crash the process. * @internal */ -function cleanOldLogs(): void { +async function cleanOldLogs(): Promise { if (!loggingConfig.file?.enabled) return const logDir = loggingConfig.file.path || 'logs' @@ -184,20 +183,25 @@ function cleanOldLogs(): void { const now = Date.now() try { - if (!fs.existsSync(logDir)) return + const fsPromises = await import('node:fs/promises') + try { + await fsPromises.access(logDir) + } catch { + return + } - const files = fs.readdirSync(logDir) + const files = await fsPromises.readdir(logDir) let cleanedCount = 0 for (const file of files) { if (!file.startsWith('nodelink-') || !file.endsWith('.log')) continue const filePath = path.join(logDir, file) - const stats = fs.statSync(filePath) + const stats = await fsPromises.stat(filePath) const fileAge = now - stats.mtimeMs if (fileAge > ttlMs) { - fs.unlinkSync(filePath) + await fsPromises.unlink(filePath) cleanedCount++ } } @@ -235,9 +239,7 @@ function rotateLogFile(): void { logStream = null } - if (!fs.existsSync(logDir)) { - fs.mkdirSync(logDir, { recursive: true }) - } + fs.mkdirSync(logDir, { recursive: true }) currentLogFile = newLogFilePath logStream = fs.createWriteStream(currentLogFile, { flags: 'a' }) @@ -623,17 +625,25 @@ function getGitInfo(): GitInfo { if (gitInfoCache) return gitInfoCache try { - const branch = execSync('git rev-parse --abbrev-ref HEAD', { - encoding: 'utf8' - }).trim() - const commit = execSync('git rev-parse --short HEAD', { + const output = execSync('git log -1 --format=%D%n%h%n%ct', { encoding: 'utf8' }).trim() - const commitTime = - Number.parseInt( - execSync('git log -1 --format=%ct', { encoding: 'utf8' }).trim(), - 10 - ) * 1000 + const lines = output.split('\n') + const refsLine = lines[0] || '' + const commit = (lines[1] || 'unknown').trim() + const commitTime = Number.parseInt((lines[2] || '0').trim(), 10) * 1000 + + let branch = 'unknown' + const headMatch = refsLine.match(/HEAD -> ([^,]+)/) + if (headMatch) { + branch = headMatch[1]!.trim() + } else { + try { + branch = execSync('git rev-parse --abbrev-ref HEAD', { + encoding: 'utf8' + }).trim() + } catch {} + } gitInfoCache = { branch, @@ -1420,15 +1430,20 @@ async function _internalHttp1Request( finalStream = res.pipe(zlib.createInflate()) } - res.on('error', (err) => + let cleanupBody: (() => void) | undefined + res.on('error', (err) => { + cleanupBody?.() + cleanupReq() reject(new Error(`Response error for ${urlString}: ${err.message}`)) - ) + }) if (finalStream !== res) { - finalStream.on('error', (err) => + finalStream.on('error', (err) => { + cleanupBody?.() + cleanupReq() reject( new Error(`Decompression error for ${urlString}: ${err.message}`) ) - ) + }) } if (streamOnly) { @@ -1443,7 +1458,7 @@ async function _internalHttp1Request( const chunks: Buffer[] = [] let bufferedBytes = 0 - finalStream.on('data', (chunk) => { + const onData = (chunk: Buffer) => { bufferedBytes += chunk.length if (bufferedBytes > maxResponseBodyBytes) { ;( @@ -1458,10 +1473,11 @@ async function _internalHttp1Request( return } chunks.push(chunk) - }) - finalStream.on('end', () => { + } + const onEnd = () => { try { const responseBuffer = Buffer.concat(chunks) + cleanupBody?.() if (options.responseType === 'buffer') { resolve({ @@ -1494,16 +1510,39 @@ async function _internalHttp1Request( `Error processing response body for ${urlString}: ${err instanceof Error ? err.message : String(err)}` ) ) + } finally { + cleanupBody?.() + cleanupReq() } - }) + } + + cleanupBody = () => { + finalStream.removeListener('data', onData) + finalStream.removeListener('end', onEnd) + chunks.length = 0 + cleanupBody = undefined + } + finalStream.on('data', onData) + finalStream.once('end', onEnd) }) - req.on('error', (err) => reject(err)) - req.on('timeout', () => { + const reqErrorHandler = (err: Error) => { + cleanupReq() + reject(err) + } + const reqTimeoutHandler = () => { req.destroy( new Error(`Request timed out after ${timeout}ms for ${urlString}`) ) - }) + } + + const cleanupReq = () => { + req.removeListener('error', reqErrorHandler) + req.removeListener('timeout', reqTimeoutHandler) + } + + req.on('error', reqErrorHandler) + req.on('timeout', reqTimeoutHandler) if (payloadBuffer) { req.end(payloadBuffer) @@ -1675,15 +1714,8 @@ async function makeRequest( new Error(`Too many redirects (${maxRedirects}) for ${urlString}`) ) } - // fall back to HTTP/1 for Bun requests - // Note: bun v1.3.12, crashes with "authority" argument must be a type of string, object or URL. received type Number (825110816) - // Crashes the source worker ^^, could be related to monochrome's request or anything else that uses http/2 - // UPDATE: Bun v1.3.13 has fixed this crash, since it was released today as this commit, i will be checking the version but can be removed later. - if (isBun && process.versions.bun.localeCompare('1.3.13', undefined, { numeric: true }) < 0) { - return http1makeRequest(urlString, options); - } - if (options.proxy) { + if (options.network?.proxy) { return http1makeRequest(urlString, options) } @@ -1958,6 +1990,243 @@ async function makeRequest( }) } +/** + * Checks for updates of core dependencies against the NPM registry. + * + * Logs a warning if an update is available for critical packages. + * @public + */ +/** + * Checks for updates of core dependencies against the NPM registry and GitHub. + * + * Logs a warning if an update is available for critical packages. + * @param credentialManager - Persistence manager to rate-limit checks. + * @public + */ +async function checkDependencyUpdates( + credentialManager?: CredentialManager +): Promise { + const coreDeps = [ + '@performanc/voice', + '@performanc/pwsl-server', + '@toddynnn/symphonia-decoder', + '@toddynnn/voice-opus', + '@ecliptia/faad2-wasm', + '@alexanderolsen/libsamplerate-js', + '@ecliptia/seekable-stream', + 'mp4box' + ] + + const localVersions: Array<{ name: string; version: string }> = [] + + for (const dep of coreDeps) { + try { + const depPath = path.join( + process.cwd(), + 'node_modules', + dep, + 'package.json' + ) + const version = JSON.parse(fs.readFileSync(depPath, 'utf8')).version + localVersions.push({ name: dep, version }) + } catch { + // Ignore if package not found + } + } + + if (localVersions.length > 0) { + logger( + 'info', + 'Server', + `Installed core packages: ${localVersions.map((v) => `${v.name}@${v.version}`).join(', ')}` + ) + } + + const CHECK_INTERVAL_MS = 10 * 60 * 1000 // 10 minutes + const now = Date.now() + let latestVersions: Record< + string, + { version: string; source: 'NPM' | 'GitHub' } + > = {} + let isCacheValid = false + + if (credentialManager) { + const cache = credentialManager.get<{ + ts: number + versions: Record + }>('runtime.dependencies.latest') + + if (cache && now - cache.ts < CHECK_INTERVAL_MS) { + latestVersions = cache.versions + isCacheValid = true + } + } + + if (!isCacheValid) { + const controller = new AbortController() + const timeout = setTimeout(() => controller.abort(), 5000) + + try { + const deps = + (packageJson as { dependencies?: Record }) + .dependencies || {} + + await Promise.all( + coreDeps.map(async (dep) => { + try { + const declaredVersion = deps[dep] || '' + let latestVersionStr = '' + let source: 'NPM' | 'GitHub' = 'NPM' + + if ( + declaredVersion.startsWith('github:') || + (declaredVersion.includes('/') && !declaredVersion.includes(':')) + ) { + source = 'GitHub' + const repo = declaredVersion.replace('github:', '').split('#')[0] + const branch = declaredVersion.split('#')[1] || 'main' + const response = await fetch( + `https://raw.githubusercontent.com/${repo}/${branch}/package.json`, + { signal: controller.signal } + ) + if (response.ok) { + const data = (await response.json()) as { version: string } + latestVersionStr = data.version + } + } else if ( + !declaredVersion.includes(':') && + !declaredVersion.includes('/') + ) { + const response = await fetch( + `https://registry.npmjs.org/${dep}/latest`, + { + signal: controller.signal + } + ) + if (response.ok) { + const data = (await response.json()) as { version: string } + latestVersionStr = data.version + } + } + + if (latestVersionStr) { + latestVersions[dep] = { version: latestVersionStr, source } + } + } catch { + // Ignore individual failures + } + }) + ) + + if (credentialManager && Object.keys(latestVersions).length > 0) { + credentialManager.set( + 'runtime.dependencies.latest', + { ts: now, versions: latestVersions }, + 24 * 60 * 60 * 1000 + ) + } + } catch (error) { + logger( + 'debug', + 'Server', + `Failed to check dependency updates: ${error instanceof Error ? error.message : String(error)}` + ) + } finally { + clearTimeout(timeout) + } + } + + const updates: Array<{ + name: string + current: string + latest: string + source: 'NPM' | 'GitHub' + }> = [] + + for (const local of localVersions) { + const latest = latestVersions[local.name] + if (!latest || local.version === latest.version) continue + + const currentSemver = parseSemver(local.version) + const latestSemver = parseSemver(latest.version) + + if (currentSemver && latestSemver) { + const isNewer = + latestSemver.major > currentSemver.major || + (latestSemver.major === currentSemver.major && + latestSemver.minor > currentSemver.minor) || + (latestSemver.major === currentSemver.major && + latestSemver.minor === currentSemver.minor && + latestSemver.patch > currentSemver.patch) + + if (isNewer) { + updates.push({ + name: local.name, + current: local.version, + latest: latest.version, + source: latest.source + }) + } + } + } + + if (updates.length > 0) { + logger( + 'warn', + 'Server', + 'The following core dependencies have updates available and will be automatically updated:' + ) + + for (const update of updates) { + logger( + 'warn', + 'Server', + ` - ${update.name}: ${update.current} -> \x1b[1m\x1b[32m${update.latest}\x1b[0m (${update.source})` + ) + } + + try { + logger('info', 'Server', `Running automatic update for core packages...`) + // pnpm and bun can be on the same path, so we check both + // (referring to myself, im lazy to delete the pnpm lock file) + + const isBun = + process.versions.bun && + fs.existsSync(path.resolve(process.cwd(), 'bun.lock')) + const isPnpm = + fs.existsSync(path.resolve(process.cwd(), 'pnpm-lock.yaml')) && !isBun + const cmd = isPnpm ? 'pnpm update' : isBun ? 'bun update' : 'npm update' + execSync(cmd, { stdio: 'inherit' }) + logger( + 'info', + 'Server', + 'Dependencies updated successfully. Restarting process to apply changes...' + ) + + const { spawn } = await import('node:child_process') + const child = spawn(process.argv[0] as string, process.argv.slice(1), { + stdio: 'inherit', + env: process.env + } as import('node:child_process').SpawnOptions) + + child.on('exit', (code: number | null) => { + process.exit(code ?? 0) + }) + + // Halt execution of the parent process forever while the child runs + await new Promise(() => {}) + } catch (error) { + logger( + 'error', + 'Server', + `Failed to auto-update dependencies: ${error instanceof Error ? error.message : String(error)}` + ) + } + } else if (Object.keys(latestVersions).length > 0) { + logger('info', 'Server', 'All core packages are up to date.') + } +} + /** * Checks for git updates against the upstream branch. * @@ -1967,26 +2236,37 @@ async function makeRequest( async function checkForUpdates(): Promise { logger('info', 'Git', 'Checking for updates...') try { - execSync('git fetch', { stdio: 'ignore' }) + const { exec } = await import('node:child_process') + const util = await import('node:util') + const execAsync = util.promisify(exec) + + await execAsync('git fetch', { stdio: 'ignore' } as any) - const local = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim() - const remote = execSync('git rev-parse @{u}', { encoding: 'utf8' }).trim() + const { stdout: local } = await execAsync('git rev-parse HEAD', { + encoding: 'utf8' + }) + const { stdout: remote } = await execAsync('git rev-parse @{u}', { + encoding: 'utf8' + }) - if (local !== remote) { - const behind = execSync('git rev-list --right-only --count HEAD...@{u}', { - encoding: 'utf8' - }).trim() - const remoteCommit = execSync( + if (local.trim() !== remote.trim()) { + const { stdout: behind } = await execAsync( + 'git rev-list --right-only --count HEAD...@{u}', + { + encoding: 'utf8' + } + ) + const { stdout: remoteCommit } = await execAsync( 'git log -1 --pretty=format:"%h - %s (%cr)" @{u}', { encoding: 'utf8' } - ).trim() + ) logger( 'warn', 'Git', - `Your version is ${behind} commits behind the remote.` + `Your version is ${behind.trim()} commits behind the remote.` ) - logger('warn', 'Git', `Latest commit: ${remoteCommit}`) + logger('warn', 'Git', `Latest commit: ${remoteCommit.trim()}`) logger('warn', 'Git', 'Please run "git pull" to update.') } else { logger('info', 'Git', 'You are running the latest version.') @@ -2136,11 +2416,11 @@ function applyEnvOverrides( * @returns Best matching candidate or null. * @public */ -function getBestMatch( - list: BestMatchCandidate[], +export function getBestMatch( + list: T[], original: BestMatchTrackInfo, options: BestMatchOptions = {} -): BestMatchCandidate | null { +): T | null { const { durationTolerance = 0.15, allowExplicit = true } = options const normalize = (str: string): string => { @@ -2313,7 +2593,11 @@ async function fetchSponsorBlockSegments( const url = `${apiBase.replace(/\/+$/, '')}/api/skipSegments/${prefix}?${params.toString()}` - logger('debug', 'SponsorBlock', `Fetching segments for video ${videoId} (prefix: ${prefix}) from ${url}`) + logger( + 'debug', + 'SponsorBlock', + `Fetching segments for video ${videoId} (prefix: ${prefix}) from ${url}` + ) try { const startTime = Date.now() @@ -2321,45 +2605,70 @@ async function fetchSponsorBlockSegments( const duration = Date.now() - startTime if (result.statusCode !== 200) { - logger('warn', 'SponsorBlock', `API returned status ${result.statusCode} for video ${videoId} after ${duration}ms`) + logger( + 'warn', + 'SponsorBlock', + `API returned status ${result.statusCode} for video ${videoId} after ${duration}ms` + ) return [] } if (!Array.isArray(result.body)) { - logger('debug', 'SponsorBlock', `No segments found for prefix ${prefix} (Status: ${result.statusCode}, Duration: ${duration}ms)`) + logger( + 'debug', + 'SponsorBlock', + `No segments found for prefix ${prefix} (Status: ${result.statusCode}, Duration: ${duration}ms)` + ) return [] } - const videoMatch = (result.body as Array<{ videoID: string; segments: any[] }>).find( - (entry) => entry.videoID === videoId - ) + const videoMatch = ( + result.body as Array<{ + videoID: string + segments: Array + }> + ).find((entry) => entry.videoID === videoId) if (!videoMatch?.segments) { - logger('debug', 'SponsorBlock', `No exact match for video ${videoId} in prefix results (Results: ${result.body.length}, Duration: ${duration}ms)`) + logger( + 'debug', + 'SponsorBlock', + `No exact match for video ${videoId} in prefix results (Results: ${result.body.length}, Duration: ${duration}ms)` + ) return [] } - logger('debug', 'SponsorBlock', `Successfully loaded ${videoMatch.segments.length} segments for video ${videoId} in ${duration}ms`) + logger( + 'debug', + 'SponsorBlock', + `Successfully loaded ${videoMatch.segments.length} segments for video ${videoId} in ${duration}ms` + ) return videoMatch.segments.map((s) => ({ - uuid: s.UUID, - start: Math.round(s.segment[0] * 1000), - end: Math.round(s.segment[1] * 1000), + uuid: s.uuid, + start: Math.round(s.start * 1000), + end: Math.round(s.end * 1000), category: s.category, actionType: s.actionType, votes: s.votes, - locked: s.locked === 1, + locked: s.locked, videoDuration: Math.round(s.videoDuration * 1000), description: s.description || '' })) } catch (error) { - logger('warn', 'SponsorBlock', `Failed to fetch segments for video ${videoId}:`, error) + logger( + 'warn', + 'SponsorBlock', + `Failed to fetch segments for video ${videoId}:`, + error + ) return [] } } export { applyEnvOverrides, + checkDependencyUpdates, checkForUpdates, cleanupHttpAgents, cleanupLogger, @@ -2367,7 +2676,6 @@ export { encodeTrack, fetchSponsorBlockSegments, generateRandomLetters, - getBestMatch, getGitInfo, getStats, getVersion, diff --git a/src/voice/voiceRelay.ts b/src/voice/voiceRelay.ts index 6e4b4fbe..552a7ec0 100644 --- a/src/voice/voiceRelay.ts +++ b/src/voice/voiceRelay.ts @@ -215,7 +215,7 @@ export function createVoiceRelay({ if (!conn || conn._voiceRelayAttached) return conn._voiceRelayAttached = true - conn.on('speakStart', (userId: string, ssrc: number) => { + const speakStartHandler = (userId: string, ssrc: number) => { void handleSpeakStart(guildId, userId, ssrc).catch((err: Error) => { if (logger) { logger( @@ -225,12 +225,29 @@ export function createVoiceRelay({ ) } }) - }) - - conn.on('speakEnd', (userId: string, ssrc: number) => { + } + const speakEndHandler = (userId: string, ssrc: number) => { handleSpeakStop(guildId, userId, ssrc) - }) + } + + conn._voiceRelaySpeakStart = speakStartHandler + conn._voiceRelaySpeakEnd = speakEndHandler + + conn.on('speakStart', speakStartHandler) + conn.on('speakEnd', speakEndHandler) + } + + const detach = (connection: VoiceConnection): void => { + const conn = connection as ExtendedVoiceConnection + if (!conn._voiceRelayAttached) return + if (conn._voiceRelaySpeakStart) { + conn.removeListener('speakStart', conn._voiceRelaySpeakStart) + } + if (conn._voiceRelaySpeakEnd) { + conn.removeListener('speakEnd', conn._voiceRelaySpeakEnd) + } + conn._voiceRelayAttached = false } - return { attach } + return { attach, detach } } diff --git a/src/workers/main.ts b/src/workers/main.ts index c0473883..c6454775 100644 --- a/src/workers/main.ts +++ b/src/workers/main.ts @@ -18,9 +18,13 @@ import RoutePlannerManager from '../managers/routePlannerManager.ts' import SourceManager from '../managers/sourceManager.ts' import StatsManager from '../managers/statsManager.ts' import TrackCacheManager from '../managers/trackCacheManager.ts' +import { migrateConfig } from '../modules/config/configMigration.ts' import { getWebmOpusProfilerStats } from '../playback/demuxers/WebmOpus.ts' import { bufferPool } from '../playback/structs/BufferPool.ts' -import type { NodelinkConfig as NodeLinkConfig } from '../typings/config/config.types.ts' +import type { + JsonValue, + NodelinkConfig as NodeLinkConfig +} from '../typings/config/config.types.ts' import type { NodeLink, TrackInfoExtended @@ -47,7 +51,12 @@ import type { WorkerNodeLink, WorkerPlayer } from '../typings/workers/worker.types.ts' -import { applyEnvOverrides, cleanupHttpAgents, initLogger, logger } from '../utils.ts' +import { + applyEnvOverrides, + cleanupHttpAgents, + initLogger, + logger +} from '../utils.ts' import { createVoiceRelay } from '../voice/voiceRelay.ts' import { createHeadQueue, @@ -101,13 +110,73 @@ try { let config: NodeLinkConfig const resolveRootConfigUrl = (fileName: string): string => pathToFileURL(resolvePath(process.cwd(), fileName)).href -try { - config = (await import(resolveRootConfigUrl('config.js'))) - .default as unknown as NodeLinkConfig -} catch { - config = (await import(resolveRootConfigUrl('config.default.js'))) - .default as unknown as NodeLinkConfig +const resolveConfigExport = ( + importedModule: Record, + fileName: string +): Record => { + const candidate = + ( + importedModule as { + default?: unknown + config?: unknown + } + ).default ?? + ( + importedModule as { + default?: unknown + config?: unknown + } + ).config + + if ( + candidate && + typeof candidate === 'object' && + Object.keys(candidate as Record).length > 0 + ) { + return candidate as Record + } + + throw new Error( + `[ERROR] Config: ${fileName} must export a non-empty configuration object (default export or named "config").` + ) +} + +const loadConfig = async (): Promise => { + const candidates = [ + 'config.ts', + 'config.js', + 'config.default.ts', + 'config.default.js' + ] + + for (const fileName of candidates) { + try { + const module = await import(resolveRootConfigUrl(fileName)) + const raw = resolveConfigExport( + module as Record, + fileName + ) + + return migrateConfig( + raw as Record + ) as unknown as NodeLinkConfig + } catch (error) { + const err = error as { code?: string; message?: string } + const isNotFound = + err.code === 'ERR_MODULE_NOT_FOUND' || + err.code === 'ENOENT' || + err.message?.includes('Cannot find module') + if (isNotFound) continue + throw error + } + } + + throw new Error( + '[ERROR] Config: Failed to load configuration (config.ts/config.js/config.default.ts/config.default.js).' + ) } + +config = await loadConfig() applyEnvOverrides(config as unknown as Record) const HIBERNATION_ENABLED = config.cluster?.hibernation?.enabled !== false @@ -1094,13 +1163,14 @@ const sendProcessMessage = ( } } -const { EVENT_SOCKET_PATH, COMMAND_SOCKET_PATH, NODE_UNIQUE_ID } = +const { EVENT_SOCKET_PATH, COMMAND_SOCKET_PATH, WORKER_CLUSTER_ID } = process.env as NodeJS.ProcessEnv & { EVENT_SOCKET_PATH?: string COMMAND_SOCKET_PATH?: string - NODE_UNIQUE_ID?: string + WORKER_CLUSTER_ID?: string } +let WORKER_CLUSTER_ID_OVERRIDE = '' let eventSocket: net.Socket | null = null let eventSocketPath = EVENT_SOCKET_PATH let eventReconnectTimer: NodeJS.Timeout | null = null @@ -1169,12 +1239,31 @@ const handleSocketDisconnect = ( scheduleReconnect(socketType) } +const sendEventHello = (): boolean => { + if (!eventSocket || eventSocket.destroyed) return false + const payload = v8.serialize({ pid: process.pid }) + const header = Buffer.alloc(6) + header.writeUInt8(0, 0) + header.writeUInt8(0, 1) + header.writeUInt32BE(payload.length, 2) + try { + eventSocket.cork() + const okHeader = eventSocket.write(header) + const okPayload = eventSocket.write(payload) + eventSocket.uncork() + return okHeader && okPayload + } catch { + return false + } +} + const connectEventSocket = (): void => { if (!eventSocketPath) return const socket = net.createConnection(eventSocketPath, () => { eventSocket = socket clearReconnectTimer('event') + sendEventHello() logger('info', 'Worker', 'Connected to Master event socket') }) socket.on('error', () => { @@ -1522,8 +1611,8 @@ const nodelink: WorkerNodeLink = { } as unknown as WorkerNodeLink const createdVoiceRelay = createVoiceRelay({ - enabled: config.voiceReceive?.enabled, - format: config.voiceReceive?.format, + enabled: config.playback.voiceReceive?.enabled, + format: config.playback.voiceReceive?.format, sendFrame: (frame: Buffer) => sendEventBinaryFrame(8, frame), logger }) @@ -1565,13 +1654,13 @@ function startTimers(hibernating = false): void { const updateInterval = hibernating ? 60000 - : (config?.playerUpdateInterval ?? 5000) + : (config?.playback.playerUpdateInterval ?? 5000) const statsInterval = hibernating ? 120000 - : config?.metrics?.enabled + : config?.api.metrics?.enabled ? 5000 - : (config?.statsUpdateInterval ?? 30000) - const zombieThreshold = config?.zombieThresholdMs ?? 60000 + : (config?.playback.statsUpdateInterval ?? 30000) + const zombieThreshold = config?.playback.zombieThresholdMs ?? 60000 playerUpdateTimer = setInterval(() => { if (!process.connected) return @@ -1689,7 +1778,7 @@ function startTimers(hibernating = false): void { elapsedMs > 0 ? (cpuUsage.user + cpuUsage.system) / 1000 / elapsedMs : 0 const mem = process.memoryUsage() - const workerIdEnv = NODE_UNIQUE_ID + const resolvedClusterId = WORKER_CLUSTER_ID_OVERRIDE || WORKER_CLUSTER_ID const eluP50 = hndl.percentile(50) / 1e6 const eluP95 = hndl.percentile(95) / 1e6 const eluP99 = hndl.percentile(99) / 1e6 @@ -1705,7 +1794,7 @@ function startTimers(hibernating = false): void { } const stats = { - workerId: parseInt(workerIdEnv ?? '0', 10) + 1, + workerId: resolvedClusterId ? parseInt(resolvedClusterId, 10) : 0, isHibernating, players: localPlayers, playingPlayers: localPlayingPlayers, @@ -2404,6 +2493,12 @@ process.on('message', (msg: unknown) => { ipcMessageTracker.trackReceived(message.type, message) } + if (message.type === 'clusterId') { + WORKER_CLUSTER_ID_OVERRIDE = String( + (message as { clusterId?: number }).clusterId ?? '' + ) + return + } if (message.type === 'ping') { if (process.connected) { try { diff --git a/src/workers/source.ts b/src/workers/source.ts index 5541a91b..f810e056 100644 --- a/src/workers/source.ts +++ b/src/workers/source.ts @@ -17,7 +17,12 @@ import { import type PluginManager from '../managers/pluginManager.ts' import type { PluginManagerContext } from '../managers/pluginManager.ts' +import { migrateConfig } from '../modules/config/configMigration.ts' +import type { + JsonValue, + NodelinkConfig +} from '../typings/config/config.types.ts' import type { NodeLink } from '../typings/playback/player.types.ts' import type { FrameType, @@ -100,11 +105,65 @@ if (isMainThread) { * @internal */ async function loadConfig(): Promise> { - try { - return (await import(resolveRootConfigUrl('config.js'))).default - } catch { - return (await import(resolveRootConfigUrl('config.default.js'))).default + const resolveConfigExport = ( + importedModule: Record, + fileName: string + ): Record => { + const candidate = + ( + importedModule as { + default?: unknown + config?: unknown + } + ).default ?? + ( + importedModule as { + default?: unknown + config?: unknown + } + ).config + + if ( + candidate && + typeof candidate === 'object' && + Object.keys(candidate as Record).length > 0 + ) { + return candidate as Record + } + + throw new Error( + `[ERROR] Config: ${fileName} must export a non-empty configuration object (default export or named "config").` + ) } + + const candidates = [ + 'config.ts', + 'config.js', + 'config.default.ts', + 'config.default.js' + ] + for (const fileName of candidates) { + try { + const module = await import(resolveRootConfigUrl(fileName)) + const raw = resolveConfigExport( + module as Record, + fileName + ) + return migrateConfig(raw as Record) + } catch (error) { + const err = error as { code?: string; message?: string } + const isNotFound = + err.code === 'ERR_MODULE_NOT_FOUND' || + err.code === 'ENOENT' || + err.message?.includes('Cannot find module') + if (isNotFound) continue + throw error + } + } + + throw new Error( + '[ERROR] Config: Failed to load configuration (config.ts/config.js/config.default.ts/config.default.js).' + ) } const config = await loadConfig() @@ -120,7 +179,7 @@ if (isMainThread) { const nodelink: Pick = { - options: config, + options: config as unknown as NodelinkConfig, logger: utils.logger, pluginManager: null as unknown as PluginManager }