From 4cfd13db3c37f8126064c1c443db86871d023781 Mon Sep 17 00:00:00 2001 From: zeroz Date: Sat, 8 Aug 2026 01:08:28 -0400 Subject: [PATCH 01/11] initial debrid support main commit --- client/core/webtorrent.js | 24 ++- .../torrent/components/TorrentCard.svelte | 6 + .../torrent/components/TorrentResults.svelte | 20 +- common/modules/debrid/alldebrid.js | 29 +++ common/modules/debrid/debrid.js | 203 ++++++++++++++++++ common/modules/debrid/metadata.js | 149 +++++++++++++ common/modules/debrid/premiumize.js | 29 +++ common/modules/debrid/realdebrid.js | 162 ++++++++++++++ common/modules/debrid/route.js | 32 +++ common/modules/debrid/service.js | 161 ++++++++++++++ common/modules/debrid/torbox.js | 30 +++ common/modules/torrent.js | 2 + common/modules/util.js | 5 + common/package.json | 1 + common/routes/player/PlayerPage.svelte | 31 ++- common/routes/settings/SettingsPage.svelte | 14 +- common/routes/settings/tabs/AppTab.svelte | 2 +- common/routes/settings/tabs/DebridTab.svelte | 58 +++++ pnpm-lock.yaml | 17 +- 19 files changed, 955 insertions(+), 20 deletions(-) create mode 100644 common/modules/debrid/alldebrid.js create mode 100644 common/modules/debrid/debrid.js create mode 100644 common/modules/debrid/metadata.js create mode 100644 common/modules/debrid/premiumize.js create mode 100644 common/modules/debrid/realdebrid.js create mode 100644 common/modules/debrid/route.js create mode 100644 common/modules/debrid/service.js create mode 100644 common/modules/debrid/torbox.js create mode 100644 common/routes/settings/tabs/DebridTab.svelte diff --git a/client/core/webtorrent.js b/client/core/webtorrent.js index 07d10911..3ed6e240 100644 --- a/client/core/webtorrent.js +++ b/client/core/webtorrent.js @@ -491,6 +491,23 @@ export default class TorrentClient extends WebTorrent { break } case 'current': { if (data.data) { + if (data.data.current.debrid) { + // debrid streams play over HTTP and never join the client, just detach the previous torrent file + if (this.playerProcess) { + this.playerProcess.kill() + this.playerProcess = null + } + if (this.currentFile) { + this.currentFile.removeAllListeners('stream') + this.currentFile.removeAllListeners('iterator') + if (this.settings.torrentStreamedDownload && !this.currentFile._destroyed && this.currentFile.progress < 1) this.currentFile.deselect() + this.currentFile = null + } + this.metadata?.destroy?.() + this.metadata = null + if (data.data.external && (SUPPORTS.isAndroid || this.player)) this.dispatch('externalReady') + break + } const torrent = await this.get(data.data.current.infoHash) if (!torrent || torrent.destroyed) return const found = torrent.files.find(file => file.path === data.data.current.path) @@ -553,7 +570,8 @@ export default class TorrentClient extends WebTorrent { break } case 'externalPlay': { const startTime = Date.now() - const found = this.torrents.find(_torrent => _torrent.current)?.files?.find(file => file.path === data.data.current.path) + const current = data.data.current + const found = current?.debrid ? current : this.torrents.find(_torrent => _torrent.current)?.files?.find(file => file.path === current.path) if (!found) return this.ipc.removeAllListeners('external-close') if (this.playerProcess) { @@ -562,7 +580,7 @@ export default class TorrentClient extends WebTorrent { this.playerProcess = null } if (this.player) { - this.playerProcess = spawn(this.player, ['' + new URL('http://localhost:' + this.server.address().port + found.streamURL)]) + this.playerProcess = spawn(this.player, ['' + new URL(current?.debrid ? found.url : 'http://localhost:' + this.server.address().port + found.streamURL)]) this.playerProcess.stdout.on('data', () => {}) this.playerProcess.once('close', () => { if (this.destroyed) return @@ -570,7 +588,7 @@ export default class TorrentClient extends WebTorrent { const seconds = (Date.now() - startTime) / 1000 this.dispatch('externalWatched', seconds) }) - } else if (SUPPORTS.isAndroid) this.dispatch('androidExternal', `intent://localhost:${this.server.address().port}${found.streamURL}#Intent;type=video/any;scheme=http;end;`) + } else if (SUPPORTS.isAndroid) this.dispatch('androidExternal', current?.debrid ? `intent://${found.url.replace(/^https?:\/\//, '')}#Intent;type=video/any;scheme=${found.url.startsWith('https') ? 'https' : 'http'};end;` : `intent://localhost:${this.server.address().port}${found.streamURL}#Intent;type=video/any;scheme=http;end;`) break } case 'torrent': { const hash = data.data && data.data.hash diff --git a/common/modals/torrent/components/TorrentCard.svelte b/common/modals/torrent/components/TorrentCard.svelte index f25f7d6d..5a00b84c 100644 --- a/common/modals/torrent/components/TorrentCard.svelte +++ b/common/modals/torrent/components/TorrentCard.svelte @@ -6,6 +6,7 @@ import { getEpisodeMetadataForMedia, getKitsuMappings } from '@/modules/anime/anime.js' import { copyToClipboard } from '@/modules/lib/clipboard.js' import { malDubs } from '@/modules/anime/animedubs.js' + import { debridEnabled, debridCachedHashes } from '@/modules/debrid/debrid.js' import { settings } from '@/modules/settings.js' import { Database, BadgeCheck, HardDrive, FileQuestion, AlertCircle, TriangleAlert } from 'lucide-svelte' @@ -447,6 +448,11 @@
{since(new Date(result.date))}
+ {#if $debridEnabled && $debridCachedHashes.has(result.hash?.toLowerCase())} +
+ Debrid Cached +
+ {/if} {#if result.type === 'best'}
Best Release diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index 46a26837..f6c962a0 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -10,13 +10,14 @@ import { anitomyscript, getMediaMaxEp, getKitsuMappings, getEpisodeMetadataForMedia } from '@/modules/anime/anime.js' import { loadedTorrent, completedTorrents, seedingTorrents, stagingTorrents } from '@/modules/torrent.js' import { dedupe, getTorrentResults, updatePeerCounts } from '@/modules/extensions/handler.js' + import { debridEnabled, debridCachedHashes, debridServices, refreshDebridCache } from '@/modules/debrid/debrid.js' import { getId, getHash } from '@/modules/anime/animehash.js' import AnimeResolver from '@/modules/anime/animeresolver.js' import { anilistClient } from '@/modules/providers/anilist/anilist.js' import { click } from '@/modules/lib/click.js' import { toast } from 'svelte-sonner' import NestedDropdown from '@/components/overlays/NestedDropdown.svelte' - import { X, Search, EllipsisVertical, Timer, Clapperboard, MonitorCog, ArrowDownWideNarrow, Paintbrush, ListMusic, ChevronUp, ChevronDown, Radio, RefreshCw } from 'lucide-svelte' + import { X, Search, EllipsisVertical, Timer, Clapperboard, MonitorCog, ArrowDownWideNarrow, Paintbrush, ListMusic, ChevronUp, ChevronDown, Radio, RefreshCw, Cloud } from 'lucide-svelte' import Debug from 'debug' const debug = Debug('ui:torrents') @@ -86,15 +87,17 @@ * @param {Result[]} results * @param {string} sort * @param {boolean} batch + * @param {Set} [debridHashes] - Hashes that play instantly via debrid, listed even without seeders. */ - function sortResults(results, sort, batch) { + function sortResults(results, sort, batch, debridHashes) { if (!results) return { results: [], hiddenResults: [] } const deduped = Array.from(dedupe(results)).map(result => { if (!(result.parseObject?.release_group && result.parseObject.release_group.length < 20)) result.parseObject = { ...result.parseObject, release_group: 'No Group' } return result }) + const available = entry => entry.seeders > 0 || entry.source?.managed || debridHashes?.has(entry.hash?.toLowerCase()) return { - results: deduped.filter(entry => entry.seeders > 0 || entry.source?.managed).sort((a, b) => { + results: deduped.filter(available).sort((a, b) => { switch (sort) { case 'smallest': return a.size - b.size case 'best': return ((b.type === 'best') - (a.type === 'best') || (b.type === 'alt') - (a.type === 'alt')) || b.seeders - a.seeders @@ -108,7 +111,7 @@ default: return b.seeders - a.seeders } }), - hiddenResults: deduped.filter(entry => !entry.seeders && !entry.source?.managed) + hiddenResults: deduped.filter(entry => !available(entry)) } } @@ -247,6 +250,7 @@ async function queryExtensions(request, resolution) { scrollTop() + if ($debridEnabled) refreshDebridCache() $results = {} const cachedHashes = [] for (const resolvedHash of getHash(search?.media?.id, { episode: search?.episode, client: true, batchGuess: true }, false, true, true) ?? []) { @@ -329,7 +333,7 @@ $: resolution = $settings.rssQuality $: queries = queryExtensions({...search}, resolution) $: errors = getErrors({...search}, queries) - $: queryResults = sortResults($results?.torrents, $settings.torrentSort, batch) + $: queryResults = sortResults($results?.torrents, $settings.torrentSort, batch, $debridEnabled ? $debridCachedHashes : undefined) $: lookup = queryResults?.results $: (episodeSearch || resolution || $settings.torrentSort || $settings.audioLanguage) && scrollTop() @@ -476,6 +480,12 @@
+ {#if debridServices[$settings.debridService]} +
+ + {$settings.debridMode === 'only' ? 'Debrid Only' : 'Debrid First'} +
+ {/if}
diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js new file mode 100644 index 00000000..77d35f4f --- /dev/null +++ b/common/modules/debrid/alldebrid.js @@ -0,0 +1,29 @@ +// relative import keeps this module loadable under plain Node for API tests +import DebridService, { DebridError } from './service.js' + +/** + * AllDebrid stub, see https://docs.alldebrid.com/ + * Untested skeleton kept out of the settings menu until someone with an account + * implements and verifies it. The relevant endpoints are: + * - GET /user?apikey= -> account and premium status for validate() + * - GET /magnet/status?apikey= -> account magnets for listCachedHashes() + * - GET /magnet/upload?apikey=&magnets[]= -> add a magnet, `instant` flags cache state + * - GET /link/unlock?apikey=&link= -> direct stream URL per file + * Note: AllDebrid authenticates through a query parameter instead of a header. + */ +export default class AllDebrid extends DebridService { + static id = 'alldebrid' + static title = 'AllDebrid' + + async validate () { + throw new DebridError(`${AllDebrid.title} support is not implemented yet`) + } + + async listCachedHashes () { + throw new DebridError(`${AllDebrid.title} support is not implemented yet`) + } + + async resolve (magnet, opts) { + throw new DebridError(`${AllDebrid.title} support is not implemented yet`) + } +} diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js new file mode 100644 index 00000000..1a1adec3 --- /dev/null +++ b/common/modules/debrid/debrid.js @@ -0,0 +1,203 @@ +import { files } from '@/components/MediaHandler.svelte' +import { settings } from '@/modules/settings.js' +import { cache, caches } from '@/modules/cache.js' +import { status } from '@/modules/networking.js' +import { videoRx, subRx } from '@/modules/util.js' +import { anitomyscript } from '@/modules/anime/anime.js' +import { writable } from 'simple-store-svelte' +import { derived } from 'svelte/store' +import { toast } from 'svelte-sonner' +import RealDebrid from '@/modules/debrid/realdebrid.js' +import AllDebrid from '@/modules/debrid/alldebrid.js' +import TorBox from '@/modules/debrid/torbox.js' +import Premiumize from '@/modules/debrid/premiumize.js' +import { DebridNotCachedError } from '@/modules/debrid/service.js' +import { routeDebrid } from '@/modules/debrid/route.js' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +// register new services here, stubs stay hidden from the settings menu until +// their `available` flag is flipped after being implemented and tested +export const debridServices = Object.fromEntries([RealDebrid, AllDebrid, TorBox, Premiumize].filter(Service => Service.available).map(Service => [Service.id, Service])) + +const MAX_REMEMBERED = 300 + +// user facing messages for the routing policy's blocked outcomes +const blockedMessages = { + key: () => 'Debrid only mode is on but no API key is set. Add your key in the debrid settings or disable debrid only mode.', + offline: () => 'Shiru is currently offline, so ' + serviceTitle() + ' cannot be reached.', + source: () => 'This source only provides a torrent file which debrid cannot resolve yet. Pick a different release or disable debrid only mode.' +} + +/** @type {import('@/modules/debrid/service.js').default | null} */ +let service = null +let serviceKey = null + +/** Whether a debrid service is selected and has an API key. */ +export const debridEnabled = derived(settings, value => Boolean(debridServices[value.debridService] && value.debridApiKey)) + +/** Lowercase info hashes known to play instantly on the configured service. */ +export const debridCachedHashes = writable(new Set()) + +settings.subscribe(value => { + const key = `${value.debridService}:${value.debridApiKey}` + if (serviceKey !== null && serviceKey !== key) { + service?.destroy() + service = null + lastRefresh = 0 + debridCachedHashes.set(new Set()) + } + serviceKey = key +}) + +function getService () { + if (service) return service + const Service = debridServices[settings.value.debridService] + if (!Service || !settings.value.debridApiKey) return null + debug(`Initializing debrid service ${Service.title}`) + service = new Service(settings.value.debridApiKey) + return service +} + +/** Validates the configured service and API key, used by the settings test button. */ +export async function testDebrid () { + const service = getService() + if (!service) throw new Error('No debrid service configured') + if (status.value === 'offline') throw new Error(`Shiru is currently offline, so ${serviceTitle()} cannot be reached`) + return service.validate() +} + +/** + * Attempts to stream a torrent through the configured debrid service. + * Returns true when playback was handled, either with resolved files or a + * final error in debrid only mode. Returns false to fall back to torrents. + * The routing policy lives in route.js, debrid only never reaches the torrent client. + * @param {string} torrentID - Magnet URI, info hash, or .torrent link. + * @param {string} [hash] - Info hash when known. + * @param {{ episode?: number }} [search] - Playback context for picking the right file in packs. + */ +export async function streamDebrid (torrentID, hash, search) { + const debridOnly = Boolean(debridServices[settings.value.debridService]) && settings.value.debridMode === 'only' + const route = routeDebrid({ + torrentID, + hash, + serviceSelected: Boolean(debridServices[settings.value.debridService]), + serviceReady: Boolean(getService()), + offline: status.value === 'offline', + mode: settings.value.debridMode + }) + if (route.action === 'torrent') return false + if (route.action === 'block') { + toast.error('Debrid', { description: blockedMessages[route.reason]() }) + return true + } + try { + files.set(await resolveDebridFiles(route.id, search)) + return true + } catch (error) { + if (error instanceof DebridNotCachedError) { + debug(`Torrent not cached: ${error.message}`) + if (!debridOnly) { + toast('Debrid', { description: 'Not cached on ' + serviceTitle() + ', streaming via torrent instead.' }) + return false + } + toast.error('Debrid', { description: 'This torrent is not cached on ' + serviceTitle() + '. Pick a different release or disable debrid only mode.' }) + } else { + debug('Debrid resolve failed:', error) + if (!debridOnly) { + toast.warning('Debrid Error', { description: `${error.message || error}\nStreaming via torrent instead.` }) + return false + } + toast.error('Debrid Error', { description: '' + (error.message || error) }) + } + return true // handled, only mode never falls back to the torrent client + } +} + +/** + * Resolves a magnet to player ready file objects shaped like the torrent client's. + * @param {string} torrentID - Magnet URI or info hash. + * @param {{ episode?: number }} [search] + */ +export async function resolveDebridFiles (torrentID, search) { + const service = getService() + const episode = Number(search?.episode) + const resolved = await service.resolve(torrentID, { + fileFilter: name => videoRx.test(name) || subRx.test(name), + pickFile: Number.isFinite(episode) ? files => pickEpisodeFile(files, episode) : undefined + }) + rememberHash(resolved.hash) + return Promise.all(resolved.files.map(async file => ({ + infoHash: resolved.hash, + fileHash: await sha1hex(`${resolved.hash}:${file.name}:${file.size}`), // same key the torrent client uses, so watch progress is shared + torrent_name: resolved.name, + name: file.name, + type: file.type, + size: file.size, + path: file.path, + url: file.url, + debrid: true + }))) +} + +let lastRefresh = 0 +/** + * Updates the cached hash set from remembered resolves and, at most once a + * minute, the list of torrents already downloaded on the account. + */ +export function refreshDebridCache () { + const service = getService() + if (!service) return + const remembered = Object.keys(cache.getEntry(caches.GENERAL, 'debridResolvedHashes')?.[serviceId()] || {}) + if (remembered.length) debridCachedHashes.update(set => new Set([...set, ...remembered])) + if (Date.now() - lastRefresh < 60_000 || status.value === 'offline') return + lastRefresh = Date.now() + service.listCachedHashes().then(hashes => { + debridCachedHashes.update(set => new Set([...set, ...hashes])) + }).catch(error => { + lastRefresh = 0 + debug('Failed to list debrid torrents:', error) + }) +} + +/** + * Picks the file for the requested episode out of a pack using the same + * anitomy parsing the rest of the app relies on, largest file as fallback. + * @param {{ id: number, path: string, size: number }[]} files + * @param {number} episode + */ +async function pickEpisodeFile (files, episode) { + const videoFiles = files.filter(({ path }) => videoRx.test(path)) + if (videoFiles.length <= 1) return videoFiles[0] || files[0] + try { + const parsed = await anitomyscript(videoFiles.map(({ path }) => path.split('/').pop())) + const match = parsed?.findIndex(parse => Number(parse.episode_number) === episode) + if (match >= 0) return videoFiles[match] + } catch (error) { + debug('Failed to parse pack file names:', error) + } + return videoFiles.sort((a, b) => b.size - a.size)[0] +} + +function serviceId () { + return settings.value.debridService +} + +function serviceTitle () { + return debridServices[serviceId()]?.title || 'debrid' +} + +/** Remembers a successfully resolved hash per service so results can be badged instantly. */ +function rememberHash (hash) { + debridCachedHashes.update(set => new Set([...set, hash])) + cache.setEntry(caches.GENERAL, 'debridResolvedHashes', (current = {}) => { + const hashes = { ...(current[serviceId()] || {}), [hash]: Date.now() } + const pruned = Object.fromEntries(Object.entries(hashes).sort(([, a], [, b]) => b - a).slice(0, MAX_REMEMBERED)) + return { ...current, [serviceId()]: pruned } + }) +} + +async function sha1hex (data) { + const buffer = await crypto.subtle.digest('SHA-1', new TextEncoder().encode(data)) + return Array.from(new Uint8Array(buffer)).map(byte => byte.toString(16).padStart(2, '0')).join('') +} diff --git a/common/modules/debrid/metadata.js b/common/modules/debrid/metadata.js new file mode 100644 index 00000000..bd873b80 --- /dev/null +++ b/common/modules/debrid/metadata.js @@ -0,0 +1,149 @@ +import Metadata from 'matroska-metadata' +import { arr2hex, hex2bin } from 'uint8-util' +import { fontRx, subRx, sleep } from '@/modules/util.js' +import { SUPPORTS } from '@/modules/support.js' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +// stay this many seconds of video ahead of playback when streaming subtitles +const AHEAD_SECONDS = 120 +const RETRIES = 3 + +/** + * Blob-like wrapper around a remote URL so matroska-metadata can read it + * through HTTP range requests, mirroring how it reads torrent files. + */ +class RemoteFile { + /** + * @param {string} url + * @param {number} size + * @param {string} name + */ + constructor (url, size, name) { + this.url = url + this.size = size + this.name = name + this.controllers = new Set() + } + + /** @param {number} [start] @param {number} [end] */ + slice (start = 0, end) { + const { url, controllers } = this + const range = `bytes=${start}-${end ? end - 1 : ''}` + return { + stream () { + const controller = new AbortController() + controllers.add(controller) + return (async function * () { + try { + const res = await fetch(url, { headers: { Range: range }, signal: controller.signal }) + if (!res.ok && res.status !== 206) throw new Error(`Failed to fetch stream: ${res.status}`) + yield * res.body + } finally { + controllers.delete(controller) + controller.abort() + } + })() + } + } + } + + destroy () { + for (const controller of this.controllers) controller.abort() + this.controllers.clear() + } +} + +/** + * Extracts embedded tracks, fonts, chapters and subtitles from a debrid HTTP + * stream and feeds them into the same Subtitles pipeline torrents use. Unlike + * torrents the playback bytes can't be tapped, so subtitle events come from a + * second range request that is paced to stay just ahead of the play position. + */ +export default class DebridMetadata { + destroyed = false + + /** + * @param {any} file - The playing debrid file object. + * @param {any[]} files - All resolved files of the torrent, used to find external subtitles. + * @param {import('@/modules/subtitles.js').default} subtitles - Player subtitle instance to feed. + * @param {{ getTime?: () => number, onChapters?: (chapters: any[]) => void }} [opts] + */ + constructor (file, files, subtitles, { getTime = () => 0, onChapters } = {}) { + debug('Initializing debrid metadata parser for: ' + file?.name) + this.file = file + this.getTime = getTime + this.remote = new RemoteFile(file.url, file.size, file.name) + this.metadata = new Metadata(this.remote) + + this.metadata.getTracks().then(tracks => { + if (this.destroyed) return + debug(`Found ${tracks?.length} subtitle tracks`) + if (!tracks.length) return this.destroy() + subtitles.handleTracks(tracks) + this.#streamSubtitles() + }).catch(error => debug('Failed to read tracks:', error)) + + this.metadata.getChapters().then(chapters => { + if (this.destroyed || !chapters?.length) return + debug(`Found ${chapters.length} chapters`) + onChapters?.(chapters) + }).catch(error => debug('Failed to read chapters:', error)) + + this.metadata.getAttachments().then(attachments => { + if (this.destroyed) return + debug(`Found ${attachments?.length} attachments`) + for (const attachment of attachments) { + if (fontRx.test(attachment.filename) || attachment.mimetype?.toLowerCase().includes('font')) { + if (SUPPORTS.isAndroid && attachment.data.length > 15_000_000) continue // matches the torrent client's large font guard + subtitles.handleFile(hex2bin(arr2hex(attachment.data))) + } + } + }).catch(error => debug('Failed to read attachments:', error)) + + this.metadata.on('subtitle', (subtitle, trackNumber) => { + if (!this.destroyed) subtitles.handleSubtitle({ subtitle, trackNumber }) + }) + + // external subtitle files that were resolved alongside the video + for (const sub of (files || []).filter(({ name }) => subRx.test(name))) { + fetch(sub.url).then(res => res.arrayBuffer()).then(data => { + if (!this.destroyed) subtitles.handleSubtitleFile({ name: sub.name, data }) + }).catch(error => debug(`Failed to fetch subtitle file ${sub.name}:`, error)) + } + } + + /** Streams the file through the parser, throttled against the playback position. */ + async #streamSubtitles () { + const durationMs = await this.metadata.duration + const byteRate = durationMs > 0 ? this.file.size / (durationMs / 1_000) : 0 + for (let attempt = 0, offset = 0; attempt < RETRIES && !this.destroyed; ++attempt) { + try { + const stream = this.remote.slice(offset).stream() + for await (const chunk of this.metadata.parseStream(stream, offset === 0)) { + if (this.destroyed) return + offset += chunk.length + // wait for playback to catch up before buffering further, seeks resume instantly + while (!this.destroyed && byteRate && offset > (this.getTime() + AHEAD_SECONDS) * byteRate) await sleep(1_000) + } + return + } catch (error) { + if (this.destroyed) return + debug(`Subtitle stream interrupted at ${offset}, retrying:`, error) + await sleep(1_000 * (attempt + 1)) + } + } + } + + destroy () { + if (this.destroyed) return + debug('Destroying debrid metadata parser') + this.destroyed = true + this.metadata?.removeAllListeners() + this.metadata?.destroy() + this.remote?.destroy() + this.metadata = null + this.remote = null + this.file = null + } +} diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js new file mode 100644 index 00000000..25c9d5ce --- /dev/null +++ b/common/modules/debrid/premiumize.js @@ -0,0 +1,29 @@ +// relative import keeps this module loadable under plain Node for API tests +import DebridService, { DebridError } from './service.js' + +/** + * Premiumize stub, see https://www.premiumize.me/api + * Untested skeleton kept out of the settings menu until someone with an account + * implements and verifies it. The relevant endpoints are: + * - GET /account/info?apikey= -> account and premium status for validate() + * - GET /transfer/list?apikey= -> account transfers for listCachedHashes() + * - GET /cache/check?apikey=&items[]= -> Premiumize still offers a real cache check + * - POST /transfer/directdl?apikey=&src= -> direct stream URLs for a magnet in one call + * Note: Premiumize authenticates through a query parameter instead of a header. + */ +export default class Premiumize extends DebridService { + static id = 'premiumize' + static title = 'Premiumize' + + async validate () { + throw new DebridError(`${Premiumize.title} support is not implemented yet`) + } + + async listCachedHashes () { + throw new DebridError(`${Premiumize.title} support is not implemented yet`) + } + + async resolve (magnet, opts) { + throw new DebridError(`${Premiumize.title} support is not implemented yet`) + } +} diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js new file mode 100644 index 00000000..3df51494 --- /dev/null +++ b/common/modules/debrid/realdebrid.js @@ -0,0 +1,162 @@ +// relative import keeps this module loadable under plain Node for API tests +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError } from './service.js' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +const API = 'https://api.real-debrid.com/rest/1.0' +const hashRx = /urn:btih:([a-f\d]{40})/i +const archiveRx = /\.(rar|zip|7z)$/i +// statuses that mean the torrent will never complete +const deadStatuses = ['magnet_error', 'error', 'virus', 'dead'] + +/** + * Real-Debrid implementation, see https://api.real-debrid.com/ + * + * Two quirks discovered against the live API shape this client: + * - There is no instant availability endpoint anymore, cache state is only found + * out by adding a magnet: a cached torrent reports 'downloaded' right after file + * selection, anything queued for a fresh download is not cached and gets removed. + * - Selecting multiple files can serve a single RAR archive instead of individual + * links, so when that happens the torrent is re-added selecting only the target + * file, which always yields a direct streamable link. + */ +export default class RealDebrid extends DebridService { + static id = 'realdebrid' + static title = 'Real-Debrid' + static available = true + // documented allowance is 250 requests per minute, keep some headroom + static limits = { reservoir: 200, reservoirRefreshAmount: 200, reservoirRefreshInterval: 60_000, maxConcurrent: 4, minTime: 150 } + + mapError (status, json) { + // https://api.real-debrid.com/ error_code 8 = bad_token, 9 = permission_denied + if (json?.error_code === 8 || json?.error_code === 9 || status === 401 || status === 403) return new DebridAuthError(json?.error === 'bad_token' ? 'Invalid Real-Debrid API key' : (json?.error || 'Real-Debrid denied the request'), { status, code: json?.error_code }) + return super.mapError(status, json) + } + + async validate () { + const user = await this.request(`${API}/user`) + if (user?.type !== 'premium') throw new DebridAuthError('Real-Debrid premium is required to stream torrents') + return { username: user.username, expires: user.expiration } + } + + async listCachedHashes () { + const torrents = await this.request(`${API}/torrents?limit=100`) + return (torrents || []).filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) + } + + async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = 60 } = {}) { + const hash = (hashRx.exec(magnet)?.[1] || (/^[a-f\d]{40}$/i.test(magnet) ? magnet : '')).toLowerCase() + const magnetURI = magnet.startsWith('magnet:') ? magnet : `magnet:?xt=urn:btih:${hash}` + let torrentId = null + let added = false + try { + // reuse a torrent that is already on the account instead of adding a duplicate + const existing = hash && (await this.request(`${API}/torrents?limit=100`))?.find(torrent => torrent.hash.toLowerCase() === hash) + if (existing?.status === 'waiting_files_selection') { + // a stale add that never got its files selected, finish the job + const info = await this.request(`${API}/torrents/info/${existing.id}`) + const ids = info.files.filter(file => fileFilter(file.path)).map(file => file.id) + await this.request(`${API}/torrents/selectFiles/${existing.id}`, { method: 'POST', body: { files: ids.length ? ids.join(',') : 'all' } }) + torrentId = existing.id + } else if (existing && existing.status !== 'downloaded') throw new DebridNotCachedError() + else if (existing) torrentId = existing.id + else { + torrentId = await this.#addAndSelect(magnetURI, fileFilter) + added = true + } + let info = await this.#awaitStatus(torrentId, 'downloaded', 5_000) + let files = await this.#unrestrictLinks(info, fileFilter, maxFiles) + + // figure out which single file playback is really after, so archives and + // reused torrents that are missing it can be recovered from + const wanted = info.files.filter(file => fileFilter(file.path)).map(file => ({ id: file.id, path: file.path, size: file.bytes })) + const target = wanted.length ? (pickFile ? await pickFile(wanted) : wanted.sort((a, b) => b.size - a.size)[0]) : null + if (target && !files.some(file => file.name === target.path.split('/').pop())) { + debug(`Re-adding torrent to select only ${target.path}`) + const retryId = await this.#addAndSelect(magnetURI, null, target.id) + if (added) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + torrentId = retryId + added = true + info = await this.#awaitStatus(torrentId, 'downloaded', 5_000) + files = await this.#unrestrictLinks(info, fileFilter, 1) + if (!files.length) throw new DebridError('Real-Debrid only serves this torrent as an archive') + } + if (!files.length) throw new DebridError('No playable files in this torrent') + debug(`Resolved ${files.length} files for ${info.filename}`) + return { hash: info.hash.toLowerCase(), name: info.filename, files } + } catch (error) { + // only clean up torrents this call added, never the user's own downloads + if (added && torrentId) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + throw error + } + } + + /** + * Adds a magnet and selects either the files matching the filter or one specific file. + * @param {string} magnetURI + * @param {((name: string) => boolean) | null} fileFilter + * @param {number} [fileId] + * @returns {Promise} The new torrent id. + */ + async #addAndSelect (magnetURI, fileFilter, fileId) { + const torrentId = (await this.request(`${API}/torrents/addMagnet`, { method: 'POST', body: { magnet: magnetURI } }))?.id + try { + const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', 12_000) + if (info.status === 'waiting_files_selection') { + const ids = fileId ? [fileId] : info.files.filter(file => fileFilter(file.path)).map(file => file.id) + await this.request(`${API}/torrents/selectFiles/${torrentId}`, { method: 'POST', body: { files: ids.length ? ids.join(',') : 'all' } }) + } + return torrentId + } catch (error) { + if (torrentId) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + throw error + } + } + + /** + * Unrestricts a torrent's links into direct stream files. The cached copy may + * serve fewer links than the files selected: when the lists align filter by + * path up front, otherwise unrestrict and filter by the reported filename. + * RD-generated archives are dropped, the caller recovers via single file selection. + * @param {any} info + * @param {(name: string) => boolean} fileFilter + * @param {number} maxFiles + */ + async #unrestrictLinks (info, fileFilter, maxFiles) { + if (!info.links?.length) throw new DebridError('Real-Debrid returned no links for this torrent') + const selected = info.files.filter(file => file.selected) + const aligned = info.links.length === selected.length + const candidates = (aligned + ? selected.map((file, index) => ({ link: info.links[index], path: file.path, size: file.bytes })).filter(file => fileFilter(file.path)) + : info.links.map(link => ({ link }))).slice(0, maxFiles) + return (await Promise.all(candidates.map(async ({ link, path, size }) => { + const unrestricted = await this.request(`${API}/unrestrict/link`, { method: 'POST', body: { link } }) + const name = path?.split('/').pop() || unrestricted.filename + if (!path && !fileFilter(name)) return null + if (archiveRx.test(name) && !selected.some(file => file.path.endsWith(name))) return null // RD packed the selection into an archive + return { name, path: path || `/${name}`, size: unrestricted.filesize || size, url: unrestricted.download, type: unrestricted.mimeType } + }))).filter(Boolean) + } + + /** + * Polls torrent info until it reaches the wanted status. Anything queued for a + * fresh download means the torrent is not in the instant cache. + * @param {string} id + * @param {string} wanted + * @param {number} timeout + */ + async #awaitStatus (id, wanted, timeout) { + const started = Date.now() + while (true) { + const info = await this.request(`${API}/torrents/info/${id}`) + if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info + if (deadStatuses.includes(info.status)) throw new DebridError(`Real-Debrid could not process this torrent (${info.status})`) + if (['queued', 'downloading', 'uploading', 'compressing'].includes(info.status)) throw new DebridNotCachedError() + if (Date.now() - started > timeout) { + if (info.status === 'magnet_conversion') throw new DebridNotCachedError('Real-Debrid does not recognize this torrent') + throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) + } + await new Promise(resolve => setTimeout(resolve, 1_000).unref?.()) + } + } +} diff --git a/common/modules/debrid/route.js b/common/modules/debrid/route.js new file mode 100644 index 00000000..f3e81aa2 --- /dev/null +++ b/common/modules/debrid/route.js @@ -0,0 +1,32 @@ +// Pure playback routing policy, free of UI imports so it can be tested under +// plain Node. This is the single decision point for debrid vs torrent playback: +// debrid only mode must never route to the torrent client, whatever the input. + +const magnetRx = /^magnet:.*urn:btih:[a-f\d]{40}/i +const hexRx = /^[a-f\d]{40}$/i + +/** @param {any} torrentID */ +function usable (torrentID) { + return (typeof torrentID === 'string' && (magnetRx.test(torrentID) || hexRx.test(torrentID)) && torrentID) || null +} + +/** + * Decides how a play request should be handled. + * @param {Object} options + * @param {any} options.torrentID - Magnet URI, info hash, .torrent link, or torrent file bytes. + * @param {any} [options.hash] - Info hash when known, used when the link itself is not resolvable. + * @param {boolean} options.serviceSelected - A debrid service is selected in settings. + * @param {boolean} options.serviceReady - The service has an API key configured. + * @param {boolean} options.offline - The client has no network connection. + * @param {string} options.mode - The debridMode setting, 'prefer' or 'only'. + * @returns {{ action: 'torrent' } | { action: 'block', reason: 'key' | 'offline' | 'source' } | { action: 'resolve', id: string }} + */ +export function routeDebrid ({ torrentID, hash, serviceSelected, serviceReady, offline, mode }) { + if (!serviceSelected) return { action: 'torrent' } + const debridOnly = mode === 'only' + if (!serviceReady) return debridOnly ? { action: 'block', reason: 'key' } : { action: 'torrent' } + if (offline) return debridOnly ? { action: 'block', reason: 'offline' } : { action: 'torrent' } + const id = usable(torrentID) || usable(hash) + if (!id) return debridOnly ? { action: 'block', reason: 'source' } : { action: 'torrent' } + return { action: 'resolve', id } +} diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js new file mode 100644 index 00000000..86745b81 --- /dev/null +++ b/common/modules/debrid/service.js @@ -0,0 +1,161 @@ +import Bottleneck from 'bottleneck' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +// This module is intentionally free of UI imports so it can also run under plain Node for testing. + +export class DebridError extends Error { + /** + * @param {string} message + * @param {{ status?: number, code?: string | number }} [opts] + */ + constructor (message, { status, code } = {}) { + super(message) + this.name = 'DebridError' + this.status = status + this.code = code + } +} + +/** Thrown when the API key is missing, invalid or the account lacks the required plan. */ +export class DebridAuthError extends DebridError { + constructor (message, opts) { + super(message, opts) + this.name = 'DebridAuthError' + } +} + +/** Thrown when the service could not be reached at all, usually because the client is offline. */ +export class DebridNetworkError extends DebridError { + constructor (message, opts) { + super(message, opts) + this.name = 'DebridNetworkError' + } +} + +/** Thrown when a torrent is not present in the service's instant cache. */ +export class DebridNotCachedError extends DebridError { + constructor (message = 'Torrent is not cached on the debrid service', opts) { + super(message, opts) + this.name = 'DebridNotCachedError' + } +} + +/** + * @typedef {Object} DebridFile + * @property {string} name - File name without directories. + * @property {string} path - Path within the torrent, always starting with a slash. + * @property {number} size - File size in bytes. + * @property {string} url - Direct HTTPS stream URL. + * @property {string} [type] - MIME type when the service reports one. + */ + +/** + * @typedef {Object} DebridResolved + * @property {string} hash - Lowercase info hash. + * @property {string} name - Torrent name. + * @property {DebridFile[]} files - Streamable files, in torrent order. + */ + +/** + * Base class for debrid services, providing rate limited requests and typed errors. + * Implementations only talk HTTP, state is per-instance so services stay swappable. + * @abstract + */ +export default class DebridService { + /** @type {string} Unique lowercase identifier, e.g. 'realdebrid'. */ + static id = '' + /** @type {string} Human readable service name. */ + static title = '' + /** @type {boolean} Only implemented and tested services are offered in the settings menu. */ + static available = false + /** @type {import('bottleneck').ConstructorOptions} Request rate limits for the service API. */ + static limits = { maxConcurrent: 4, minTime: 250 } + + /** @param {string} apiKey */ + constructor (apiKey) { + this.apiKey = apiKey + this.rateLimitPromise = null + this.limiter = new Bottleneck(/** @type {typeof DebridService} */(this.constructor).limits) + this.limiter.on('failed', (error, jobInfo) => { + if (error instanceof DebridNetworkError) return // offline, retrying just delays the error + if (error instanceof DebridError && error.status === 429 && jobInfo.retryCount < 2) { + const time = (Number(error.retryAfter) || 5) * 1_000 + debug(`Rate limited by ${/** @type {typeof DebridService} */(this.constructor).title}, retrying in ${time}ms`) + if (!this.rateLimitPromise) this.rateLimitPromise = new Promise(resolve => setTimeout(resolve, time).unref?.()).then(() => { this.rateLimitPromise = null }) + return time + } + if (!(error instanceof DebridError) && jobInfo.retryCount < 1) return 3_000 // single retry for network hiccups + }) + this.request = this.limiter.wrap(this.#request.bind(this)) + } + + /** + * @param {string} url - Absolute request URL. + * @param {{ method?: string, body?: Record, timeout?: number }} [opts] - Body is sent form-encoded. + */ + async #request (url, { method = 'GET', body, timeout = 30_000 } = {}) { + await this.rateLimitPromise + if (!this.apiKey) throw new DebridAuthError('No debrid API key configured') + debug(`${method} ${url}`) + const res = await fetch(url, { + method, + headers: { Authorization: `Bearer ${this.apiKey}`, ...(body ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}) }, + body: body && new URLSearchParams(body).toString(), + signal: AbortSignal.timeout(timeout) + }) + // the app short-circuits external requests while it considers itself offline, + // handing back a plain object instead of a Response + if (typeof res?.json !== 'function') throw new DebridNetworkError(res?.message?.replace(/^failed to fetch: /i, '') || 'Network request failed') + if (!res?.ok) { + let json = null + try { json = await res.json() } catch {} + const error = this.mapError(res.status, json) + if (error.status === 429) error.retryAfter = res.headers?.get('retry-after') + throw error + } + if (res.status === 204) return null + return res.json().catch(() => null) // some endpoints return an empty body on success + } + + /** + * Maps an HTTP error response to a typed error, override for service specific codes. + * @param {number} status + * @param {any} json - Parsed error body, may be null. + * @returns {DebridError} + */ + mapError (status, json) { + const message = json?.error || json?.message || `Request failed with status ${status}` + if (status === 401 || status === 403) return new DebridAuthError(message, { status, code: json?.error_code }) + return new DebridError(message, { status, code: json?.error_code }) + } + + /** + * Verifies the API key and that the account can stream torrents. + * @abstract + * @returns {Promise<{ username: string, expires?: string }>} + */ + async validate () { throw new Error('Not implemented') } + + /** + * Lists info hashes that are already downloaded on the account, used for instant playback badges. + * @abstract + * @returns {Promise} Lowercase info hashes. + */ + async listCachedHashes () { throw new Error('Not implemented') } + + /** + * Resolves a magnet to direct stream URLs, throws DebridNotCachedError when the + * service would have to download the torrent first. + * @abstract + * @param {string} magnet - Magnet URI or bare info hash. + * @param {{ fileFilter?: (name: string) => boolean, maxFiles?: number }} [opts] + * @returns {Promise} + */ + async resolve (magnet, opts) { throw new Error('Not implemented') } + + /** Cancels queued requests, the instance must not be used afterwards. */ + destroy () { + this.limiter.stop({ dropWaitingJobs: true }).catch(() => {}) + } +} diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js new file mode 100644 index 00000000..918c238b --- /dev/null +++ b/common/modules/debrid/torbox.js @@ -0,0 +1,30 @@ +// relative import keeps this module loadable under plain Node for API tests +import DebridService, { DebridError } from './service.js' + +/** + * TorBox stub, see https://api-docs.torbox.app/ + * Untested skeleton kept out of the settings menu until someone with an account + * implements and verifies it. The relevant endpoints are: + * - GET /user/me -> account and plan for validate() + * - GET /torrents/mylist -> account torrents for listCachedHashes() + * - GET /torrents/checkcached?hash= -> TorBox still offers a real cache check + * - POST /torrents/createtorrent -> add a magnet + * - GET /torrents/requestdl?torrent_id=&file_id= -> direct stream URL per file + * Auth is a Bearer token like Real-Debrid, so the base request wrapper works as is. + */ +export default class TorBox extends DebridService { + static id = 'torbox' + static title = 'TorBox' + + async validate () { + throw new DebridError(`${TorBox.title} support is not implemented yet`) + } + + async listCachedHashes () { + throw new DebridError(`${TorBox.title} support is not implemented yet`) + } + + async resolve (magnet, opts) { + throw new DebridError(`${TorBox.title} support is not implemented yet`) + } +} diff --git a/common/modules/torrent.js b/common/modules/torrent.js index e05a7108..1c543ab8 100644 --- a/common/modules/torrent.js +++ b/common/modules/torrent.js @@ -8,6 +8,7 @@ import { writable } from 'simple-store-svelte' import { toast } from 'svelte-sonner' import { capitalize } from '@/modules/util.js' import clipboard from '@/modules/lib/clipboard.js' +import { streamDebrid } from '@/modules/debrid/debrid.js' import { setHash } from '@/modules/anime/animehash.js' import { TORRENT, ELECTRON } from '@/modules/bridge.js' import { get } from 'svelte/store' @@ -138,6 +139,7 @@ export async function add(torrentID, search, hash, magnet, base64 = false) { media.value = search ? { media: (search.media || media.value?.media), episode: (search.episode || media.value?.episode), ...(media.value?.torrent ? { torrent: true } : { feed: true }) } : { torrent: true } if (hash && search) setHash(hash, { mediaId: search.media?.id, episode: search.episode, client: true }) if (SUPPORTS.isAndroid && !settings.value.enableExternal) document.querySelector('.content-wrapper').requestFullscreen() // this WILL not work with auto-select torrents due to permissions check. + if (await streamDebrid(torrentID, hash, search)) return TORRENT.stream(torrentID, (hash === torrentID && torrentID) || false, magnet, base64) } } diff --git a/common/modules/util.js b/common/modules/util.js index 554db0fc..e3de9019 100644 --- a/common/modules/util.js +++ b/common/modules/util.js @@ -696,6 +696,9 @@ export const defaults = { showLabels: true, expandingSidebar: false, torrentPathNew: undefined, + debridService: 'none', + debridApiKey: '', + debridMode: 'prefer', donate: true, w2g: false, font: undefined, @@ -742,6 +745,7 @@ export const defaults = { * @property {any} [stagingTorrents] * @property {any} [seedingTorrents] * @property {any} [completedTorrents] + * @property {Record>} [debridResolvedHashes] * @property {string} posMiniplayer * @property {string} widthMiniplayer */ @@ -754,6 +758,7 @@ export const generalDefaults = { stagingTorrents: [], seedingTorrents: [], completedTorrents: [], + debridResolvedHashes: {}, posMiniplayer: 'bottom right', widthMiniplayer: '0px' } diff --git a/common/package.json b/common/package.json index 1e863539..1e9feafb 100644 --- a/common/package.json +++ b/common/package.json @@ -14,6 +14,7 @@ "js-levenshtein": "^1.1.6", "lucide-svelte": "0.455.0", "marked": "^18.0.9", + "matroska-metadata": "github:cedarpolar/matroska-metadata#b36dd003c41da5acd11c70144c13aef16a5603ee", "ms": "^2.1.3", "rvfc-polyfill": "^1.0.8", "p2pt": "github:ThaUnknown/p2pt#modernise", diff --git a/common/routes/player/PlayerPage.svelte b/common/routes/player/PlayerPage.svelte index 6647b7f6..e7ed6c6c 100644 --- a/common/routes/player/PlayerPage.svelte +++ b/common/routes/player/PlayerPage.svelte @@ -11,6 +11,7 @@ import { writable } from 'simple-store-svelte' import { createEventDispatcher } from 'svelte' import Subtitles from '@/modules/subtitles.js' + import DebridMetadata from '@/modules/debrid/metadata.js' import { toTS, fastPrettyBytes, capitalize, matchPhrase, videoRx, isValidNumber, debounce } from '@/modules/util.js' import { toast } from 'svelte-sonner' import { getChaptersAniSkip } from '@/modules/anime/anime.js' @@ -28,7 +29,7 @@ import 'rvfc-polyfill' import { ELECTRON, ANDROID, TORRENT } from '@/modules/bridge.js' import { unload } from '@/modules/torrent.js' - import { Settings, Gauge, Timer, X, Minus, ArrowDown, ArrowUp, Captions, CaptionsOff, CircleHelp, Contrast, FastForward, Keyboard, EllipsisVertical, SquareArrowOutUpRight, List, Eye, FilePlus2, ListMusic, ListVideo, Maximize, Minimize, Pause, PictureInPicture, PictureInPicture2, Play, Proportions, RefreshCcw, Rewind, RotateCcw, RotateCw, ScreenShare, SkipBack, SkipForward, Users, Volume1, Volume2, VolumeX, SlidersVertical, SquarePen, Milestone, ClockArrowDown, ClockArrowUp } from 'lucide-svelte' + import { Settings, Gauge, Timer, X, Minus, ArrowDown, ArrowUp, Captions, CaptionsOff, CircleHelp, Contrast, FastForward, Keyboard, EllipsisVertical, SquareArrowOutUpRight, List, Eye, FilePlus2, ListMusic, ListVideo, Maximize, Minimize, Pause, PictureInPicture, PictureInPicture2, Play, Proportions, RefreshCcw, Rewind, RotateCcw, RotateCw, ScreenShare, SkipBack, SkipForward, Users, Volume1, Volume2, VolumeX, SlidersVertical, SquarePen, Milestone, ClockArrowDown, ClockArrowUp, Cloud } from 'lucide-svelte' import Debug from 'debug' const debug = Debug('ui:player') @@ -67,6 +68,7 @@ let container = null let current = null let subs = null + let debridMeta = null let duration = 0.1 let muted = false let wasPaused = null @@ -226,6 +228,10 @@ subs.destroy() subs = null } + if (debridMeta) { + debridMeta.destroy() + debridMeta = null + } } } @@ -279,6 +285,10 @@ subs.destroy() subs = null } + if (debridMeta) { + debridMeta.destroy() + debridMeta = null + } current = file setCurrent(file) } @@ -290,6 +300,8 @@ src = file.url if (!launchExternal) { subs = new Subtitles(video, files, current, handleHeaders) + // debrid streams never pass through the torrent client, parse metadata from the remote file instead + if (current?.debrid) debridMeta = new DebridMetadata(current, files, subs, { getTime: () => currentTime, onChapters: _chapters => { chapters = _chapters; embeddedChapters = _chapters } }) video.load() await loadAnimeProgress() } else video.load() @@ -1731,12 +1743,17 @@
{/if}
- - {torrent.peers || 0} - - {fastPrettyBytes(torrent.down)}/s - - {fastPrettyBytes(torrent.up)}/s + {#if current?.debrid} + + Debrid + {:else} + + {torrent.peers || 0} + + {fastPrettyBytes(torrent.down)}/s + + {fastPrettyBytes(torrent.up)}/s + {/if} {#if resolvePrompt}
diff --git a/common/routes/settings/SettingsPage.svelte b/common/routes/settings/SettingsPage.svelte index 6ae53ace..fb3a4953 100644 --- a/common/routes/settings/SettingsPage.svelte +++ b/common/routes/settings/SettingsPage.svelte @@ -56,10 +56,11 @@ import AppTab from '@/routes/settings/tabs/AppTab.svelte' import ChangelogTab from '@/routes/settings/tabs/ChangelogTab.svelte' import ExtensionTab from '@/routes/settings/tabs/ExtensionTab.svelte' + import DebridTab from '@/routes/settings/tabs/DebridTab.svelte' import { status } from '@/modules/networking.js' import { modal } from '@/modules/navigation.js' import semver from 'semver' - import { AppWindow, Puzzle, User, Heart, Logs, Play, Rss, LayoutDashboard } from 'lucide-svelte' + import { AppWindow, Puzzle, User, Heart, Logs, Play, Rss, LayoutDashboard, Cloud } from 'lucide-svelte' export let statusTransition = false @@ -80,6 +81,10 @@ name: 'Extensions', icon: Puzzle }, + debrid: { + name: 'Debrid', + icon: Cloud + }, login: { name: 'Profiles', icon: User, @@ -155,6 +160,13 @@
+ +
+
+ +
+
+
diff --git a/common/routes/settings/tabs/AppTab.svelte b/common/routes/settings/tabs/AppTab.svelte index 62c854b8..ed661c72 100644 --- a/common/routes/settings/tabs/AppTab.svelte +++ b/common/routes/settings/tabs/AppTab.svelte @@ -182,7 +182,7 @@
- + resetSettings()} class='btn btn-danger mt-5 d-flex align-items-center justify-content-center' confirmText='Confirm Reset' confirmClass='btn-danger-dim long-button' cancelClass='btn-secondary long-button' actionClass='d-inline-flex d-md-block' dataToggle='tooltip' dataPlacement='top' dataTitle='Restores All Settings Back To Their Recommended Defaults'> Reset to Defaults diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte new file mode 100644 index 00000000..4aae7902 --- /dev/null +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -0,0 +1,58 @@ + + +

Debrid Settings

+ + + +{#if settings.debridService !== 'none'} + +
+ { settings.debridApiKey = event.target.value.trim() }} + on:keydown|stopPropagation + /> +
+ + +
+
+ + + + +{/if} diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index dcfa072e..be947302 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -237,6 +237,9 @@ importers: marked: specifier: ^18.0.9 version: 18.0.9 + matroska-metadata: + specifier: github:cedarpolar/matroska-metadata#b36dd003c41da5acd11c70144c13aef16a5603ee + version: https://codeload.github.com/cedarpolar/matroska-metadata/tar.gz/b36dd003c41da5acd11c70144c13aef16a5603ee ms: specifier: ^2.1.3 version: 2.1.3 @@ -1968,10 +1971,12 @@ packages: conventional-changelog-atom@2.0.8: resolution: {integrity: sha512-xo6v46icsFTK3bb7dY/8m2qvc8sZemRgdqLb/bjpBsH2UyOS8rKNTgcb5025Hri6IpANPApbXMg15QLb1LJpBw==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-codemirror@2.0.8: resolution: {integrity: sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-conventionalcommits@4.6.3: resolution: {integrity: sha512-LTTQV4fwOM4oLPad317V/QNQ1FY4Hju5qeBIM1uTHbrnCE+Eg4CdRZ3gO2pUeR+tzWdp80M2j3qFFEDWVqOV4g==} @@ -1980,26 +1985,32 @@ packages: conventional-changelog-core@4.2.4: resolution: {integrity: sha512-gDVS+zVJHE2v4SLc6B0sLsPiloR0ygU7HaDW14aNJE1v4SlqJPILPl/aJC7YdtRE4CybBf8gDwObBvKha8Xlyg==} engines: {node: '>=10'} + deprecated: Deprecated and no longer maintained. Please use conventional-changelog instead. conventional-changelog-ember@2.0.9: resolution: {integrity: sha512-ulzIReoZEvZCBDhcNYfDIsLTHzYHc7awh+eI44ZtV5cx6LVxLlVtEmcO+2/kGIHGtw+qVabJYjdI5cJOQgXh1A==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-eslint@3.0.9: resolution: {integrity: sha512-6NpUCMgU8qmWmyAMSZO5NrRd7rTgErjrm4VASam2u5jrZS0n38V7Y9CzTtLT2qwz5xEChDR4BduoWIr8TfwvXA==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-express@2.0.6: resolution: {integrity: sha512-SDez2f3iVJw6V563O3pRtNwXtQaSmEfTCaTBPCqn0oG0mfkq0rX4hHBq5P7De2MncoRixrALj3u3oQsNK+Q0pQ==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-jquery@3.0.11: resolution: {integrity: sha512-x8AWz5/Td55F7+o/9LQ6cQIPwrCjfJQ5Zmfqi8thwUEKHstEn4kTIofXub7plf1xvFA2TqhZlq7fy5OmV6BOMw==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-jshint@2.0.9: resolution: {integrity: sha512-wMLdaIzq6TNnMHMy31hql02OEQ8nCQfExw1SE0hYL5KvU+JCTuPaDO+7JiogGT2gJAxiUGATdtYYfh+nT+6riA==} engines: {node: '>=10'} + deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-preset-loader@2.3.4: resolution: {integrity: sha512-GEKRWkrSAZeTq5+YjUZOYxdHq+ci4dNwHvpaBC3+ENalzFWuCWa9EZXSuZBpkr72sMdKB+1fyDV4takK1Lf58g==} @@ -2333,7 +2344,7 @@ packages: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} ebml-iterator@https://codeload.github.com/cedarpolar/ebml-iterator/tar.gz/10bd04f977cdd747c7cc41135cf04f8b91fb024d: - resolution: {gitHosted: true, tarball: https://codeload.github.com/cedarpolar/ebml-iterator/tar.gz/10bd04f977cdd747c7cc41135cf04f8b91fb024d} + resolution: {gitHosted: true, integrity: sha512-fogU5IZc6+Hay7Hg0XNIsrby9sRsAWC0cUTBc2rNVAawu7OMHNa2cAvAZS7k2O+BTrUF+mP7HCYjcz86kqH0Mw==, tarball: https://codeload.github.com/cedarpolar/ebml-iterator/tar.gz/10bd04f977cdd747c7cc41135cf04f8b91fb024d} version: 1.0.5 ee-first@1.1.1: @@ -2899,7 +2910,7 @@ packages: git-raw-commits@2.0.11: resolution: {integrity: sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==} engines: {node: '>=10'} - deprecated: This package is no longer maintained. For the JavaScript API, please use @conventional-changelog/git-client instead. + deprecated: Deprecated and no longer maintained. Use @conventional-changelog/git-client instead. hasBin: true git-remote-origin-url@2.0.0: @@ -2909,7 +2920,7 @@ packages: git-semver-tags@4.1.1: resolution: {integrity: sha512-OWyMt5zBe7xFs8vglMmhM9lRQzCWL3WjHtxNNfJTMngGym7pC1kh8sP6jevfydJ6LP3ZvGxfb6ABYgPUM0mtsA==} engines: {node: '>=10'} - deprecated: This package is no longer maintained. For the JavaScript API, please use @conventional-changelog/git-client instead. + deprecated: Deprecated and no longer maintained. Use @conventional-changelog/git-client instead. hasBin: true gitconfiglocal@1.0.0: From 0d71678c7fa254aa181518cc961a922e00a9462d Mon Sep 17 00:00:00 2001 From: zeroz Date: Sat, 8 Aug 2026 07:18:24 -0400 Subject: [PATCH 02/11] better interface debrid handling, unit testing service routes with debrid and subtitles. Fixes from pr comments --- client/core/webtorrent.js | 18 +- .../torrent/components/TorrentCard.svelte | 9 +- .../torrent/components/TorrentResults.svelte | 8 +- common/modules/debrid/alldebrid.js | 33 ++-- common/modules/debrid/debrid.js | 48 +++-- common/modules/debrid/metadata.js | 47 +++-- common/modules/debrid/premiumize.js | 33 ++-- common/modules/debrid/realdebrid.js | 59 +++--- common/modules/debrid/route.js | 17 +- common/modules/debrid/service.js | 169 ++++++++++++++++-- common/modules/debrid/torbox.js | 36 ++-- common/modules/util.js | 20 +++ common/routes/player/PlayerPage.svelte | 7 +- common/routes/settings/tabs/DebridTab.svelte | 4 +- 14 files changed, 357 insertions(+), 151 deletions(-) diff --git a/client/core/webtorrent.js b/client/core/webtorrent.js index 3ed6e240..c331faa6 100644 --- a/client/core/webtorrent.js +++ b/client/core/webtorrent.js @@ -3,7 +3,7 @@ import HTTPTracker from 'http-tracker' import Client from 'bittorrent-tracker' import { hex2bin, arr2hex, text2arr } from 'uint8-util' import { makeHash, getInfoHash, hasIntegrity, getProgressAndSize, stringifyQuery, errorToString, TMP } from '@client/lib/util.js' -import { fontRx, sleep, subRx, videoRx, isValidNumber } from '@/modules/util.js' +import { fontRx, sleep, matchSubtitleFiles, isValidNumber } from '@/modules/util.js' import { SUPPORTS } from '@/modules/support.js' import { spawn } from 'node:child_process' import Metadata from '@client/lib/metadata.js' @@ -229,10 +229,8 @@ export default class TorrentClient extends WebTorrent { async findSubtitleFiles(targetFile) { const currentTorrent = this.torrents.find(torrent => torrent.current) if (!currentTorrent?.files) return - const videoFiles = currentTorrent.files.filter(file => videoRx.test(file.name)) - const videoName = targetFile.name.substring(0, targetFile.name.lastIndexOf('.')) || targetFile.name - // array of subtitle files that match video name, or all subtitle files when only 1 vid file - const subfiles = currentTorrent.files.filter(file => subRx.test(file.name) && (videoFiles.length === 1 ? true : file.name.includes(videoName))) + // shared with debrid playback so both lanes match subtitles to the video the same way + const subfiles = matchSubtitleFiles(currentTorrent.files, targetFile.name) debug(`Found ${subfiles?.length} subtitle files`) for (const file of subfiles) { const data = await file.arrayBuffer() @@ -492,7 +490,8 @@ export default class TorrentClient extends WebTorrent { } case 'current': { if (data.data) { if (data.data.current.debrid) { - // debrid streams play over HTTP and never join the client, just detach the previous torrent file + // debrid files stream straight from the service over HTTPS and never join the + // torrent client, so there is nothing to attach, only the previous playback to release if (this.playerProcess) { this.playerProcess.kill() this.playerProcess = null @@ -505,6 +504,13 @@ export default class TorrentClient extends WebTorrent { } this.metadata?.destroy?.() this.metadata = null + // nothing is playing from the client anymore, so stop reporting the old torrent + // as current or its peers and speeds keep flowing to the player and torrent manager + const lastTorrent = this.torrents.find(_torrent => _torrent.current) + if (lastTorrent) { + lastTorrent.current = false + this.bumpTorrent(lastTorrent) + } if (data.data.external && (SUPPORTS.isAndroid || this.player)) this.dispatch('externalReady') break } diff --git a/common/modals/torrent/components/TorrentCard.svelte b/common/modals/torrent/components/TorrentCard.svelte index 5a00b84c..9edd2ac3 100644 --- a/common/modals/torrent/components/TorrentCard.svelte +++ b/common/modals/torrent/components/TorrentCard.svelte @@ -6,9 +6,9 @@ import { getEpisodeMetadataForMedia, getKitsuMappings } from '@/modules/anime/anime.js' import { copyToClipboard } from '@/modules/lib/clipboard.js' import { malDubs } from '@/modules/anime/animedubs.js' - import { debridEnabled, debridCachedHashes } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridCachedHashes, debridTransport } from '@/modules/debrid/debrid.js' import { settings } from '@/modules/settings.js' - import { Database, BadgeCheck, HardDrive, FileQuestion, AlertCircle, TriangleAlert } from 'lucide-svelte' + import { Database, BadgeCheck, HardDrive, FileQuestion, AlertCircle, TriangleAlert, Cloud } from 'lucide-svelte' const { reactive, init } = createListener(['torrent-button', 'torrent-safe-area']) init(true) @@ -449,8 +449,9 @@
{#if $debridEnabled && $debridCachedHashes.has(result.hash?.toLowerCase())} -
- Debrid Cached +
+ + Debrid
{/if} {#if result.type === 'best'} diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index f6c962a0..fad9b450 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -10,7 +10,7 @@ import { anitomyscript, getMediaMaxEp, getKitsuMappings, getEpisodeMetadataForMedia } from '@/modules/anime/anime.js' import { loadedTorrent, completedTorrents, seedingTorrents, stagingTorrents } from '@/modules/torrent.js' import { dedupe, getTorrentResults, updatePeerCounts } from '@/modules/extensions/handler.js' - import { debridEnabled, debridCachedHashes, debridServices, refreshDebridCache } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridCachedHashes, debridTransport, refreshDebridCache } from '@/modules/debrid/debrid.js' import { getId, getHash } from '@/modules/anime/animehash.js' import AnimeResolver from '@/modules/anime/animeresolver.js' import { anilistClient } from '@/modules/providers/anilist/anilist.js' @@ -480,10 +480,10 @@
- {#if debridServices[$settings.debridService]} -
+ {#if $debridTransport} +
- {$settings.debridMode === 'only' ? 'Debrid Only' : 'Debrid First'} + {$debridTransport.label}
{/if}
diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js index 77d35f4f..82b08479 100644 --- a/common/modules/debrid/alldebrid.js +++ b/common/modules/debrid/alldebrid.js @@ -1,29 +1,20 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService, { DebridError } from './service.js' +import DebridService from './service.js' /** - * AllDebrid stub, see https://docs.alldebrid.com/ - * Untested skeleton kept out of the settings menu until someone with an account - * implements and verifies it. The relevant endpoints are: - * - GET /user?apikey= -> account and premium status for validate() - * - GET /magnet/status?apikey= -> account magnets for listCachedHashes() - * - GET /magnet/upload?apikey=&magnets[]= -> add a magnet, `instant` flags cache state - * - GET /link/unlock?apikey=&link= -> direct stream URL per file - * Note: AllDebrid authenticates through a query parameter instead of a header. + * AllDebrid template, see https://docs.alldebrid.com/ + * + * Implementation template: the base class already provides authentication, rate + * limiting, typed errors and clear not-implemented reporting, so adding support + * means writing `validate`, `listCachedHashes` and `resolve` here and flipping + * `available` to true. Nothing outside this file has to change. Useful endpoints: + * - GET /user -> account and premium status for validate() + * - GET /magnet/status -> account magnets for listCachedHashes() + * - GET /magnet/upload -> add a magnet (`magnets[]=`), the `instant` flag reports cache state + * - GET /link/unlock -> direct stream URL per file (`link=`) */ export default class AllDebrid extends DebridService { static id = 'alldebrid' static title = 'AllDebrid' - - async validate () { - throw new DebridError(`${AllDebrid.title} support is not implemented yet`) - } - - async listCachedHashes () { - throw new DebridError(`${AllDebrid.title} support is not implemented yet`) - } - - async resolve (magnet, opts) { - throw new DebridError(`${AllDebrid.title} support is not implemented yet`) - } + static auth = 'query' } diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index 1a1adec3..b2a6c73a 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -11,16 +11,22 @@ import RealDebrid from '@/modules/debrid/realdebrid.js' import AllDebrid from '@/modules/debrid/alldebrid.js' import TorBox from '@/modules/debrid/torbox.js' import Premiumize from '@/modules/debrid/premiumize.js' -import { DebridNotCachedError } from '@/modules/debrid/service.js' +import { DebridNotCachedError, secureFiles } from '@/modules/debrid/service.js' import { routeDebrid } from '@/modules/debrid/route.js' import Debug from 'debug' const debug = Debug('ui:debrid') -// register new services here, stubs stay hidden from the settings menu until -// their `available` flag is flipped after being implemented and tested -export const debridServices = Object.fromEntries([RealDebrid, AllDebrid, TorBox, Premiumize].filter(Service => Service.available).map(Service => [Service.id, Service])) +// register new services here, implementation templates stay hidden from the settings +// menu until their `available` flag is flipped after being implemented and tested. +// This registry is the only place that touches service classes, everything else in +// the app goes through the stores and functions exported below. +const debridServices = Object.fromEntries([RealDebrid, AllDebrid, TorBox, Premiumize].filter(Service => Service.available).map(Service => [Service.id, Service])) + +/** Selectable services for the settings menu, as plain data. */ +export const debridOptions = Object.values(debridServices).map(Service => ({ id: Service.id, title: Service.title })) const MAX_REMEMBERED = 300 +const REFRESH_INTERVAL = 60_000 // user facing messages for the routing policy's blocked outcomes const blockedMessages = { @@ -32,10 +38,29 @@ const blockedMessages = { /** @type {import('@/modules/debrid/service.js').default | null} */ let service = null let serviceKey = null +let lastRefresh = 0 /** Whether a debrid service is selected and has an API key. */ export const debridEnabled = derived(settings, value => Boolean(debridServices[value.debridService] && value.debridApiKey)) +/** + * How playback is routed right now, or null when no debrid service is selected. + * The single source the UI reads to describe the active transport. + */ +export const debridTransport = derived(settings, value => { + const Service = debridServices[value.debridService] + if (!Service) return null + const only = value.debridMode === 'only' + return { + title: Service.title, + only, + label: only ? 'Debrid Only' : 'Debrid First', + description: only + ? `Debrid Only: playback always uses ${Service.title}, torrents never start.` + : `Debrid First: releases cached on ${Service.title} stream from it, anything uncached falls back to torrents.` + } +}) + /** Lowercase info hashes known to play instantly on the configured service. */ export const debridCachedHashes = writable(new Set()) @@ -77,16 +102,18 @@ export async function testDebrid () { * @param {{ episode?: number }} [search] - Playback context for picking the right file in packs. */ export async function streamDebrid (torrentID, hash, search) { - const debridOnly = Boolean(debridServices[settings.value.debridService]) && settings.value.debridMode === 'only' + const serviceSelected = Boolean(debridServices[settings.value.debridService]) const route = routeDebrid({ torrentID, hash, - serviceSelected: Boolean(debridServices[settings.value.debridService]), - serviceReady: Boolean(getService()), + serviceSelected, + // only build the service once the selection alone cannot decide the outcome + serviceReady: serviceSelected && Boolean(getService()), offline: status.value === 'offline', mode: settings.value.debridMode }) if (route.action === 'torrent') return false + const debridOnly = route.only if (route.action === 'block') { toast.error('Debrid', { description: blockedMessages[route.reason]() }) return true @@ -126,8 +153,10 @@ export async function resolveDebridFiles (torrentID, search) { fileFilter: name => videoRx.test(name) || subRx.test(name), pickFile: Number.isFinite(episode) ? files => pickEpisodeFile(files, episode) : undefined }) + const files = secureFiles(resolved.files, serviceTitle()) + if (files.length !== resolved.files.length) debug(`Discarded ${resolved.files.length - files.length} non-HTTPS links from ${serviceTitle()}`) rememberHash(resolved.hash) - return Promise.all(resolved.files.map(async file => ({ + return Promise.all(files.map(async file => ({ infoHash: resolved.hash, fileHash: await sha1hex(`${resolved.hash}:${file.name}:${file.size}`), // same key the torrent client uses, so watch progress is shared torrent_name: resolved.name, @@ -140,7 +169,6 @@ export async function resolveDebridFiles (torrentID, search) { }))) } -let lastRefresh = 0 /** * Updates the cached hash set from remembered resolves and, at most once a * minute, the list of torrents already downloaded on the account. @@ -150,7 +178,7 @@ export function refreshDebridCache () { if (!service) return const remembered = Object.keys(cache.getEntry(caches.GENERAL, 'debridResolvedHashes')?.[serviceId()] || {}) if (remembered.length) debridCachedHashes.update(set => new Set([...set, ...remembered])) - if (Date.now() - lastRefresh < 60_000 || status.value === 'offline') return + if (Date.now() - lastRefresh < REFRESH_INTERVAL || status.value === 'offline') return lastRefresh = Date.now() service.listCachedHashes().then(hashes => { debridCachedHashes.update(set => new Set([...set, ...hashes])) diff --git a/common/modules/debrid/metadata.js b/common/modules/debrid/metadata.js index bd873b80..334c279e 100644 --- a/common/modules/debrid/metadata.js +++ b/common/modules/debrid/metadata.js @@ -1,6 +1,6 @@ import Metadata from 'matroska-metadata' import { arr2hex, hex2bin } from 'uint8-util' -import { fontRx, subRx, sleep } from '@/modules/util.js' +import { fontRx, matroskaRx, matchSubtitleFiles, sleep } from '@/modules/util.js' import { SUPPORTS } from '@/modules/support.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -39,6 +39,10 @@ class RemoteFile { const res = await fetch(url, { headers: { Range: range }, signal: controller.signal }) if (!res.ok && res.status !== 206) throw new Error(`Failed to fetch stream: ${res.status}`) yield * res.body + } catch (error) { + // the only thing that aborts these is our own teardown, so end the stream + // quietly rather than surfacing a failure nobody can act on + if (error?.name !== 'AbortError') throw error } finally { controllers.delete(controller) controller.abort() @@ -62,6 +66,10 @@ class RemoteFile { */ export default class DebridMetadata { destroyed = false + /** @type {RemoteFile | null} */ + remote = null + /** @type {Metadata | null} */ + metadata = null /** * @param {any} file - The playing debrid file object. @@ -73,13 +81,28 @@ export default class DebridMetadata { debug('Initializing debrid metadata parser for: ' + file?.name) this.file = file this.getTime = getTime + + // external subtitle files that were resolved alongside the video, matched to it + // exactly like the torrent client does so season packs load one episode's subs + for (const sub of matchSubtitleFiles(files, file.name)) { + fetch(sub.url).then(res => res.arrayBuffer()).then(data => { + if (!this.destroyed) subtitles.handleSubtitleFile({ name: sub.name, data }) + }).catch(error => debug(`Failed to fetch subtitle file ${sub.name}:`, error)) + } + + // everything below reads the Matroska container, which only these formats have + if (!matroskaRx.test(file.name)) { + debug('Not a Matroska container, skipping embedded metadata: ' + file.name) + return + } this.remote = new RemoteFile(file.url, file.size, file.name) this.metadata = new Metadata(this.remote) this.metadata.getTracks().then(tracks => { if (this.destroyed) return debug(`Found ${tracks?.length} subtitle tracks`) - if (!tracks.length) return this.destroy() + // nothing embedded to stream, drop the parser but stay alive for external subtitle files + if (!tracks.length) return this.#releaseParser() subtitles.handleTracks(tracks) this.#streamSubtitles() }).catch(error => debug('Failed to read tracks:', error)) @@ -104,13 +127,6 @@ export default class DebridMetadata { this.metadata.on('subtitle', (subtitle, trackNumber) => { if (!this.destroyed) subtitles.handleSubtitle({ subtitle, trackNumber }) }) - - // external subtitle files that were resolved alongside the video - for (const sub of (files || []).filter(({ name }) => subRx.test(name))) { - fetch(sub.url).then(res => res.arrayBuffer()).then(data => { - if (!this.destroyed) subtitles.handleSubtitleFile({ name: sub.name, data }) - }).catch(error => debug(`Failed to fetch subtitle file ${sub.name}:`, error)) - } } /** Streams the file through the parser, throttled against the playback position. */ @@ -135,15 +151,20 @@ export default class DebridMetadata { } } - destroy () { - if (this.destroyed) return - debug('Destroying debrid metadata parser') - this.destroyed = true + /** Releases the container parser and its range requests, leaving external subtitles alone. */ + #releaseParser () { this.metadata?.removeAllListeners() this.metadata?.destroy() this.remote?.destroy() this.metadata = null this.remote = null + } + + destroy () { + if (this.destroyed) return + debug('Destroying debrid metadata parser') + this.destroyed = true + this.#releaseParser() this.file = null } } diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js index 25c9d5ce..df182472 100644 --- a/common/modules/debrid/premiumize.js +++ b/common/modules/debrid/premiumize.js @@ -1,29 +1,20 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService, { DebridError } from './service.js' +import DebridService from './service.js' /** - * Premiumize stub, see https://www.premiumize.me/api - * Untested skeleton kept out of the settings menu until someone with an account - * implements and verifies it. The relevant endpoints are: - * - GET /account/info?apikey= -> account and premium status for validate() - * - GET /transfer/list?apikey= -> account transfers for listCachedHashes() - * - GET /cache/check?apikey=&items[]= -> Premiumize still offers a real cache check - * - POST /transfer/directdl?apikey=&src= -> direct stream URLs for a magnet in one call - * Note: Premiumize authenticates through a query parameter instead of a header. + * Premiumize template, see https://www.premiumize.me/api + * + * Implementation template: the base class already provides authentication, rate + * limiting, typed errors and clear not-implemented reporting, so adding support + * means writing `validate`, `listCachedHashes` and `resolve` here and flipping + * `available` to true. Nothing outside this file has to change. Useful endpoints: + * - GET /account/info -> account and premium status for validate() + * - GET /transfer/list -> account transfers for listCachedHashes() + * - GET /cache/check -> Premiumize still offers a real cache check (`items[]=`) + * - POST /transfer/directdl -> direct stream URLs for a magnet in one call (`src=`) */ export default class Premiumize extends DebridService { static id = 'premiumize' static title = 'Premiumize' - - async validate () { - throw new DebridError(`${Premiumize.title} support is not implemented yet`) - } - - async listCachedHashes () { - throw new DebridError(`${Premiumize.title} support is not implemented yet`) - } - - async resolve (magnet, opts) { - throw new DebridError(`${Premiumize.title} support is not implemented yet`) - } + static auth = 'query' } diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index 3df51494..2c44d910 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -1,13 +1,15 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService, { DebridError, DebridAuthError, DebridNotCachedError } from './service.js' +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, archiveRx } from './service.js' import Debug from 'debug' const debug = Debug('ui:debrid') const API = 'https://api.real-debrid.com/rest/1.0' -const hashRx = /urn:btih:([a-f\d]{40})/i -const archiveRx = /\.(rar|zip|7z)$/i +// how much of the account's torrent history to read for reuse and cache badges +const LIST_LIMIT = 100 // statuses that mean the torrent will never complete const deadStatuses = ['magnet_error', 'error', 'virus', 'dead'] +// statuses that mean the torrent is being fetched fresh, so it was never cached +const downloadingStatuses = ['queued', 'downloading', 'uploading', 'compressing'] /** * Real-Debrid implementation, see https://api.real-debrid.com/ @@ -39,19 +41,24 @@ export default class RealDebrid extends DebridService { return { username: user.username, expires: user.expiration } } + /** The account's recent torrents, the one list both cache badges and torrent reuse read from. */ + async #accountTorrents () { + return (await this.request(`${API}/torrents?limit=${LIST_LIMIT}`)) || [] + } + async listCachedHashes () { - const torrents = await this.request(`${API}/torrents?limit=100`) - return (torrents || []).filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) + const torrents = await this.#accountTorrents() + return torrents.filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) } - async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = 60 } = {}) { - const hash = (hashRx.exec(magnet)?.[1] || (/^[a-f\d]{40}$/i.test(magnet) ? magnet : '')).toLowerCase() - const magnetURI = magnet.startsWith('magnet:') ? magnet : `magnet:?xt=urn:btih:${hash}` + async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = this.config.maxFiles } = {}) { + const hash = RealDebrid.parseHash(magnet) + const magnetURI = RealDebrid.toMagnet(magnet) let torrentId = null let added = false try { // reuse a torrent that is already on the account instead of adding a duplicate - const existing = hash && (await this.request(`${API}/torrents?limit=100`))?.find(torrent => torrent.hash.toLowerCase() === hash) + const existing = hash && (await this.#accountTorrents()).find(torrent => torrent.hash.toLowerCase() === hash) if (existing?.status === 'waiting_files_selection') { // a stale add that never got its files selected, finish the job const info = await this.request(`${API}/torrents/info/${existing.id}`) @@ -64,21 +71,22 @@ export default class RealDebrid extends DebridService { torrentId = await this.#addAndSelect(magnetURI, fileFilter) added = true } - let info = await this.#awaitStatus(torrentId, 'downloaded', 5_000) - let files = await this.#unrestrictLinks(info, fileFilter, maxFiles) + let info = await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) - // figure out which single file playback is really after, so archives and - // reused torrents that are missing it can be recovered from + // work out which single file playback is really after before unrestricting, so a + // capped pack never drops the wanted episode, and so archives and reused torrents + // that are missing it can be recovered from const wanted = info.files.filter(file => fileFilter(file.path)).map(file => ({ id: file.id, path: file.path, size: file.bytes })) - const target = wanted.length ? (pickFile ? await pickFile(wanted) : wanted.sort((a, b) => b.size - a.size)[0]) : null + const target = wanted.length ? (pickFile ? await pickFile(wanted) : [...wanted].sort((a, b) => b.size - a.size)[0]) : null + let files = await this.#unrestrictLinks(info, fileFilter, maxFiles, target) if (target && !files.some(file => file.name === target.path.split('/').pop())) { debug(`Re-adding torrent to select only ${target.path}`) const retryId = await this.#addAndSelect(magnetURI, null, target.id) if (added) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) torrentId = retryId added = true - info = await this.#awaitStatus(torrentId, 'downloaded', 5_000) - files = await this.#unrestrictLinks(info, fileFilter, 1) + info = await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) + files = await this.#unrestrictLinks(info, fileFilter, 1, null) if (!files.length) throw new DebridError('Real-Debrid only serves this torrent as an archive') } if (!files.length) throw new DebridError('No playable files in this torrent') @@ -101,7 +109,7 @@ export default class RealDebrid extends DebridService { async #addAndSelect (magnetURI, fileFilter, fileId) { const torrentId = (await this.request(`${API}/torrents/addMagnet`, { method: 'POST', body: { magnet: magnetURI } }))?.id try { - const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', 12_000) + const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', this.config.timeouts.select) if (info.status === 'waiting_files_selection') { const ids = fileId ? [fileId] : info.files.filter(file => fileFilter(file.path)).map(file => file.id) await this.request(`${API}/torrents/selectFiles/${torrentId}`, { method: 'POST', body: { files: ids.length ? ids.join(',') : 'all' } }) @@ -121,21 +129,24 @@ export default class RealDebrid extends DebridService { * @param {any} info * @param {(name: string) => boolean} fileFilter * @param {number} maxFiles + * @param {{ path: string } | null} [target] - The file playback wants, kept inside the cap. */ - async #unrestrictLinks (info, fileFilter, maxFiles) { + async #unrestrictLinks (info, fileFilter, maxFiles, target) { if (!info.links?.length) throw new DebridError('Real-Debrid returned no links for this torrent') const selected = info.files.filter(file => file.selected) const aligned = info.links.length === selected.length - const candidates = (aligned + const candidates = RealDebrid.windowFiles(aligned ? selected.map((file, index) => ({ link: info.links[index], path: file.path, size: file.bytes })).filter(file => fileFilter(file.path)) - : info.links.map(link => ({ link }))).slice(0, maxFiles) - return (await Promise.all(candidates.map(async ({ link, path, size }) => { + : info.links.map(link => ({ link })), target, maxFiles) + // dead files inside a pack are skipped by mapFiles, the caller checks separately that + // the episode actually wanted came back and recovers if it did not + return this.mapFiles(candidates, async ({ link, path, size }) => { const unrestricted = await this.request(`${API}/unrestrict/link`, { method: 'POST', body: { link } }) const name = path?.split('/').pop() || unrestricted.filename if (!path && !fileFilter(name)) return null if (archiveRx.test(name) && !selected.some(file => file.path.endsWith(name))) return null // RD packed the selection into an archive return { name, path: path || `/${name}`, size: unrestricted.filesize || size, url: unrestricted.download, type: unrestricted.mimeType } - }))).filter(Boolean) + }, candidate => candidate.path || candidate.link) } /** @@ -151,12 +162,12 @@ export default class RealDebrid extends DebridService { const info = await this.request(`${API}/torrents/info/${id}`) if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info if (deadStatuses.includes(info.status)) throw new DebridError(`Real-Debrid could not process this torrent (${info.status})`) - if (['queued', 'downloading', 'uploading', 'compressing'].includes(info.status)) throw new DebridNotCachedError() + if (downloadingStatuses.includes(info.status)) throw new DebridNotCachedError() if (Date.now() - started > timeout) { if (info.status === 'magnet_conversion') throw new DebridNotCachedError('Real-Debrid does not recognize this torrent') throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) } - await new Promise(resolve => setTimeout(resolve, 1_000).unref?.()) + await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) } } } diff --git a/common/modules/debrid/route.js b/common/modules/debrid/route.js index f3e81aa2..6454fddb 100644 --- a/common/modules/debrid/route.js +++ b/common/modules/debrid/route.js @@ -19,14 +19,17 @@ function usable (torrentID) { * @param {boolean} options.serviceReady - The service has an API key configured. * @param {boolean} options.offline - The client has no network connection. * @param {string} options.mode - The debridMode setting, 'prefer' or 'only'. - * @returns {{ action: 'torrent' } | { action: 'block', reason: 'key' | 'offline' | 'source' } | { action: 'resolve', id: string }} + * @returns {{ action: 'torrent', only: boolean } | { action: 'block', reason: 'key' | 'offline' | 'source', only: boolean } | { action: 'resolve', id: string, only: boolean }} + * `only` reports whether debrid only mode governs this decision, so callers never + * have to re-derive the fallback rules that were already applied here. */ export function routeDebrid ({ torrentID, hash, serviceSelected, serviceReady, offline, mode }) { - if (!serviceSelected) return { action: 'torrent' } - const debridOnly = mode === 'only' - if (!serviceReady) return debridOnly ? { action: 'block', reason: 'key' } : { action: 'torrent' } - if (offline) return debridOnly ? { action: 'block', reason: 'offline' } : { action: 'torrent' } + // with no service selected debrid is entirely out of the picture, only mode included + if (!serviceSelected) return { action: 'torrent', only: false } + const only = mode === 'only' + if (!serviceReady) return only ? { action: 'block', reason: 'key', only } : { action: 'torrent', only } + if (offline) return only ? { action: 'block', reason: 'offline', only } : { action: 'torrent', only } const id = usable(torrentID) || usable(hash) - if (!id) return debridOnly ? { action: 'block', reason: 'source' } : { action: 'torrent' } - return { action: 'resolve', id } + if (!id) return only ? { action: 'block', reason: 'source', only } : { action: 'torrent', only } + return { action: 'resolve', id, only } } diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index 86745b81..ce6a2be0 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -41,12 +41,21 @@ export class DebridNotCachedError extends DebridError { } } +/** Thrown by the base class for any method a service template has not filled in yet. */ +export class DebridNotImplementedError extends DebridError { + /** @param {string} title - The service's display name. */ + constructor (title) { + super(`${title || 'This debrid service'} support is not implemented yet`) + this.name = 'DebridNotImplementedError' + } +} + /** * @typedef {Object} DebridFile * @property {string} name - File name without directories. * @property {string} path - Path within the torrent, always starting with a slash. * @property {number} size - File size in bytes. - * @property {string} url - Direct HTTPS stream URL. + * @property {string} url - Direct stream URL, must be HTTPS, the player streams it as is. * @property {string} [type] - MIME type when the service reports one. */ @@ -57,9 +66,39 @@ export class DebridNotCachedError extends DebridError { * @property {DebridFile[]} files - Streamable files, in torrent order. */ +/** + * Holds services to the HTTPS half of the DebridFile contract. Debrid links are + * account bound, so a service handing back cleartext would put the user's traffic + * and their link on the wire in the clear, silently. Dropped rather than downgraded. + * @param {DebridFile[]} files + * @param {string} title - Service name, for the message the user sees. + * @returns {DebridFile[]} The files safe to stream. + */ +export function secureFiles (files, title) { + const secure = (files || []).filter(file => /^https:\/\//i.test(file?.url)) + if (!secure.length) throw new DebridError(`${title} returned no secure stream links`) + return secure +} + +/** Archives a service may serve instead of streamable files, when it repacks a selection. */ +export const archiveRx = /\.(rar|zip|7z)$/i + +const magnetHashRx = /urn:btih:([a-f\d]{40})/i +const bareHashRx = /^[a-f\d]{40}$/i + +// retry policy for the shared limiter, applies to every service +const RATE_LIMIT_RETRIES = 2 +const RATE_LIMIT_FALLBACK = 5 // seconds to wait when a 429 carries no retry-after header +const NETWORK_RETRY_DELAY = 3_000 + /** * Base class for debrid services, providing rate limited requests and typed errors. * Implementations only talk HTTP, state is per-instance so services stay swappable. + * + * Adding a service means subclassing this, setting the statics below, and + * implementing the three abstract methods. Nothing outside the new file needs to + * change apart from one entry in the registry in `debrid.js`. Anything left + * unimplemented reports itself clearly instead of failing obscurely. * @abstract */ export default class DebridService { @@ -71,36 +110,90 @@ export default class DebridService { static available = false /** @type {import('bottleneck').ConstructorOptions} Request rate limits for the service API. */ static limits = { maxConcurrent: 4, minTime: 250 } + /** @type {'bearer' | 'query'} How the API key travels: an Authorization header or a query parameter. */ + static auth = 'bearer' + /** @type {string} Query parameter name used when `auth` is 'query'. */ + static authParam = 'apikey' + /** Tunable time limits in milliseconds, override only what differs for the service. */ + static timeouts = { + request: 30_000, // hard limit on a single HTTP request + select: 12_000, // waiting for the service to accept a magnet and expose its file list + ready: 5_000, // waiting for a cached torrent to report ready, anything slower is a fresh download + poll: 1_000 // gap between status polls + } + + /** @type {number} Most files one resolve turns into stream links, guards against huge season packs. */ + static maxFiles = 60 /** @param {string} apiKey */ constructor (apiKey) { this.apiKey = apiKey this.rateLimitPromise = null - this.limiter = new Bottleneck(/** @type {typeof DebridService} */(this.constructor).limits) + this.limiter = new Bottleneck(this.config.limits) this.limiter.on('failed', (error, jobInfo) => { if (error instanceof DebridNetworkError) return // offline, retrying just delays the error - if (error instanceof DebridError && error.status === 429 && jobInfo.retryCount < 2) { - const time = (Number(error.retryAfter) || 5) * 1_000 - debug(`Rate limited by ${/** @type {typeof DebridService} */(this.constructor).title}, retrying in ${time}ms`) + if (error instanceof DebridError && error.status === 429 && jobInfo.retryCount < RATE_LIMIT_RETRIES) { + const time = (Number(error.retryAfter) || RATE_LIMIT_FALLBACK) * 1_000 + debug(`Rate limited by ${this.config.title}, retrying in ${time}ms`) if (!this.rateLimitPromise) this.rateLimitPromise = new Promise(resolve => setTimeout(resolve, time).unref?.()).then(() => { this.rateLimitPromise = null }) return time } - if (!(error instanceof DebridError) && jobInfo.retryCount < 1) return 3_000 // single retry for network hiccups + if (!(error instanceof DebridError) && jobInfo.retryCount < 1) return NETWORK_RETRY_DELAY // single retry for network hiccups }) this.request = this.limiter.wrap(this.#request.bind(this)) } + /** The subclass's static configuration, typed so implementations get completions. */ + get config () { + return /** @type {typeof DebridService} */ (this.constructor) + } + + /** + * The lowercase info hash of a magnet URI or bare hash, empty when there is none. + * Every service takes the same input shape, so the parsing lives here once. + * @param {any} magnetOrHash + * @returns {string} + */ + static parseHash (magnetOrHash) { + if (typeof magnetOrHash !== 'string') return '' + return (magnetHashRx.exec(magnetOrHash)?.[1] || (bareHashRx.test(magnetOrHash) ? magnetOrHash : '')).toLowerCase() + } + + /** + * Normalizes a magnet URI or bare info hash into a magnet URI to hand to the API. + * @param {any} magnetOrHash + * @returns {string} Empty when the input holds no usable hash. + */ + static toMagnet (magnetOrHash) { + if (typeof magnetOrHash === 'string' && magnetOrHash.startsWith('magnet:')) return magnetOrHash + const hash = this.parseHash(magnetOrHash) + return hash ? `magnet:?xt=urn:btih:${hash}` : '' + } + + /** + * Applies the service's authentication scheme to an outgoing request. + * @param {string} url + * @returns {{ url: string, headers: Record }} + */ + authorize (url) { + if (this.config.auth !== 'query') return { url, headers: { Authorization: `Bearer ${this.apiKey}` } } + const target = new URL(url) + target.searchParams.set(this.config.authParam, this.apiKey) + return { url: target.href, headers: {} } + } + /** * @param {string} url - Absolute request URL. * @param {{ method?: string, body?: Record, timeout?: number }} [opts] - Body is sent form-encoded. */ - async #request (url, { method = 'GET', body, timeout = 30_000 } = {}) { + async #request (url, { method = 'GET', body, timeout = this.config.timeouts.request } = {}) { await this.rateLimitPromise if (!this.apiKey) throw new DebridAuthError('No debrid API key configured') - debug(`${method} ${url}`) - const res = await fetch(url, { + const authorized = this.authorize(url) + debug(`${method} ${url}`) // logged before authorization so query-parameter keys never reach the log + const res = await fetch(authorized.url, { method, - headers: { Authorization: `Bearer ${this.apiKey}`, ...(body ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}) }, + headers: { ...authorized.headers, ...(body ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}) }, body: body && new URLSearchParams(body).toString(), signal: AbortSignal.timeout(timeout) }) @@ -130,29 +223,75 @@ export default class DebridService { return new DebridError(message, { status, code: json?.error_code }) } + /** + * Caps a pack's file list, keeping a window centred on the file playback wants rather + * than its first N entries. Every service hits this: a season pack can hold hundreds of + * files, the wanted episode is often a late one, and dropping it forces an expensive + * re-add. Torrent order is preserved so in-player next/previous still works. + * @template T + * @param {T[]} files - Candidate files, in torrent order. + * @param {T | null} target - The file playback asked for, or null when there is none. + * @param {number} [maxFiles] + * @param {(file: T) => any} [key] - Identity used to locate the target among the candidates. + * @returns {T[]} + */ + static windowFiles (files, target, maxFiles = this.maxFiles, key = file => file?.path) { + if (files.length <= maxFiles) return files + const index = target ? files.findIndex(file => key(file) === key(target)) : -1 + const start = index < 0 ? 0 : Math.min(Math.max(0, index - (maxFiles >> 1)), files.length - maxFiles) + debug(`Pack holds ${files.length} files, taking ${maxFiles} from index ${start}`) + return files.slice(start, start + maxFiles) + } + + /** + * Turns candidate files into stream links concurrently, skipping the individual ones the + * service cannot serve. Packs really do contain dead files (Real-Debrid answers + * `hoster_unavailable`), and one of those must not fail the whole resolve. Authentication + * failures still abort, since every other link would fail for the same reason. + * @template T + * @param {T[]} candidates + * @param {(candidate: T) => Promise} toFile - Unrestricts one file, may return null to drop it. + * @param {(candidate: T) => string} [describe] - Names a candidate for the debug log. + * @returns {Promise} + */ + async mapFiles (candidates, toFile, describe = candidate => candidate?.path || 'file') { + const files = await Promise.all(candidates.map(async candidate => { + try { + return await toFile(candidate) + } catch (error) { + if (error instanceof DebridAuthError) throw error + debug(`Skipping ${describe(candidate)}: ${error.message}`) + return null + } + })) + return files.filter(Boolean) + } + /** * Verifies the API key and that the account can stream torrents. * @abstract * @returns {Promise<{ username: string, expires?: string }>} */ - async validate () { throw new Error('Not implemented') } + async validate () { throw new DebridNotImplementedError(this.config.title) } /** * Lists info hashes that are already downloaded on the account, used for instant playback badges. + * Services with a real cache-check endpoint can answer this far more completely than + * Real-Debrid can, the app treats the result as a hint either way. * @abstract * @returns {Promise} Lowercase info hashes. */ - async listCachedHashes () { throw new Error('Not implemented') } + async listCachedHashes () { throw new DebridNotImplementedError(this.config.title) } /** * Resolves a magnet to direct stream URLs, throws DebridNotCachedError when the - * service would have to download the torrent first. + * service would have to download the torrent first. Returned URLs must be HTTPS. * @abstract * @param {string} magnet - Magnet URI or bare info hash. - * @param {{ fileFilter?: (name: string) => boolean, maxFiles?: number }} [opts] + * @param {{ fileFilter?: (name: string) => boolean, pickFile?: (files: { id: number, path: string, size: number }[]) => Promise, maxFiles?: number }} [opts] * @returns {Promise} */ - async resolve (magnet, opts) { throw new Error('Not implemented') } + async resolve (magnet, opts) { throw new DebridNotImplementedError(this.config.title) } /** Cancels queued requests, the instance must not be used afterwards. */ destroy () { diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js index 918c238b..36ef3733 100644 --- a/common/modules/debrid/torbox.js +++ b/common/modules/debrid/torbox.js @@ -1,30 +1,22 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService, { DebridError } from './service.js' +import DebridService from './service.js' /** - * TorBox stub, see https://api-docs.torbox.app/ - * Untested skeleton kept out of the settings menu until someone with an account - * implements and verifies it. The relevant endpoints are: - * - GET /user/me -> account and plan for validate() - * - GET /torrents/mylist -> account torrents for listCachedHashes() - * - GET /torrents/checkcached?hash= -> TorBox still offers a real cache check - * - POST /torrents/createtorrent -> add a magnet - * - GET /torrents/requestdl?torrent_id=&file_id= -> direct stream URL per file - * Auth is a Bearer token like Real-Debrid, so the base request wrapper works as is. + * TorBox template, see https://api-docs.torbox.app/ + * + * Implementation template: the base class already provides authentication, rate + * limiting, typed errors and clear not-implemented reporting, so adding support + * means writing `validate`, `listCachedHashes` and `resolve` here and flipping + * `available` to true. Nothing outside this file has to change. TorBox uses a + * Bearer token like Real-Debrid, so the inherited `auth` default already fits. + * Useful endpoints: + * - GET /user/me -> account and plan for validate() + * - GET /torrents/mylist -> account torrents for listCachedHashes() + * - GET /torrents/checkcached -> a real cache check (`hash=`), so badges can be exact + * - POST /torrents/createtorrent -> add a magnet + * - GET /torrents/requestdl -> direct stream URL per file (`torrent_id=&file_id=`) */ export default class TorBox extends DebridService { static id = 'torbox' static title = 'TorBox' - - async validate () { - throw new DebridError(`${TorBox.title} support is not implemented yet`) - } - - async listCachedHashes () { - throw new DebridError(`${TorBox.title} support is not implemented yet`) - } - - async resolve (magnet, opts) { - throw new DebridError(`${TorBox.title} support is not implemented yet`) - } } diff --git a/common/modules/util.js b/common/modules/util.js index e3de9019..4d28ecbf 100644 --- a/common/modules/util.js +++ b/common/modules/util.js @@ -830,3 +830,23 @@ export const videoRx = new RegExp(`.(${videoExtensions.join('|')})$`, 'i') // freetype supported export const fontExtensions = ['ttf', 'ttc', 'woff', 'woff2', 'otf', 'cff', 'otc', 'pfa', 'pfb', 'pcf', 'fnt', 'bdf', 'pfr', 'eot'] export const fontRx = new RegExp(`.(${fontExtensions.join('|')})$`, 'i') + +// containers the Matroska parser can read embedded tracks, fonts and chapters out of +export const matroskaRx = /\.(mkv|webm)$/i + +/** + * Picks the external subtitle files belonging to one video out of a release's file list. + * Season packs ship a subtitle per episode, so subtitles are matched against the playing + * file's name unless the release holds a single video, in which case they all belong to it. + * Shared by the torrent client and debrid playback so both lanes stay in step. + * @param {{ name: string }[]} files - Every file in the release. + * @param {string} videoName - Name of the video being played, with extension. + * @param {number} [videoCount] - Videos in the release, counted from `files` when omitted. + * @returns {any[]} The matching subtitle files, in the order given. + */ +export function matchSubtitleFiles (files, videoName, videoCount) { + if (!files?.length || !videoName) return [] + const videos = videoCount ?? files.filter(file => videoRx.test(file.name)).length + const stem = videoName.substring(0, videoName.lastIndexOf('.')) || videoName + return files.filter(file => subRx.test(file.name) && (videos <= 1 || file.name.includes(stem))) +} diff --git a/common/routes/player/PlayerPage.svelte b/common/routes/player/PlayerPage.svelte index e7ed6c6c..8c77c1a4 100644 --- a/common/routes/player/PlayerPage.svelte +++ b/common/routes/player/PlayerPage.svelte @@ -12,6 +12,7 @@ import { createEventDispatcher } from 'svelte' import Subtitles from '@/modules/subtitles.js' import DebridMetadata from '@/modules/debrid/metadata.js' + import { debridTransport } from '@/modules/debrid/debrid.js' import { toTS, fastPrettyBytes, capitalize, matchPhrase, videoRx, isValidNumber, debounce } from '@/modules/util.js' import { toast } from 'svelte-sonner' import { getChaptersAniSkip } from '@/modules/anime/anime.js' @@ -69,6 +70,8 @@ let current = null let subs = null let debridMeta = null + // the player shows the service name in place of peers and speeds, which debrid streams have none of + $: debridTitle = `Streaming from ${$debridTransport?.title ?? 'your debrid service'}, no torrent peers involved` let duration = 0.1 let muted = false let wasPaused = null @@ -1744,8 +1747,8 @@ {/if}
{#if current?.debrid} - - Debrid + + {$debridTransport?.title ?? 'Debrid'} {:else} {torrent.peers || 0} diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index 4aae7902..b890fe0a 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -3,7 +3,7 @@ import { toast } from 'svelte-sonner' import { Eye, EyeOff } from 'lucide-svelte' import SettingCard from '@/routes/settings/components/SettingCard.svelte' - import { debridServices, testDebrid } from '@/modules/debrid/debrid.js' + import { debridOptions, testDebrid } from '@/modules/debrid/debrid.js' export let settings let showKey = false @@ -23,7 +23,7 @@ From a573085dcfbe54b39aad8ce0be06381359597f85 Mon Sep 17 00:00:00 2001 From: zeroz Date: Sat, 8 Aug 2026 19:18:25 -0400 Subject: [PATCH 03/11] fix small issue with debrid on playback --- common/modules/debrid/debrid.js | 29 +++++++++++++++++++++----- common/modules/torrent.js | 7 ++++++- common/routes/player/PlayerPage.svelte | 16 +++++++++++--- 3 files changed, 43 insertions(+), 9 deletions(-) diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index b2a6c73a..276b83b3 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -64,6 +64,14 @@ export const debridTransport = derived(settings, value => { /** Lowercase info hashes known to play instantly on the configured service. */ export const debridCachedHashes = writable(new Set()) +/** + * Whether debrid owns what the player is showing. Set the moment playback is routed to a + * service, before the resolve that takes a few seconds, because the player opens straight + * away and must not look like a torrent while it waits. Cleared whenever playback goes to + * the torrent client instead. + */ +export const debridPlayback = writable(false) + settings.subscribe(value => { const key = `${value.debridService}:${value.debridApiKey}` if (serviceKey !== null && serviceKey !== key) { @@ -112,12 +120,14 @@ export async function streamDebrid (torrentID, hash, search) { offline: status.value === 'offline', mode: settings.value.debridMode }) - if (route.action === 'torrent') return false + if (route.action === 'torrent') return handOver(false) const debridOnly = route.only if (route.action === 'block') { toast.error('Debrid', { description: blockedMessages[route.reason]() }) - return true + return handOver(true) // nothing plays, so nothing is owned } + // claimed before the resolve, which takes seconds the player spends already open + debridPlayback.set(true) try { files.set(await resolveDebridFiles(route.id, search)) return true @@ -126,21 +136,30 @@ export async function streamDebrid (torrentID, hash, search) { debug(`Torrent not cached: ${error.message}`) if (!debridOnly) { toast('Debrid', { description: 'Not cached on ' + serviceTitle() + ', streaming via torrent instead.' }) - return false + return handOver(false) } toast.error('Debrid', { description: 'This torrent is not cached on ' + serviceTitle() + '. Pick a different release or disable debrid only mode.' }) } else { debug('Debrid resolve failed:', error) if (!debridOnly) { toast.warning('Debrid Error', { description: `${error.message || error}\nStreaming via torrent instead.` }) - return false + return handOver(false) } toast.error('Debrid Error', { description: '' + (error.message || error) }) } - return true // handled, only mode never falls back to the torrent client + return handOver(true) // handled, only mode never falls back to the torrent client } } +/** + * Releases the player back to the torrent client and reports the routing outcome. + * @param {boolean} handled - What streamDebrid returns to its caller. + */ +function handOver (handled) { + debridPlayback.set(false) + return handled +} + /** * Resolves a magnet to player ready file objects shaped like the torrent client's. * @param {string} torrentID - Magnet URI or info hash. diff --git a/common/modules/torrent.js b/common/modules/torrent.js index 1c543ab8..b8e59649 100644 --- a/common/modules/torrent.js +++ b/common/modules/torrent.js @@ -8,7 +8,7 @@ import { writable } from 'simple-store-svelte' import { toast } from 'svelte-sonner' import { capitalize } from '@/modules/util.js' import clipboard from '@/modules/lib/clipboard.js' -import { streamDebrid } from '@/modules/debrid/debrid.js' +import { streamDebrid, debridPlayback } from '@/modules/debrid/debrid.js' import { setHash } from '@/modules/anime/animehash.js' import { TORRENT, ELECTRON } from '@/modules/bridge.js' import { get } from 'svelte/store' @@ -80,6 +80,11 @@ TORRENT.portRequest(_settings).then(() => { TORRENT.onFiles(_files => { debug(`Got files request:`, _files?.length) + // the client announces the files of every torrent it loads, including the one restored + // at startup, whose metadata can arrive long after debrid playback began. Letting that + // through would swap out what is playing for a torrent the user never picked. Playing + // a torrent hands the player back first, so this never blocks a real request. + if (debridPlayback.value) return debug('Ignoring torrent files, debrid owns playback') files.set(_files) }) diff --git a/common/routes/player/PlayerPage.svelte b/common/routes/player/PlayerPage.svelte index 8c77c1a4..db98c890 100644 --- a/common/routes/player/PlayerPage.svelte +++ b/common/routes/player/PlayerPage.svelte @@ -12,7 +12,7 @@ import { createEventDispatcher } from 'svelte' import Subtitles from '@/modules/subtitles.js' import DebridMetadata from '@/modules/debrid/metadata.js' - import { debridTransport } from '@/modules/debrid/debrid.js' + import { debridTransport, debridPlayback } from '@/modules/debrid/debrid.js' import { toTS, fastPrettyBytes, capitalize, matchPhrase, videoRx, isValidNumber, debounce } from '@/modules/util.js' import { toast } from 'svelte-sonner' import { getChaptersAniSkip } from '@/modules/anime/anime.js' @@ -70,6 +70,10 @@ let current = null let subs = null let debridMeta = null + let buffer = 0 // percent of the file reachable for seeking and thumbnails + // true from the moment playback is routed to debrid, not just once its files have resolved, + // so the player never shows torrent peers and speeds during the seconds a resolve takes + $: isDebrid = current?.debrid || $debridPlayback // the player shows the service name in place of peers and speeds, which debrid streams have none of $: debridTitle = `Streaming from ${$debridTransport?.title ?? 'your debrid service'}, no torrent peers involved` let duration = 0.1 @@ -293,6 +297,9 @@ debridMeta = null } current = file + // a debrid stream is served over HTTP ranges, so every byte is reachable immediately. + // Torrent playback starts at nothing and is filled in by the client's progress events. + buffer = file.debrid ? 100 : 0 setCurrent(file) } } @@ -1189,8 +1196,8 @@ } return 0 } - let buffer = 0 TORRENT.onProgress(progress => { + if (isDebrid) return // a background torrent's download says nothing about this stream buffer = progress * 100 }) @@ -1474,6 +1481,9 @@ const torrent = {} TORRENT.onCurrentStats(updateStats) function updateStats (detail) { + // no torrent backs a debrid stream, and the client keeps its own session running in the + // background, so its numbers must never be shown against what is actually playing + if (isDebrid) return torrent.peers = detail.numPeers || 0 torrent.up = detail.uploadSpeed || 0 torrent.down = detail.downloadSpeed || 0 @@ -1746,7 +1756,7 @@
{/if}
- {#if current?.debrid} + {#if isDebrid} {$debridTransport?.title ?? 'Debrid'} {:else} From e5e2fb52a875ec088e45f1f5f7c6378f8073e5e6 Mon Sep 17 00:00:00 2001 From: zeroz Date: Sat, 8 Aug 2026 21:32:13 -0400 Subject: [PATCH 04/11] mostly fix missing subtitle gui integration for debrid pipeline --- common/modules/debrid/metadata.js | 42 ++++++++++++++++++++++++++++--- common/modules/networking.js | 4 ++- common/package.json | 1 + common/webpack.config.cjs | 3 +++ pnpm-lock.yaml | 3 +++ 5 files changed, 48 insertions(+), 5 deletions(-) diff --git a/common/modules/debrid/metadata.js b/common/modules/debrid/metadata.js index 334c279e..61fd9668 100644 --- a/common/modules/debrid/metadata.js +++ b/common/modules/debrid/metadata.js @@ -7,6 +7,8 @@ const debug = Debug('ui:debrid') // stay this many seconds of video ahead of playback when streaming subtitles const AHEAD_SECONDS = 120 +// land this many seconds of video before a seek, so a rough byte estimate still covers it +const JUMP_BACK_SECONDS = 15 const RETRIES = 3 /** @@ -97,6 +99,9 @@ export default class DebridMetadata { } this.remote = new RemoteFile(file.url, file.size, file.name) this.metadata = new Metadata(this.remote) + // the parser starts several reads in its constructor, settle the ones nothing may + // ever await (duration when no tracks stream) so they cannot reject unhandled + for (const pending of [this.metadata.segment, this.metadata.seekHead, this.metadata.duration]) Promise.resolve(pending).catch(() => {}) this.metadata.getTracks().then(tracks => { if (this.destroyed) return @@ -133,16 +138,26 @@ export default class DebridMetadata { async #streamSubtitles () { const durationMs = await this.metadata.duration const byteRate = durationMs > 0 ? this.file.size / (durationMs / 1_000) : 0 - for (let attempt = 0, offset = 0; attempt < RETRIES && !this.destroyed; ++attempt) { + // the window of bytes fed to the parser so far, seeks outside it restart the stream + let start = 0 + let offset = 0 + for (let attempt = 0; attempt < RETRIES && !this.destroyed; ++attempt) { try { const stream = this.remote.slice(offset).stream() + let jumped = false for await (const chunk of this.metadata.parseStream(stream, offset === 0)) { if (this.destroyed) return offset += chunk.length - // wait for playback to catch up before buffering further, seeks resume instantly - while (!this.destroyed && byteRate && offset > (this.getTime() + AHEAD_SECONDS) * byteRate) await sleep(1_000) + const next = await this.#pace(byteRate, start, offset) + if (next !== offset) { + debug(`Seek left the parsed subtitle window, restarting stream at ${next}`) + start = offset = next + jumped = true + break + } } - return + if (!jumped) return // parsed to the end of the file + attempt = -1 // following a seek is progress, not a failed attempt } catch (error) { if (this.destroyed) return debug(`Subtitle stream interrupted at ${offset}, retrying:`, error) @@ -151,6 +166,25 @@ export default class DebridMetadata { } } + /** + * Waits until the parser should read further and reports where from: the current + * offset while playback approaches it, or a fresh one when a seek left the parsed + * window, where reading on sequentially would download everything in between for + * nothing. The player renderer deduplicates events, so overlapping parses are safe. + */ + async #pace (byteRate, start, offset) { + while (!this.destroyed && byteRate) { + const position = this.getTime() * byteRate + const jump = Math.max(0, Math.floor(position - JUMP_BACK_SECONDS * byteRate)) + // a target beyond the file means the estimate overshot, sequential reading covers it + if (jump < this.file.size && (position < start || jump > offset)) return jump + // wait for playback to catch up before buffering further ahead + if (offset <= position + AHEAD_SECONDS * byteRate) return offset + await sleep(1_000) + } + return offset + } + /** Releases the container parser and its range requests, leaving external subtitles alone. */ #releaseParser () { this.metadata?.removeAllListeners() diff --git a/common/modules/networking.js b/common/modules/networking.js index 1d4c4c34..7aa3f966 100644 --- a/common/modules/networking.js +++ b/common/modules/networking.js @@ -73,7 +73,9 @@ window.fetch = async (...args) => { if (status.value === 'offline') return { message: 'failed to fetch: client is offline' } try { - const res = await fetch(url, { ...options, signal: offlineController.signal }) + // keep the caller's own signal working, timeouts and teardown aborts depend on it + const signal = options.signal ? AbortSignal.any([options.signal, offlineController.signal]) : offlineController.signal + const res = await fetch(url, { ...options, signal }) if (!res?.ok && res?.status !== 404 && res?.status !== 429 && res?.status !== 451) fetchError({ response: res?.response, status: res?.status, message: res?.message }) return res } catch (error) { diff --git a/common/package.json b/common/package.json index 1e9feafb..a4f89749 100644 --- a/common/package.json +++ b/common/package.json @@ -5,6 +5,7 @@ "@fontsource-variable/nunito": "^5.3.0", "anitomyscript": "github:ThaUnknown/anitomyscript#42290c4b3f256893be08a4e89051f448ff5e9d00", "bottleneck": "^2.19.5", + "buffer": "^6.0.3", "comlink": "^4.4.2", "css-loader": "^7.1.4", "dompurify": "^3.4.13", diff --git a/common/webpack.config.cjs b/common/webpack.config.cjs index 68fe4d47..de632813 100644 --- a/common/webpack.config.cjs +++ b/common/webpack.config.cjs @@ -2,6 +2,7 @@ const { join, resolve } = require('path') const mode = process.env.NODE_ENV?.trim() || 'development' const isDev = mode === 'development' +const webpack = require('webpack') const HtmlWebpackPlugin = require('html-webpack-plugin') const MiniCssExtractPlugin = require('mini-css-extract-plugin') const CopyWebpackPlugin = require('copy-webpack-plugin') @@ -87,6 +88,8 @@ module.exports = (parentDir, alias = {}, aliasFields = 'browser', filename = 'ap extensions: ['.mjs', '.js', '.svelte'] }, plugins: [ + // matroska-metadata (debrid subtitle parsing) expects Node's Buffer global, which target 'web' lacks + new webpack.ProvidePlugin({ Buffer: ['buffer', 'Buffer'] }), new MiniCssExtractPlugin({ filename: '[name].css' }), diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index be947302..ee2543e2 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -210,6 +210,9 @@ importers: bottleneck: specifier: ^2.19.5 version: 2.19.5 + buffer: + specifier: ^6.0.3 + version: 6.0.3 comlink: specifier: ^4.4.2 version: 4.4.2 From 9c6a76bdfe3759861d21fcde7f4f607427594388 Mon Sep 17 00:00:00 2001 From: zeroz Date: Sun, 9 Aug 2026 05:33:06 -0400 Subject: [PATCH 05/11] debrid probing for RD and batch cache check for others. service hardening --- .../torrent/components/TorrentCard.svelte | 5 +- .../torrent/components/TorrentResults.svelte | 69 +++++--- common/modules/debrid/alldebrid.js | 6 +- common/modules/debrid/debrid.js | 71 +++++++- common/modules/debrid/premiumize.js | 6 +- common/modules/debrid/realdebrid.js | 58 ++++++- common/modules/debrid/route.js | 20 ++- common/modules/debrid/service.js | 152 +++++++++++++++++- common/modules/debrid/torbox.js | 6 +- common/modules/util.js | 2 + common/routes/settings/tabs/DebridTab.svelte | 3 + 11 files changed, 351 insertions(+), 47 deletions(-) diff --git a/common/modals/torrent/components/TorrentCard.svelte b/common/modals/torrent/components/TorrentCard.svelte index 9edd2ac3..e8722a4b 100644 --- a/common/modals/torrent/components/TorrentCard.svelte +++ b/common/modals/torrent/components/TorrentCard.svelte @@ -449,9 +449,8 @@
{#if $debridEnabled && $debridCachedHashes.has(result.hash?.toLowerCase())} -
- - Debrid +
+
{/if} {#if result.type === 'best'} diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index fad9b450..1200c10a 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -10,7 +10,8 @@ import { anitomyscript, getMediaMaxEp, getKitsuMappings, getEpisodeMetadataForMedia } from '@/modules/anime/anime.js' import { loadedTorrent, completedTorrents, seedingTorrents, stagingTorrents } from '@/modules/torrent.js' import { dedupe, getTorrentResults, updatePeerCounts } from '@/modules/extensions/handler.js' - import { debridEnabled, debridCachedHashes, debridTransport, refreshDebridCache } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridCachedHashes, debridTransport, debridChecking, refreshDebridCache, probeDebridCache } from '@/modules/debrid/debrid.js' + import { listResult } from '@/modules/debrid/route.js' import { getId, getHash } from '@/modules/anime/animehash.js' import AnimeResolver from '@/modules/anime/animeresolver.js' import { anilistClient } from '@/modules/providers/anilist/anilist.js' @@ -21,6 +22,10 @@ import Debug from 'debug' const debug = Debug('ui:torrents') + // how far down the results the debrid cache check reaches, the service caps the cost + // of answering within that (one batch request, or a handful of probes) + const CACHE_CHECK_RESULTS = 20 + /** @typedef {import('@/modules/providers/anilist/al.d.ts').Media} Media */ /** @typedef {import('anitomyscript').AnitomyResult} AnitomyResult */ /** @typedef {import('../../../../extensions').TorrentResult} Result */ @@ -88,30 +93,39 @@ * @param {string} sort * @param {boolean} batch * @param {Set} [debridHashes] - Hashes that play instantly via debrid, listed even without seeders. + * @param {boolean} [cachedOnly] - Show only debrid-cached releases, hiding the rest rather than dropping them. */ - function sortResults(results, sort, batch, debridHashes) { - if (!results) return { results: [], hiddenResults: [] } + function sortResults(results, sort, batch, debridHashes, cachedOnly) { + if (!results) return { results: [], hiddenResults: [], sorted: [], cachedCount: 0 } const deduped = Array.from(dedupe(results)).map(result => { if (!(result.parseObject?.release_group && result.parseObject.release_group.length < 20)) result.parseObject = { ...result.parseObject, release_group: 'No Group' } return result }) - const available = entry => entry.seeders > 0 || entry.source?.managed || debridHashes?.has(entry.hash?.toLowerCase()) - return { - results: deduped.filter(available).sort((a, b) => { - switch (sort) { - case 'smallest': return a.size - b.size - case 'best': return ((b.type === 'best') - (a.type === 'best') || (b.type === 'alt') - (a.type === 'alt')) || b.seeders - a.seeders - case 'batch': { - if (!batch) return b.seeders - a.seeders - return ((b.type === 'batch') - (a.type === 'batch')) || b.seeders - a.seeders - } - case 'new': return new Date(b.date) - new Date(a.date) - case 'old': return new Date(a.date) - new Date(b.date) - case 'seeders': - default: return b.seeders - a.seeders + const cached = entry => Boolean(debridHashes?.has(entry.hash?.toLowerCase())) + // filtering narrows what the rest of the modal sees, so the best pick and autoplay + // follow it too, which is the whole point in debrid only mode + const available = entry => listResult(entry, cached(entry), cachedOnly) + // sorted before partitioning, so the hidden half keeps display order and the cache + // check can walk the same priority the user sees, filtered or not + const sorted = deduped.sort((a, b) => { + switch (sort) { + case 'smallest': return a.size - b.size + case 'best': return ((b.type === 'best') - (a.type === 'best') || (b.type === 'alt') - (a.type === 'alt')) || b.seeders - a.seeders + case 'batch': { + if (!batch) return b.seeders - a.seeders + return ((b.type === 'batch') - (a.type === 'batch')) || b.seeders - a.seeders } - }), - hiddenResults: deduped.filter(entry => !available(entry)) + case 'new': return new Date(b.date) - new Date(a.date) + case 'old': return new Date(a.date) - new Date(b.date) + case 'seeders': + default: return b.seeders - a.seeders + } + }) + return { + sorted, + cachedCount: debridHashes ? sorted.filter(cached).length : 0, + results: sorted.filter(available), + hiddenResults: sorted.filter(entry => !available(entry)) } } @@ -333,7 +347,13 @@ $: resolution = $settings.rssQuality $: queries = queryExtensions({...search}, resolution) $: errors = getErrors({...search}, queries) - $: queryResults = sortResults($results?.torrents, $settings.torrentSort, batch, $debridEnabled ? $debridCachedHashes : undefined) + $: cachedOnly = $debridEnabled && $settings.debridCachedOnly + // ask the service about the releases nearest the top, which are the ones most likely to be + // played. Answers land in the store the badges read, so the list marks itself up as they + // arrive. The unfiltered order is used deliberately: filtering to cached results and then + // only ever checking those would leave everything else permanently unknown. + $: if ($debridEnabled && $results?.resolved) probeDebridCache((queryResults?.sorted || []).slice(0, CACHE_CHECK_RESULTS).map(result => result.hash)) + $: queryResults = sortResults($results?.torrents, $settings.torrentSort, batch, $debridEnabled ? $debridCachedHashes : undefined, cachedOnly) $: lookup = queryResults?.results $: (episodeSearch || resolution || $settings.torrentSort || $settings.audioLanguage) && scrollTop() @@ -486,6 +506,13 @@ {$debridTransport.label}
{/if} + {#if $debridEnabled} + + {/if}
@@ -565,7 +592,7 @@ {/if} {#if lookupHidden?.length && $results?.torrents?.length && filterResults(lookupHidden, searchText)?.length} {#if viewHidden} diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js index 82b08479..b4f0e733 100644 --- a/common/modules/debrid/alldebrid.js +++ b/common/modules/debrid/alldebrid.js @@ -6,8 +6,8 @@ import DebridService from './service.js' * * Implementation template: the base class already provides authentication, rate * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listCachedHashes` and `resolve` here and flipping - * `available` to true. Nothing outside this file has to change. Useful endpoints: + * means writing `validate`, `listCachedHashes`, `resolve` and `checkCachedBatch` here + * and flipping `available` to true. Nothing outside this file has to change. Useful endpoints: * - GET /user -> account and premium status for validate() * - GET /magnet/status -> account magnets for listCachedHashes() * - GET /magnet/upload -> add a magnet (`magnets[]=`), the `instant` flag reports cache state @@ -17,4 +17,6 @@ export default class AllDebrid extends DebridService { static id = 'alldebrid' static title = 'AllDebrid' static auth = 'query' + // the upload response carries an `instant` flag per magnet, so a batch check is possible + static cacheCheck = 'batch' } diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index 276b83b3..38d75234 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -11,7 +11,7 @@ import RealDebrid from '@/modules/debrid/realdebrid.js' import AllDebrid from '@/modules/debrid/alldebrid.js' import TorBox from '@/modules/debrid/torbox.js' import Premiumize from '@/modules/debrid/premiumize.js' -import { DebridNotCachedError, secureFiles } from '@/modules/debrid/service.js' +import DebridService, { DebridNotCachedError, secureFiles } from '@/modules/debrid/service.js' import { routeDebrid } from '@/modules/debrid/route.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -64,6 +64,9 @@ export const debridTransport = derived(settings, value => { /** Lowercase info hashes known to play instantly on the configured service. */ export const debridCachedHashes = writable(new Set()) +/** Cache checks in flight, so the UI can show that badges are still filling in. */ +export const debridChecking = writable(0) + /** * Whether debrid owns what the player is showing. Set the moment playback is routed to a * service, before the resolve that takes a few seconds, because the player opens straight @@ -134,6 +137,7 @@ export async function streamDebrid (torrentID, hash, search) { } catch (error) { if (error instanceof DebridNotCachedError) { debug(`Torrent not cached: ${error.message}`) + forgetHash(route.id) // the badge was wrong, or it aged out of the cache if (!debridOnly) { toast('Debrid', { description: 'Not cached on ' + serviceTitle() + ', streaming via torrent instead.' }) return handOver(false) @@ -174,7 +178,9 @@ export async function resolveDebridFiles (torrentID, search) { }) const files = secureFiles(resolved.files, serviceTitle()) if (files.length !== resolved.files.length) debug(`Discarded ${resolved.files.length - files.length} non-HTTPS links from ${serviceTitle()}`) - rememberHash(resolved.hash) + // playing it is the most authoritative cache answer there is, so no probe repeats it + service.remember(resolved.hash, true) + rememberHashes([resolved.hash]) return Promise.all(files.map(async file => ({ infoHash: resolved.hash, fileHash: await sha1hex(`${resolved.hash}:${file.name}:${file.size}`), // same key the torrent client uses, so watch progress is shared @@ -196,17 +202,43 @@ export function refreshDebridCache () { const service = getService() if (!service) return const remembered = Object.keys(cache.getEntry(caches.GENERAL, 'debridResolvedHashes')?.[serviceId()] || {}) - if (remembered.length) debridCachedHashes.update(set => new Set([...set, ...remembered])) + if (remembered.length) { + debridCachedHashes.update(set => new Set([...set, ...remembered])) + for (const hash of remembered) service.remember(hash, true) // never pay to re-check these + } if (Date.now() - lastRefresh < REFRESH_INTERVAL || status.value === 'offline') return lastRefresh = Date.now() service.listCachedHashes().then(hashes => { debridCachedHashes.update(set => new Set([...set, ...hashes])) + for (const hash of hashes) service.remember(hash, true) }).catch(error => { lastRefresh = 0 debug('Failed to list debrid torrents:', error) }) } +/** + * Fills in cache state for the releases the user is looking at, so badges reflect what the + * service can actually stream rather than only what this account has touched before. The + * service decides how: one batch call where its API offers a cache endpoint, capped probing + * where it does not. Answers are remembered, so browsing the same show again is free. + * @param {string[]} hashes - Candidate info hashes, most relevant first, the cap bites from the end. + */ +export async function probeDebridCache (hashes) { + const service = getService() + if (!service || !settings.value.debridCacheCheck || status.value === 'offline') return + if (!service.unknownHashes(hashes).length) return // everything here already has an answer + debridChecking.update(count => count + 1) + try { + const { cached } = await service.checkCached(hashes) + if (cached.size) rememberHashes([...cached]) + } catch (error) { + debug('Cache check failed:', error) + } finally { + debridChecking.update(count => count - 1) + } +} + /** * Picks the file for the requested episode out of a pack using the same * anitomy parsing the rest of the app relies on, largest file as fallback. @@ -234,12 +266,35 @@ function serviceTitle () { return debridServices[serviceId()]?.title || 'debrid' } -/** Remembers a successfully resolved hash per service so results can be badged instantly. */ -function rememberHash (hash) { - debridCachedHashes.update(set => new Set([...set, hash])) +/** + * Drops a hash the service turned out not to hold, from the badge store, the persisted + * list and the service's own memory. Without all three the next search would badge it + * again from persistence, and playback would fail the same way a second time. + * @param {string} magnetOrHash + */ +function forgetHash (magnetOrHash) { + const hash = DebridService.parseHash(magnetOrHash) + if (!hash) return + service?.remember(hash, false) + debridCachedHashes.update(set => { + const next = new Set(set) + next.delete(hash) + return next + }) + cache.setEntry(caches.GENERAL, 'debridResolvedHashes', (current = {}) => { + const kept = { ...(current[serviceId()] || {}) } + delete kept[hash] + return { ...current, [serviceId()]: kept } + }) +} + +/** Remembers hashes the service is known to hold, so results can be badged instantly. */ +function rememberHashes (hashes) { + debridCachedHashes.update(set => new Set([...set, ...hashes])) cache.setEntry(caches.GENERAL, 'debridResolvedHashes', (current = {}) => { - const hashes = { ...(current[serviceId()] || {}), [hash]: Date.now() } - const pruned = Object.fromEntries(Object.entries(hashes).sort(([, a], [, b]) => b - a).slice(0, MAX_REMEMBERED)) + const now = Date.now() + const merged = { ...(current[serviceId()] || {}), ...Object.fromEntries(hashes.map(hash => [hash, now])) } + const pruned = Object.fromEntries(Object.entries(merged).sort(([, a], [, b]) => b - a).slice(0, MAX_REMEMBERED)) return { ...current, [serviceId()]: pruned } }) } diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js index df182472..ba2f9f2d 100644 --- a/common/modules/debrid/premiumize.js +++ b/common/modules/debrid/premiumize.js @@ -6,8 +6,8 @@ import DebridService from './service.js' * * Implementation template: the base class already provides authentication, rate * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listCachedHashes` and `resolve` here and flipping - * `available` to true. Nothing outside this file has to change. Useful endpoints: + * means writing `validate`, `listCachedHashes`, `resolve` and `checkCachedBatch` here + * and flipping `available` to true. Nothing outside this file has to change. Useful endpoints: * - GET /account/info -> account and premium status for validate() * - GET /transfer/list -> account transfers for listCachedHashes() * - GET /cache/check -> Premiumize still offers a real cache check (`items[]=`) @@ -17,4 +17,6 @@ export default class Premiumize extends DebridService { static id = 'premiumize' static title = 'Premiumize' static auth = 'query' + // /cache/check answers for many hashes at once, so badges cost one request + static cacheCheck = 'batch' } diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index 2c44d910..184d195c 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -11,6 +11,20 @@ const deadStatuses = ['magnet_error', 'error', 'virus', 'dead'] // statuses that mean the torrent is being fetched fresh, so it was never cached const downloadingStatuses = ['queued', 'downloading', 'uploading', 'compressing'] +// https://api.real-debrid.com/ error_code values worth explaining, anything else +// falls back to the message the API sends +const errorMessages = { + 8: 'Invalid Real-Debrid API key', + 9: 'Real-Debrid denied the request, check the account permissions', + 21: 'Too many active Real-Debrid downloads, wait for one to finish', + 23: 'This Real-Debrid account has exhausted its traffic', + 34: 'Real-Debrid is rate limiting this account, try again shortly', + 35: 'Real-Debrid has blocked this release for copyright reasons, pick a different one', + 36: 'Real-Debrid fair usage limit reached' +} +// only these mean the key or account is the problem, the rest are per-request +const authCodes = [8, 9] + /** * Real-Debrid implementation, see https://api.real-debrid.com/ * @@ -28,11 +42,16 @@ export default class RealDebrid extends DebridService { static available = true // documented allowance is 250 requests per minute, keep some headroom static limits = { reservoir: 200, reservoirRefreshAmount: 200, reservoirRefreshInterval: 60_000, maxConcurrent: 4, minTime: 150 } + // no cache endpoint exists any more, so cache state has to be probed a hash at a time + static cacheCheck = 'probe' mapError (status, json) { - // https://api.real-debrid.com/ error_code 8 = bad_token, 9 = permission_denied - if (json?.error_code === 8 || json?.error_code === 9 || status === 401 || status === 403) return new DebridAuthError(json?.error === 'bad_token' ? 'Invalid Real-Debrid API key' : (json?.error || 'Real-Debrid denied the request'), { status, code: json?.error_code }) - return super.mapError(status, json) + const code = json?.error_code + const message = errorMessages[code] || json?.error || `Request failed with status ${status}` + // a blocked or unavailable file also answers 403, and must stay a plain error: an auth + // error aborts the whole resolve, where one bad file in a pack should only be skipped + if (authCodes.includes(code) || ((status === 401 || status === 403) && code == null)) return new DebridAuthError(message, { status, code }) + return new DebridError(message, { status, code }) } async validate () { @@ -46,6 +65,34 @@ export default class RealDebrid extends DebridService { return (await this.request(`${API}/torrents?limit=${LIST_LIMIT}`)) || [] } + /** + * Finds out whether Real-Debrid can stream a release right now. Since + * `/torrents/instantAvailability` was disabled the only way to ask is to add the magnet + * and read the status it settles on: a cached torrent reports 'downloaded' within about a + * second of file selection, anything else is being fetched fresh. Costs roughly five + * requests, which is why the base class caps how many of these run per search. + * + * The torrent is always removed again. Adding a hash the account already holds creates a + * separate entry with its own id, so this can never delete the user's own download. + * @param {string} hash + * @returns {Promise} + */ + async probeCached (hash) { + const magnetURI = RealDebrid.toMagnet(hash) + if (!magnetURI) return false + const timeout = this.config.timeouts.probe + let torrentId = null + try { + torrentId = await this.#addAndSelect(magnetURI, () => true, undefined, timeout) + return (await this.#awaitStatus(torrentId, 'downloaded', timeout)).status === 'downloaded' + } catch (error) { + if (error instanceof DebridAuthError) throw error // the key is the problem, not this release + return false // not cached, unrecognized, or too slow to settle: not instantly playable + } finally { + if (torrentId) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + } + } + async listCachedHashes () { const torrents = await this.#accountTorrents() return torrents.filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) @@ -104,12 +151,13 @@ export default class RealDebrid extends DebridService { * @param {string} magnetURI * @param {((name: string) => boolean) | null} fileFilter * @param {number} [fileId] + * @param {number} [timeout] - Budget for the service to accept the magnet, shortened for cache probes. * @returns {Promise} The new torrent id. */ - async #addAndSelect (magnetURI, fileFilter, fileId) { + async #addAndSelect (magnetURI, fileFilter, fileId, timeout = this.config.timeouts.select) { const torrentId = (await this.request(`${API}/torrents/addMagnet`, { method: 'POST', body: { magnet: magnetURI } }))?.id try { - const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', this.config.timeouts.select) + const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', timeout) if (info.status === 'waiting_files_selection') { const ids = fileId ? [fileId] : info.files.filter(file => fileFilter(file.path)).map(file => file.id) await this.request(`${API}/torrents/selectFiles/${torrentId}`, { method: 'POST', body: { files: ids.length ? ids.join(',') : 'all' } }) diff --git a/common/modules/debrid/route.js b/common/modules/debrid/route.js index 6454fddb..edc7aaca 100644 --- a/common/modules/debrid/route.js +++ b/common/modules/debrid/route.js @@ -1,6 +1,6 @@ -// Pure playback routing policy, free of UI imports so it can be tested under -// plain Node. This is the single decision point for debrid vs torrent playback: -// debrid only mode must never route to the torrent client, whatever the input. +// Pure debrid policy, free of UI imports so it can be tested under plain Node. +// Two decisions live here: how a play request is routed (debrid only mode must never +// reach the torrent client, whatever the input), and which search results are listed. const magnetRx = /^magnet:.*urn:btih:[a-f\d]{40}/i const hexRx = /^[a-f\d]{40}$/i @@ -33,3 +33,17 @@ export function routeDebrid ({ torrentID, hash, serviceSelected, serviceReady, o if (!id) return only ? { action: 'block', reason: 'source', only } : { action: 'torrent', only } return { action: 'resolve', id, only } } + +/** + * Whether a search result belongs in the listed results rather than the hidden ones. + * With the cached filter off this is upstream's rule, widened only by the fact that a + * cached release streams without seeders. With it on, only known-cached releases list. + * @param {{ seeders?: number, source?: { managed?: boolean } }} result + * @param {boolean} cached - The service is known to hold this release. + * @param {boolean} [cachedOnly] - The user asked to see cached releases only. + * @returns {boolean} + */ +export function listResult (result, cached, cachedOnly) { + if (cachedOnly) return cached + return result?.seeders > 0 || Boolean(result?.source?.managed) || cached +} diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index ce6a2be0..5bf6d5c9 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -119,16 +119,37 @@ export default class DebridService { request: 30_000, // hard limit on a single HTTP request select: 12_000, // waiting for the service to accept a magnet and expose its file list ready: 5_000, // waiting for a cached torrent to report ready, anything slower is a fresh download - poll: 1_000 // gap between status polls + poll: 1_000, // gap between status polls + probe: 8_000 // budget for one cache probe, past this the release is not instantly playable } /** @type {number} Most files one resolve turns into stream links, guards against huge season packs. */ static maxFiles = 60 + /** + * @type {'none' | 'batch' | 'probe'} How the service can be asked whether it holds a release. + * 'batch' services answer for many hashes in one cheap call, which is by far the best case. + * 'probe' is for services with no such endpoint, where the only way to find out is to add + * the magnet and read the status back, costing several requests per hash. + */ + static cacheCheck = 'none' + /** @type {number} Most hashes one checkCached call probes, since probing is the expensive path. */ + static maxProbes = 10 + /** + * How long a cache answer stays trusted, in milliseconds. A miss expires far sooner than a + * hit: anyone can pull a release into the service's cache at any moment, but a release it + * already holds rarely disappears. + */ + static cacheTTL = { hit: 6 * 60 * 60_000, miss: 20 * 60_000 } + /** @param {string} apiKey */ constructor (apiKey) { this.apiKey = apiKey this.rateLimitPromise = null + /** @type {Map} What the service has already said about a hash. */ + this.cacheState = new Map() + /** @type {Map>} Probes in flight, so the same hash is never asked about twice at once. */ + this.probes = new Map() this.limiter = new Bottleneck(this.config.limits) this.limiter.on('failed', (error, jobInfo) => { if (error instanceof DebridNetworkError) return // offline, retrying just delays the error @@ -267,6 +288,133 @@ export default class DebridService { return files.filter(Boolean) } + /** + * Records what is known about a release so later checks are free. Playback feeds this + * too: a resolve that succeeded proves the service holds it, a not-cached error proves + * it does not, and neither costs a request to find out again. + * @param {string} magnetOrHash + * @param {boolean} cached + */ + remember (magnetOrHash, cached) { + const hash = DebridService.parseHash(magnetOrHash) + if (hash) this.cacheState.set(hash, { cached, at: Date.now() }) + } + + /** + * A remembered answer that has not expired, or undefined when the hash needs asking about. + * @param {string} hash + * @returns {boolean | undefined} + */ + #recall (hash) { + const known = this.cacheState.get(hash) + if (!known) return undefined + if (Date.now() - known.at < (known.cached ? this.config.cacheTTL.hit : this.config.cacheTTL.miss)) return known.cached + this.cacheState.delete(hash) // stale, ask again + return undefined + } + + /** + * The given hashes that nothing is known about yet, in the order supplied. Callers use + * this to skip work entirely rather than to decide what to ask about, which checkCached + * does itself. + * @param {string[]} magnetsOrHashes + * @returns {string[]} + */ + unknownHashes (magnetsOrHashes) { + return DebridService.#normalize(magnetsOrHashes).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) + } + + /** Lowercase, deduplicated hashes, order preserved. */ + static #normalize (magnetsOrHashes) { + return [...new Set((magnetsOrHashes || []).map(entry => DebridService.parseHash(entry)).filter(Boolean))] + } + + /** + * Reports which of the given releases the service can stream instantly. + * + * Remembered answers come back for free. Whatever is left is asked about in the cheapest + * way the service supports: one batch call where the API offers a cache endpoint, or a + * capped number of probes where it does not, because a probe costs several requests. + * Hashes that stay unanswered are simply absent from `checked`, which callers must treat + * as "unknown" rather than "not cached". + * @param {string[]} magnetsOrHashes - Candidates, most relevant first, since the cap bites from the end. + * @param {{ probe?: boolean, limit?: number }} [opts] + * @returns {Promise<{ cached: Set, checked: Set }>} + */ + async checkCached (magnetsOrHashes, { probe = true, limit = this.config.maxProbes } = {}) { + const cached = new Set() + const checked = new Set() + const unknown = [] + for (const hash of DebridService.#normalize(magnetsOrHashes)) { + const known = this.#recall(hash) + if (known === undefined) unknown.push(hash) + else { + checked.add(hash) + if (known) cached.add(hash) + } + } + if (!unknown.length || this.config.cacheCheck === 'none') return { cached, checked } + + if (this.config.cacheCheck === 'batch') { + const hits = await this.checkCachedBatch(unknown) + for (const hash of unknown) { + const hit = hits.has(hash) + this.remember(hash, hit) + checked.add(hash) + if (hit) cached.add(hash) + } + return { cached, checked } + } + + if (!probe) return { cached, checked } + const targets = unknown.slice(0, Math.max(0, limit)) + if (targets.length < unknown.length) debug(`Probing ${targets.length} of ${unknown.length} unknown hashes, the rest stay unknown`) + await Promise.all(targets.map(async hash => { + try { + if (await this.#probe(hash)) cached.add(hash) + checked.add(hash) + } catch (error) { + if (error instanceof DebridAuthError) throw error // the key is wrong, every other probe would fail too + debug(`Cache probe failed for ${hash}: ${error.message}`) + } + })) + return { cached, checked } + } + + /** Runs one probe, sharing a single request with any caller already waiting on that hash. */ + #probe (hash) { + let pending = this.probes.get(hash) + if (!pending) { + pending = this.probeCached(hash) + .then(result => { + this.remember(hash, result) + return result + }) + .finally(() => this.probes.delete(hash)) + this.probes.set(hash, pending) + } + return pending + } + + /** + * Asks the service about many releases at once. Implement this for any API that exposes a + * cache endpoint, and set `cacheCheck` to 'batch': it is one request instead of dozens. + * @abstract + * @param {string[]} hashes - Lowercase info hashes. + * @returns {Promise>} The subset the service can stream instantly. + */ + async checkCachedBatch (hashes) { throw new DebridNotImplementedError(this.config.title) } + + /** + * Determines whether one release is cached, for services with no cache endpoint. + * Implementations must leave the account exactly as they found it, and must resolve + * false rather than throwing when the answer is simply "no". + * @abstract + * @param {string} hash - Lowercase info hash. + * @returns {Promise} + */ + async probeCached (hash) { throw new DebridNotImplementedError(this.config.title) } + /** * Verifies the API key and that the account can stream torrents. * @abstract @@ -295,6 +443,8 @@ export default class DebridService { /** Cancels queued requests, the instance must not be used afterwards. */ destroy () { + this.cacheState.clear() + this.probes.clear() this.limiter.stop({ dropWaitingJobs: true }).catch(() => {}) } } diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js index 36ef3733..03ba9936 100644 --- a/common/modules/debrid/torbox.js +++ b/common/modules/debrid/torbox.js @@ -6,8 +6,8 @@ import DebridService from './service.js' * * Implementation template: the base class already provides authentication, rate * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listCachedHashes` and `resolve` here and flipping - * `available` to true. Nothing outside this file has to change. TorBox uses a + * means writing `validate`, `listCachedHashes`, `resolve` and `checkCachedBatch` here + * and flipping `available` to true. Nothing outside this file has to change. TorBox uses a * Bearer token like Real-Debrid, so the inherited `auth` default already fits. * Useful endpoints: * - GET /user/me -> account and plan for validate() @@ -19,4 +19,6 @@ import DebridService from './service.js' export default class TorBox extends DebridService { static id = 'torbox' static title = 'TorBox' + // /torrents/checkcached answers for many hashes at once, so badges cost one request + static cacheCheck = 'batch' } diff --git a/common/modules/util.js b/common/modules/util.js index 4d28ecbf..48dadf7f 100644 --- a/common/modules/util.js +++ b/common/modules/util.js @@ -699,6 +699,8 @@ export const defaults = { debridService: 'none', debridApiKey: '', debridMode: 'prefer', + debridCachedOnly: false, + debridCacheCheck: true, donate: true, w2g: false, font: undefined, diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index b890fe0a..5302cf64 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -55,4 +55,7 @@ + + + {/if} From 59f312c50e0914ae530fabe7eaa95217c82d11a6 Mon Sep 17 00:00:00 2001 From: zeroz Date: Sun, 9 Aug 2026 23:09:04 -0400 Subject: [PATCH 06/11] cleanup, more rd probing --- .../torrent/components/TorrentResults.svelte | 72 +++--- common/modules/debrid/debrid.js | 59 ++--- common/modules/debrid/realdebrid.js | 86 +++---- common/modules/debrid/service.js | 212 ++++++++++++------ common/modules/util.js | 2 - common/routes/settings/tabs/DebridTab.svelte | 2 +- 6 files changed, 254 insertions(+), 179 deletions(-) diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index 1200c10a..2a1e7fc6 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -10,7 +10,7 @@ import { anitomyscript, getMediaMaxEp, getKitsuMappings, getEpisodeMetadataForMedia } from '@/modules/anime/anime.js' import { loadedTorrent, completedTorrents, seedingTorrents, stagingTorrents } from '@/modules/torrent.js' import { dedupe, getTorrentResults, updatePeerCounts } from '@/modules/extensions/handler.js' - import { debridEnabled, debridCachedHashes, debridTransport, debridChecking, refreshDebridCache, probeDebridCache } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridCachedHashes, debridTransport, debridChecking, refreshDebridCache, checkDebridCache } from '@/modules/debrid/debrid.js' import { listResult } from '@/modules/debrid/route.js' import { getId, getHash } from '@/modules/anime/animehash.js' import AnimeResolver from '@/modules/anime/animeresolver.js' @@ -22,10 +22,6 @@ import Debug from 'debug' const debug = Debug('ui:torrents') - // how far down the results the debrid cache check reaches, the service caps the cost - // of answering within that (one batch request, or a handful of probes) - const CACHE_CHECK_RESULTS = 20 - /** @typedef {import('@/modules/providers/anilist/al.d.ts').Media} Media */ /** @typedef {import('anitomyscript').AnitomyResult} AnitomyResult */ /** @typedef {import('../../../../extensions').TorrentResult} Result */ @@ -92,22 +88,14 @@ * @param {Result[]} results * @param {string} sort * @param {boolean} batch - * @param {Set} [debridHashes] - Hashes that play instantly via debrid, listed even without seeders. - * @param {boolean} [cachedOnly] - Show only debrid-cached releases, hiding the rest rather than dropping them. */ - function sortResults(results, sort, batch, debridHashes, cachedOnly) { - if (!results) return { results: [], hiddenResults: [], sorted: [], cachedCount: 0 } + function sortResults(results, sort, batch) { + if (!results) return [] const deduped = Array.from(dedupe(results)).map(result => { if (!(result.parseObject?.release_group && result.parseObject.release_group.length < 20)) result.parseObject = { ...result.parseObject, release_group: 'No Group' } return result }) - const cached = entry => Boolean(debridHashes?.has(entry.hash?.toLowerCase())) - // filtering narrows what the rest of the modal sees, so the best pick and autoplay - // follow it too, which is the whole point in debrid only mode - const available = entry => listResult(entry, cached(entry), cachedOnly) - // sorted before partitioning, so the hidden half keeps display order and the cache - // check can walk the same priority the user sees, filtered or not - const sorted = deduped.sort((a, b) => { + return deduped.sort((a, b) => { switch (sort) { case 'smallest': return a.size - b.size case 'best': return ((b.type === 'best') - (a.type === 'best') || (b.type === 'alt') - (a.type === 'alt')) || b.seeders - a.seeders @@ -121,11 +109,38 @@ default: return b.seeders - a.seeders } }) - return { - sorted, - cachedCount: debridHashes ? sorted.filter(cached).length : 0, - results: sorted.filter(available), - hiddenResults: sorted.filter(entry => !available(entry)) + } + + const sameOrder = (a, b) => a.length === b.length && a.every((entry, index) => entry === b[index]) + + /** + * Builds the function that splits sorted results into what is listed and what is hidden. + * Kept apart from the sorting above so a debrid cache answer only redoes these passes, not + * the dedupe and sort of every result. The previous split is remembered in a closure rather + * than a component variable, so it stays out of the reactive graph. + * @returns {(sorted: Result[], debridHashes?: Set, cachedOnly?: boolean) => any} + */ + function createListResults() { + let previous = null + return function listResults(sorted, debridHashes, cachedOnly) { + const results = [] + const hiddenResults = [] + let cachedCount = 0 + for (const entry of sorted) { + const cached = Boolean(debridHashes?.has(entry.hash?.toLowerCase())) + if (cached) cachedCount++ + // this narrows what the rest of the modal sees, so the best pick and autoplay follow + // it too, which is the whole point in debrid only mode + if (listResult(entry, cached, cachedOnly)) results.push(entry) + else hiddenResults.push(entry) + } + // most cache answers only move the count, since a release with seeders was listed either + // way. Handing back the same arrays then keeps the best-release pick from being redone, + // which reparses every result and is what made answers landing feel like a freeze. + if (previous && sameOrder(previous.results, results) && sameOrder(previous.hiddenResults, hiddenResults)) { + return { ...previous, cachedCount } + } + return (previous = { sorted, cachedCount, results, hiddenResults }) } } @@ -181,6 +196,7 @@ export let search export let close + const listResults = createListResults() let container let containerEl let countdown = 5 @@ -348,12 +364,12 @@ $: queries = queryExtensions({...search}, resolution) $: errors = getErrors({...search}, queries) $: cachedOnly = $debridEnabled && $settings.debridCachedOnly - // ask the service about the releases nearest the top, which are the ones most likely to be - // played. Answers land in the store the badges read, so the list marks itself up as they - // arrive. The unfiltered order is used deliberately: filtering to cached results and then - // only ever checking those would leave everything else permanently unknown. - $: if ($debridEnabled && $results?.resolved) probeDebridCache((queryResults?.sorted || []).slice(0, CACHE_CHECK_RESULTS).map(result => result.hash)) - $: queryResults = sortResults($results?.torrents, $settings.torrentSort, batch, $debridEnabled ? $debridCachedHashes : undefined, cachedOnly) + $: sortedResults = sortResults($results?.torrents, $settings.torrentSort, batch) + // confirm cache state from the top of the list down, which is where the releases worth + // playing are. How far it reaches is the service's call: one request for a service with a + // cache endpoint, a handful of probes for one without. + $: if ($debridEnabled && $results?.resolved) checkDebridCache(sortedResults.map(result => result.hash)) + $: queryResults = listResults(sortedResults, $debridEnabled ? $debridCachedHashes : undefined, cachedOnly) $: lookup = queryResults?.results $: (episodeSearch || resolution || $settings.torrentSort || $settings.audioLanguage) && scrollTop() @@ -508,7 +524,7 @@ {/if} {#if $debridEnabled} diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index 38d75234..f74e32f5 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -1,6 +1,5 @@ import { files } from '@/components/MediaHandler.svelte' import { settings } from '@/modules/settings.js' -import { cache, caches } from '@/modules/cache.js' import { status } from '@/modules/networking.js' import { videoRx, subRx } from '@/modules/util.js' import { anitomyscript } from '@/modules/anime/anime.js' @@ -25,7 +24,6 @@ const debridServices = Object.fromEntries([RealDebrid, AllDebrid, TorBox, Premiu /** Selectable services for the settings menu, as plain data. */ export const debridOptions = Object.values(debridServices).map(Service => ({ id: Service.id, title: Service.title })) -const MAX_REMEMBERED = 300 const REFRESH_INTERVAL = 60_000 // user facing messages for the routing policy's blocked outcomes @@ -178,9 +176,9 @@ export async function resolveDebridFiles (torrentID, search) { }) const files = secureFiles(resolved.files, serviceTitle()) if (files.length !== resolved.files.length) debug(`Discarded ${resolved.files.length - files.length} non-HTTPS links from ${serviceTitle()}`) - // playing it is the most authoritative cache answer there is, so no probe repeats it + // playing it proves the service holds it, which is the best cache answer there is service.remember(resolved.hash, true) - rememberHashes([resolved.hash]) + debridCachedHashes.update(set => new Set(set).add(resolved.hash)) return Promise.all(files.map(async file => ({ infoHash: resolved.hash, fileHash: await sha1hex(`${resolved.hash}:${file.name}:${file.size}`), // same key the torrent client uses, so watch progress is shared @@ -195,17 +193,12 @@ export async function resolveDebridFiles (torrentID, search) { } /** - * Updates the cached hash set from remembered resolves and, at most once a - * minute, the list of torrents already downloaded on the account. + * Refreshes the badge data every service can supply for free: the torrents already on the + * account, which stream instantly. One request a minute at most. */ export function refreshDebridCache () { const service = getService() if (!service) return - const remembered = Object.keys(cache.getEntry(caches.GENERAL, 'debridResolvedHashes')?.[serviceId()] || {}) - if (remembered.length) { - debridCachedHashes.update(set => new Set([...set, ...remembered])) - for (const hash of remembered) service.remember(hash, true) // never pay to re-check these - } if (Date.now() - lastRefresh < REFRESH_INTERVAL || status.value === 'offline') return lastRefresh = Date.now() service.listCachedHashes().then(hashes => { @@ -218,20 +211,23 @@ export function refreshDebridCache () { } /** - * Fills in cache state for the releases the user is looking at, so badges reflect what the + * Confirms cache state for the releases the user is looking at, so the badges say what the * service can actually stream rather than only what this account has touched before. The - * service decides how: one batch call where its API offers a cache endpoint, capped probing - * where it does not. Answers are remembered, so browsing the same show again is free. - * @param {string[]} hashes - Candidate info hashes, most relevant first, the cap bites from the end. + * service decides how: one batch call where its API offers a cache endpoint, a capped number + * of probes where it does not. Answers are remembered, so browsing the same show again is free. + * @param {string[]} hashes - Candidate info hashes, most relevant first, since probing bites from the front. */ -export async function probeDebridCache (hashes) { +export async function checkDebridCache (hashes) { const service = getService() if (!service || !settings.value.debridCacheCheck || status.value === 'offline') return if (!service.unknownHashes(hashes).length) return // everything here already has an answer debridChecking.update(count => count + 1) try { - const { cached } = await service.checkCached(hashes) - if (cached.size) rememberHashes([...cached]) + // badge each release as its answer lands rather than when the sweep ends, so a probing + // service marks the list up as it goes instead of all at once a minute later + await service.checkCached(hashes, { + onAnswer: (hash, hit) => { if (hit) debridCachedHashes.update(set => new Set(set).add(hash)) } + }) } catch (error) { debug('Cache check failed:', error) } finally { @@ -258,18 +254,13 @@ async function pickEpisodeFile (files, episode) { return videoFiles.sort((a, b) => b.size - a.size)[0] } -function serviceId () { - return settings.value.debridService -} - function serviceTitle () { - return debridServices[serviceId()]?.title || 'debrid' + return debridServices[settings.value.debridService]?.title || 'debrid' } /** - * Drops a hash the service turned out not to hold, from the badge store, the persisted - * list and the service's own memory. Without all three the next search would badge it - * again from persistence, and playback would fail the same way a second time. + * Drops a hash the service turned out not to hold, so the next search does not badge it + * again and fail playback the same way a second time. * @param {string} magnetOrHash */ function forgetHash (magnetOrHash) { @@ -281,22 +272,6 @@ function forgetHash (magnetOrHash) { next.delete(hash) return next }) - cache.setEntry(caches.GENERAL, 'debridResolvedHashes', (current = {}) => { - const kept = { ...(current[serviceId()] || {}) } - delete kept[hash] - return { ...current, [serviceId()]: kept } - }) -} - -/** Remembers hashes the service is known to hold, so results can be badged instantly. */ -function rememberHashes (hashes) { - debridCachedHashes.update(set => new Set([...set, ...hashes])) - cache.setEntry(caches.GENERAL, 'debridResolvedHashes', (current = {}) => { - const now = Date.now() - const merged = { ...(current[serviceId()] || {}), ...Object.fromEntries(hashes.map(hash => [hash, now])) } - const pruned = Object.fromEntries(Object.entries(merged).sort(([, a], [, b]) => b - a).slice(0, MAX_REMEMBERED)) - return { ...current, [serviceId()]: pruned } - }) } async function sha1hex (data) { diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index 184d195c..11332591 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -4,8 +4,9 @@ import Debug from 'debug' const debug = Debug('ui:debrid') const API = 'https://api.real-debrid.com/rest/1.0' -// how much of the account's torrent history to read for reuse and cache badges -const LIST_LIMIT = 100 +// the account's torrent list comes back in one request, newest first. Accounts larger than +// this keep their most recent torrents badged, which is the half anyone is browsing. +const LIST_LIMIT = 1_000 // statuses that mean the torrent will never complete const deadStatuses = ['magnet_error', 'error', 'virus', 'dead'] // statuses that mean the torrent is being fetched fresh, so it was never cached @@ -19,7 +20,7 @@ const errorMessages = { 21: 'Too many active Real-Debrid downloads, wait for one to finish', 23: 'This Real-Debrid account has exhausted its traffic', 34: 'Real-Debrid is rate limiting this account, try again shortly', - 35: 'Real-Debrid has blocked this release for copyright reasons, pick a different one', + 35: 'Real-Debrid would not accept this release, try again shortly or pick a different one', 36: 'Real-Debrid fair usage limit reached' } // only these mean the key or account is the problem, the rest are per-request @@ -28,13 +29,12 @@ const authCodes = [8, 9] /** * Real-Debrid implementation, see https://api.real-debrid.com/ * - * Two quirks discovered against the live API shape this client: - * - There is no instant availability endpoint anymore, cache state is only found - * out by adding a magnet: a cached torrent reports 'downloaded' right after file - * selection, anything queued for a fresh download is not cached and gets removed. - * - Selecting multiple files can serve a single RAR archive instead of individual - * links, so when that happens the torrent is re-added selecting only the target - * file, which always yields a direct streamable link. + * Two quirks of the live API shape this client: + * - `/torrents/instantAvailability` is disabled (403 `disabled_endpoint`), so the only way to + * ask whether a release is cached is to add the magnet and read the status back. That is + * what `probeCached` does, and why the base class caps how many of them a search may cost. + * - Selecting multiple files can serve a single RAR archive instead of individual links, so + * when that happens the torrent is re-added selecting only the target file. */ export default class RealDebrid extends DebridService { static id = 'realdebrid' @@ -42,7 +42,7 @@ export default class RealDebrid extends DebridService { static available = true // documented allowance is 250 requests per minute, keep some headroom static limits = { reservoir: 200, reservoirRefreshAmount: 200, reservoirRefreshInterval: 60_000, maxConcurrent: 4, minTime: 150 } - // no cache endpoint exists any more, so cache state has to be probed a hash at a time + // no cache endpoint any more, so cache state has to be probed a hash at a time static cacheCheck = 'probe' mapError (status, json) { @@ -60,50 +60,55 @@ export default class RealDebrid extends DebridService { return { username: user.username, expires: user.expiration } } - /** The account's recent torrents, the one list both cache badges and torrent reuse read from. */ + /** The account's torrents, the one list both cache badges and torrent reuse read from. */ async #accountTorrents () { return (await this.request(`${API}/torrents?limit=${LIST_LIMIT}`)) || [] } + async listCachedHashes () { + const torrents = await this.#accountTorrents() + return torrents.filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) + } + /** - * Finds out whether Real-Debrid can stream a release right now. Since - * `/torrents/instantAvailability` was disabled the only way to ask is to add the magnet - * and read the status it settles on: a cached torrent reports 'downloaded' within about a - * second of file selection, anything else is being fetched fresh. Costs roughly five - * requests, which is why the base class caps how many of these run per search. + * Finds out whether Real-Debrid can stream a release right now, the only way it still can be + * asked: add the magnet and read the status it settles on. A cached torrent reports + * 'downloaded' within a second or so of file selection, anything else is being fetched fresh. + * Costs about five requests and a few seconds, hence the cap in the base class. * * The torrent is always removed again. Adding a hash the account already holds creates a * separate entry with its own id, so this can never delete the user's own download. + * + * Nothing here decides what a failure means: `#awaitStatus` raises DebridNotCachedError for + * the states that really are a no, and any other error travels up as "no answer at all". * @param {string} hash * @returns {Promise} */ async probeCached (hash) { const magnetURI = RealDebrid.toMagnet(hash) - if (!magnetURI) return false + if (!magnetURI) throw new DebridError('Not a usable info hash') // no answer, rather than a made up one const timeout = this.config.timeouts.probe let torrentId = null try { torrentId = await this.#addAndSelect(magnetURI, () => true, undefined, timeout) return (await this.#awaitStatus(torrentId, 'downloaded', timeout)).status === 'downloaded' - } catch (error) { - if (error instanceof DebridAuthError) throw error // the key is the problem, not this release - return false // not cached, unrecognized, or too slow to settle: not instantly playable } finally { - if (torrentId) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + // awaited, so the probe has genuinely left the account as it found it by the time it + // answers. Playback waits on this before reusing a torrent, and teardown waits on it + // before stopping the limiter, so neither can trip over a half-finished probe. + if (torrentId) await this.release(`${API}/torrents/delete/${torrentId}`) } } - async listCachedHashes () { - const torrents = await this.#accountTorrents() - return torrents.filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) - } - async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = this.config.maxFiles } = {}) { const hash = RealDebrid.parseHash(magnet) const magnetURI = RealDebrid.toMagnet(magnet) let torrentId = null let added = false try { + // a cache probe of this same release is about to delete its own torrent, so let it + // finish first rather than reusing an id that is seconds from disappearing + await this.probes.get(hash)?.catch(() => {}) // reuse a torrent that is already on the account instead of adding a duplicate const existing = hash && (await this.#accountTorrents()).find(torrent => torrent.hash.toLowerCase() === hash) if (existing?.status === 'waiting_files_selection') { @@ -129,7 +134,9 @@ export default class RealDebrid extends DebridService { if (target && !files.some(file => file.name === target.path.split('/').pop())) { debug(`Re-adding torrent to select only ${target.path}`) const retryId = await this.#addAndSelect(magnetURI, null, target.id) - if (added) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + // not awaited, unlike the failure paths: the user is sat in front of an open player + // waiting for this resolve, and removing the superseded torrent can catch up later + if (added) this.release(`${API}/torrents/delete/${torrentId}`) torrentId = retryId added = true info = await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) @@ -141,7 +148,7 @@ export default class RealDebrid extends DebridService { return { hash: info.hash.toLowerCase(), name: info.filename, files } } catch (error) { // only clean up torrents this call added, never the user's own downloads - if (added && torrentId) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + if (added && torrentId) await this.release(`${API}/torrents/delete/${torrentId}`) throw error } } @@ -151,7 +158,7 @@ export default class RealDebrid extends DebridService { * @param {string} magnetURI * @param {((name: string) => boolean) | null} fileFilter * @param {number} [fileId] - * @param {number} [timeout] - Budget for the service to accept the magnet, shortened for cache probes. + * @param {number} [timeout] - Budget for the service to accept the magnet, shortened for probes. * @returns {Promise} The new torrent id. */ async #addAndSelect (magnetURI, fileFilter, fileId, timeout = this.config.timeouts.select) { @@ -164,7 +171,8 @@ export default class RealDebrid extends DebridService { } return torrentId } catch (error) { - if (torrentId) this.request(`${API}/torrents/delete/${torrentId}`, { method: 'DELETE' }).catch(() => {}) + // awaited, so this call has undone itself by the time it reports failure + if (torrentId) await this.release(`${API}/torrents/delete/${torrentId}`) throw error } } @@ -198,8 +206,8 @@ export default class RealDebrid extends DebridService { } /** - * Polls torrent info until it reaches the wanted status. Anything queued for a - * fresh download means the torrent is not in the instant cache. + * Polls torrent info until it reaches the wanted status. A torrent the service has to fetch + * fresh, or cannot process at all, is not something playback can stream now. * @param {string} id * @param {string} wanted * @param {number} timeout @@ -209,12 +217,14 @@ export default class RealDebrid extends DebridService { while (true) { const info = await this.request(`${API}/torrents/info/${id}`) if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info - if (deadStatuses.includes(info.status)) throw new DebridError(`Real-Debrid could not process this torrent (${info.status})`) + // a torrent the service cannot process is one it will never stream, which for playback + // is the same answer as uncached: fall back to the torrent client rather than error out + if (deadStatuses.includes(info.status)) throw new DebridNotCachedError(`Real-Debrid could not process this torrent (${info.status})`) if (downloadingStatuses.includes(info.status)) throw new DebridNotCachedError() - if (Date.now() - started > timeout) { - if (info.status === 'magnet_conversion') throw new DebridNotCachedError('Real-Debrid does not recognize this torrent') - throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) - } + // deliberately not a "not cached" answer: a rare or old release can sit in + // magnet_conversion for a while, and calling that a miss is what empties the badges on + // exactly those titles. No answer means the release stays unknown and re-checkable. + if (Date.now() - started > timeout) throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) } } diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index 5bf6d5c9..be10eccc 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -33,7 +33,7 @@ export class DebridNetworkError extends DebridError { } } -/** Thrown when a torrent is not present in the service's instant cache. */ +/** Thrown when the service would have to download a torrent before it could stream it. */ export class DebridNotCachedError extends DebridError { constructor (message = 'Torrent is not cached on the debrid service', opts) { super(message, opts) @@ -67,9 +67,9 @@ export class DebridNotImplementedError extends DebridError { */ /** - * Holds services to the HTTPS half of the DebridFile contract. Debrid links are - * account bound, so a service handing back cleartext would put the user's traffic - * and their link on the wire in the clear, silently. Dropped rather than downgraded. + * Holds services to the HTTPS half of the DebridFile contract. Debrid links are account + * bound, so a cleartext link would put the user's traffic and their link on the wire in + * the clear. Dropped rather than downgraded. * @param {DebridFile[]} files * @param {string} title - Service name, for the message the user sees. * @returns {DebridFile[]} The files safe to stream. @@ -90,15 +90,16 @@ const bareHashRx = /^[a-f\d]{40}$/i const RATE_LIMIT_RETRIES = 2 const RATE_LIMIT_FALLBACK = 5 // seconds to wait when a 429 carries no retry-after header const NETWORK_RETRY_DELAY = 3_000 +// consecutive unanswered probes before a sweep gives up on the rest of its list +const MAX_PROBE_FAILURES = 3 /** * Base class for debrid services, providing rate limited requests and typed errors. * Implementations only talk HTTP, state is per-instance so services stay swappable. * - * Adding a service means subclassing this, setting the statics below, and - * implementing the three abstract methods. Nothing outside the new file needs to - * change apart from one entry in the registry in `debrid.js`. Anything left - * unimplemented reports itself clearly instead of failing obscurely. + * Adding a service means subclassing this, setting the statics below, and implementing the + * abstract methods. Nothing outside the new file needs to change apart from one entry in the + * registry in `debrid.js`. Anything left unimplemented reports itself clearly. * @abstract */ export default class DebridService { @@ -120,21 +121,34 @@ export default class DebridService { select: 12_000, // waiting for the service to accept a magnet and expose its file list ready: 5_000, // waiting for a cached torrent to report ready, anything slower is a fresh download poll: 1_000, // gap between status polls - probe: 8_000 // budget for one cache probe, past this the release is not instantly playable + // budget for one cache probe. Deliberately tighter than `select`: a probe that drags on + // spends requests the account needs for playback, and no answer is worth that + probe: 10_000 } /** @type {number} Most files one resolve turns into stream links, guards against huge season packs. */ static maxFiles = 60 /** - * @type {'none' | 'batch' | 'probe'} How the service can be asked whether it holds a release. - * 'batch' services answer for many hashes in one cheap call, which is by far the best case. - * 'probe' is for services with no such endpoint, where the only way to find out is to add + * @type {'batch' | 'probe' | 'none'} How the service can be asked whether it holds a release. + * 'batch' services answer many hashes in one cheap request, which is by far the best case. + * 'probe' is for services with no cache endpoint, where the only way to find out is to add * the magnet and read the status back, costing several requests per hash. + * 'none' leaves badges to `listCachedHashes` and lets playback discover the rest. */ static cacheCheck = 'none' - /** @type {number} Most hashes one checkCached call probes, since probing is the expensive path. */ + + /** @type {number} Hashes per batch request, so one long results list becomes a few calls. */ + static maxBatch = 100 + + /** + * @type {number} How far down the results a probing service looks, and so the most probes + * one results list can ever cost. Probing is expensive — several requests and a few seconds + * each — so this buys confirmed answers for the releases most likely to be played rather + * than trying to answer the whole list. Everything past it stays unknown. + */ static maxProbes = 10 + /** * How long a cache answer stays trusted, in milliseconds. A miss expires far sooner than a * hit: anyone can pull a release into the service's cache at any moment, but a release it @@ -148,8 +162,10 @@ export default class DebridService { this.rateLimitPromise = null /** @type {Map} What the service has already said about a hash. */ this.cacheState = new Map() - /** @type {Map>} Probes in flight, so the same hash is never asked about twice at once. */ + /** @type {Map>} Probes in flight, so a hash is never asked about twice at once. */ this.probes = new Map() + /** @type {boolean} Whether a probe sweep is running, since only one may be. */ + this.sweeping = false this.limiter = new Bottleneck(this.config.limits) this.limiter.on('failed', (error, jobInfo) => { if (error instanceof DebridNetworkError) return // offline, retrying just delays the error @@ -164,6 +180,19 @@ export default class DebridService { this.request = this.limiter.wrap(this.#request.bind(this)) } + /** + * Undoes something this client created on the account. Never throws: it runs from `finally`, + * where it would mask the real failure. + * @param {string} url + */ + async release (url) { + try { + await this.request(url, { method: 'DELETE' }) + } catch (error) { + debug(`Cleanup failed for ${url}: ${error.message}`) + } + } + /** The subclass's static configuration, typed so implementations get completions. */ get config () { return /** @type {typeof DebridService} */ (this.constructor) @@ -289,9 +318,8 @@ export default class DebridService { } /** - * Records what is known about a release so later checks are free. Playback feeds this - * too: a resolve that succeeded proves the service holds it, a not-cached error proves - * it does not, and neither costs a request to find out again. + * Records what is known about a release so later checks are free. Playback feeds this too: + * a resolve that succeeded proves the service holds it, a not-cached error proves it does not. * @param {string} magnetOrHash * @param {boolean} cached */ @@ -314,38 +342,52 @@ export default class DebridService { } /** - * The given hashes that nothing is known about yet, in the order supplied. Callers use - * this to skip work entirely rather than to decide what to ask about, which checkCached - * does itself. + * The given hashes that nothing is known about yet, in the order supplied. Callers use this + * to skip work entirely rather than to decide what to ask about, which checkCached does itself. * @param {string[]} magnetsOrHashes * @returns {string[]} */ unknownHashes (magnetsOrHashes) { - return DebridService.#normalize(magnetsOrHashes).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) + const limit = this.config.cacheCheck === 'probe' ? this.config.maxProbes : Infinity + return DebridService.#normalize(magnetsOrHashes, limit).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) } - /** Lowercase, deduplicated hashes, order preserved. */ - static #normalize (magnetsOrHashes) { - return [...new Set((magnetsOrHashes || []).map(entry => DebridService.parseHash(entry)).filter(Boolean))] + /** + * Lowercase, deduplicated hashes, order preserved. + * @param {string[]} magnetsOrHashes + * @param {number} [limit] - Stop after this many usable hashes, so a long list costs nothing to trim. + */ + static #normalize (magnetsOrHashes, limit = Infinity) { + const hashes = new Set() + for (const entry of magnetsOrHashes || []) { + const hash = DebridService.parseHash(entry) + if (hash) hashes.add(hash) + if (hashes.size >= limit) break + } + return [...hashes] } /** * Reports which of the given releases the service can stream instantly. * - * Remembered answers come back for free. Whatever is left is asked about in the cheapest - * way the service supports: one batch call where the API offers a cache endpoint, or a - * capped number of probes where it does not, because a probe costs several requests. - * Hashes that stay unanswered are simply absent from `checked`, which callers must treat - * as "unknown" rather than "not cached". - * @param {string[]} magnetsOrHashes - Candidates, most relevant first, since the cap bites from the end. - * @param {{ probe?: boolean, limit?: number }} [opts] + * Remembered answers come back for free. Whatever is left is asked about in the cheapest way + * the service supports: one batch call where the API offers a cache endpoint, or a capped + * number of probes where it does not. Hashes that stay unanswered are simply absent from + * `checked`, which callers must treat as "unknown" rather than "not cached". + * + * `onAnswer` fires as each answer lands, so a slow probe sweep marks the list up as it goes. + * @param {string[]} magnetsOrHashes - Candidates, most relevant first, since probing bites from the front. + * @param {{ onAnswer?: (hash: string, cached: boolean) => void }} [opts] * @returns {Promise<{ cached: Set, checked: Set }>} */ - async checkCached (magnetsOrHashes, { probe = true, limit = this.config.maxProbes } = {}) { + async checkCached (magnetsOrHashes, { onAnswer } = {}) { const cached = new Set() const checked = new Set() + const mode = this.config.cacheCheck + // probing only ever looks at the top of the list, so normalize just that much of it + const candidates = DebridService.#normalize(magnetsOrHashes, mode === 'probe' ? this.config.maxProbes : Infinity) const unknown = [] - for (const hash of DebridService.#normalize(magnetsOrHashes)) { + for (const hash of candidates) { const known = this.#recall(hash) if (known === undefined) unknown.push(hash) else { @@ -353,39 +395,67 @@ export default class DebridService { if (known) cached.add(hash) } } - if (!unknown.length || this.config.cacheCheck === 'none') return { cached, checked } + if (!unknown.length || mode === 'none') return { cached, checked } - if (this.config.cacheCheck === 'batch') { - const hits = await this.checkCachedBatch(unknown) - for (const hash of unknown) { - const hit = hits.has(hash) - this.remember(hash, hit) - checked.add(hash) - if (hit) cached.add(hash) + const answer = (hash, hit) => { + checked.add(hash) + if (hit) cached.add(hash) + onAnswer?.(hash, hit) + } + + if (mode === 'batch') { + for (let index = 0; index < unknown.length; index += this.config.maxBatch) { + const chunk = unknown.slice(index, index + this.config.maxBatch) + const hits = await this.checkCachedBatch(chunk) + for (const hash of chunk) { + const hit = hits.has(hash) + this.remember(hash, hit) + answer(hash, hit) + } } return { cached, checked } } - if (!probe) return { cached, checked } - const targets = unknown.slice(0, Math.max(0, limit)) - if (targets.length < unknown.length) debug(`Probing ${targets.length} of ${unknown.length} unknown hashes, the rest stay unknown`) - await Promise.all(targets.map(async hash => { - try { - if (await this.#probe(hash)) cached.add(hash) - checked.add(hash) - } catch (error) { - if (error instanceof DebridAuthError) throw error // the key is wrong, every other probe would fail too - debug(`Cache probe failed for ${hash}: ${error.message}`) + // One sweep at a time. Probing is an add/read/delete cycle and services rate limit adding + // far harder than reading, so overlapping sweeps do not answer faster, they get refused. + if (this.sweeping) return { cached, checked } + this.sweeping = true + try { + let failures = 0 + for (const hash of unknown) { + try { + answer(hash, await this.#probe(hash)) + failures = 0 + } catch (error) { + if (error instanceof DebridAuthError) throw error // every other probe would fail too + debug(`Cache probe failed for ${hash}: ${error.message}`) + // being told to slow down, or a run of failures, ends the sweep. The rest stay + // unknown and are asked about again later rather than being called uncached + if (error?.status === 429 || ++failures >= MAX_PROBE_FAILURES) break + } } - })) + } finally { + this.sweeping = false + } return { cached, checked } } - /** Runs one probe, sharing a single request with any caller already waiting on that hash. */ + /** + * Runs one probe, sharing it with any caller already waiting on that hash, and applies the + * rule for what counts as an answer: a hit is one, and so is a definite "not cached". + * Nothing else is — a timeout, a rate limit or a dropped connection says something about the + * moment rather than the release, so it is left unremembered and re-checkable. + * @param {string} hash + * @returns {Promise} + */ #probe (hash) { let pending = this.probes.get(hash) if (!pending) { pending = this.probeCached(hash) + .catch(error => { + if (!(error instanceof DebridNotCachedError)) throw error + return false + }) .then(result => { this.remember(hash, result) return result @@ -396,25 +466,28 @@ export default class DebridService { return pending } - /** - * Asks the service about many releases at once. Implement this for any API that exposes a - * cache endpoint, and set `cacheCheck` to 'batch': it is one request instead of dozens. - * @abstract - * @param {string[]} hashes - Lowercase info hashes. - * @returns {Promise>} The subset the service can stream instantly. - */ - async checkCachedBatch (hashes) { throw new DebridNotImplementedError(this.config.title) } - /** * Determines whether one release is cached, for services with no cache endpoint. - * Implementations must leave the account exactly as they found it, and must resolve - * false rather than throwing when the answer is simply "no". + * Implementations must leave the account exactly as they found it. + * + * Answer `true`, or `false`/`DebridNotCachedError` when the service really does not hold it. + * Let everything else throw: the base class reads any other error as "no answer", which is + * what stops a bad minute on the wire from blanking out a whole results list. * @abstract * @param {string} hash - Lowercase info hash. * @returns {Promise} */ async probeCached (hash) { throw new DebridNotImplementedError(this.config.title) } + /** + * Asks the service about many releases at once. Implement this for any API that exposes a + * cache endpoint, and set `cacheCheck` to 'batch'. Chunking to `maxBatch` is already done. + * @abstract + * @param {string[]} hashes - Lowercase info hashes. + * @returns {Promise>} The subset the service can stream instantly. + */ + async checkCachedBatch (hashes) { throw new DebridNotImplementedError(this.config.title) } + /** * Verifies the API key and that the account can stream torrents. * @abstract @@ -423,9 +496,8 @@ export default class DebridService { async validate () { throw new DebridNotImplementedError(this.config.title) } /** - * Lists info hashes that are already downloaded on the account, used for instant playback badges. - * Services with a real cache-check endpoint can answer this far more completely than - * Real-Debrid can, the app treats the result as a hint either way. + * Lists info hashes the account already holds, which stream instantly. This is the badge + * source for services with no cache endpoint, so it should cover the whole account. * @abstract * @returns {Promise} Lowercase info hashes. */ @@ -444,7 +516,11 @@ export default class DebridService { /** Cancels queued requests, the instance must not be used afterwards. */ destroy () { this.cacheState.clear() + this.sweeping = false + // probes already running own a torrent on the user's account until they tear it down, so + // the limiter has to outlive them. Dropping its queue first is what strands one there. + const pending = [...this.probes.values()] this.probes.clear() - this.limiter.stop({ dropWaitingJobs: true }).catch(() => {}) + Promise.allSettled(pending).finally(() => this.limiter.stop({ dropWaitingJobs: true }).catch(() => {})) } } diff --git a/common/modules/util.js b/common/modules/util.js index 48dadf7f..b0eabf4a 100644 --- a/common/modules/util.js +++ b/common/modules/util.js @@ -747,7 +747,6 @@ export const defaults = { * @property {any} [stagingTorrents] * @property {any} [seedingTorrents] * @property {any} [completedTorrents] - * @property {Record>} [debridResolvedHashes] * @property {string} posMiniplayer * @property {string} widthMiniplayer */ @@ -760,7 +759,6 @@ export const generalDefaults = { stagingTorrents: [], seedingTorrents: [], completedTorrents: [], - debridResolvedHashes: {}, posMiniplayer: 'bottom right', widthMiniplayer: '0px' } diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index 5302cf64..3ad6d483 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -55,7 +55,7 @@ - + {/if} From 49f89d7044a52bc174493c7b057c890ae70c2d48 Mon Sep 17 00:00:00 2001 From: zeroz Date: Mon, 10 Aug 2026 06:05:26 -0400 Subject: [PATCH 07/11] change debrid avail architecture and test torbox --- .../torrent/components/TorrentCard.svelte | 24 +- .../torrent/components/TorrentResults.svelte | 49 +-- common/modules/debrid/alldebrid.js | 6 +- common/modules/debrid/availability.js | 97 ++++++ common/modules/debrid/debrid.js | 147 +++++--- common/modules/debrid/metadata.js | 3 +- common/modules/debrid/premiumize.js | 6 +- common/modules/debrid/realdebrid.js | 143 ++++++-- common/modules/debrid/route.js | 35 +- common/modules/debrid/service.js | 318 ++++++++++++------ common/modules/debrid/torbox.js | 287 +++++++++++++++- common/modules/util.js | 2 +- common/routes/settings/tabs/AppTab.svelte | 2 +- common/routes/settings/tabs/DebridTab.svelte | 28 +- 14 files changed, 910 insertions(+), 237 deletions(-) create mode 100644 common/modules/debrid/availability.js diff --git a/common/modals/torrent/components/TorrentCard.svelte b/common/modals/torrent/components/TorrentCard.svelte index e8722a4b..b30f64bb 100644 --- a/common/modals/torrent/components/TorrentCard.svelte +++ b/common/modals/torrent/components/TorrentCard.svelte @@ -6,9 +6,19 @@ import { getEpisodeMetadataForMedia, getKitsuMappings } from '@/modules/anime/anime.js' import { copyToClipboard } from '@/modules/lib/clipboard.js' import { malDubs } from '@/modules/anime/animedubs.js' - import { debridEnabled, debridCachedHashes, debridTransport } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridAvailability, debridTransport } from '@/modules/debrid/debrid.js' + import { Availability, availabilityOf, describeAvailability } from '@/modules/debrid/availability.js' import { settings } from '@/modules/settings.js' - import { Database, BadgeCheck, HardDrive, FileQuestion, AlertCircle, TriangleAlert, Cloud } from 'lucide-svelte' + import { Database, BadgeCheck, HardDrive, FileQuestion, AlertCircle, TriangleAlert, Cloud, CloudDownload, CloudOff, CloudAlert } from 'lucide-svelte' + + // one badge per availability state, so a glance at the list separates what streams instantly + // from what the service would have to fetch, from what it cannot serve at all + const availabilityBadges = { + [Availability.CACHED]: { icon: Cloud, style: 'background: hsla(var(--primary-color-dim-hsl), .15); border-color: var(--primary-color-light) !important; color: var(--primary-color-light)' }, + [Availability.AVAILABLE]: { icon: CloudDownload, style: 'background: hsla(var(--warning-color-dim-hsl), .15); border-color: var(--warning-color-dim) !important; color: var(--warning-color-dim)' }, + [Availability.UNAVAILABLE]: { icon: CloudOff, style: 'background: hsla(var(--danger-color-dim-hsl), .15); border-color: var(--danger-color-light) !important; color: var(--danger-color-light)' }, + [Availability.UNKNOWN]: { icon: CloudAlert, style: 'background: hsla(var(--white-color-dim-hsl), .08); border-color: var(--white-color-very-dim) !important; color: var(--white-color-dim)' } + } const { reactive, init } = createListener(['torrent-button', 'torrent-safe-area']) init(true) @@ -355,6 +365,10 @@ $: errorType = type === 'error' ? (result.title?.match(/no results/i) || result.title?.match(/extension is not enabled/i) ? 'warning' : 'error') : '' + $: availability = availabilityOf($debridAvailability, result.hash) + $: availabilityBadge = availabilityBadges[availability] + $: availabilityTitle = describeAvailability(availability, $debridTransport?.title).description + let card $: updateGlowColor(countdown) function updateGlowColor(value) { @@ -448,9 +462,9 @@
{since(new Date(result.date))}
- {#if $debridEnabled && $debridCachedHashes.has(result.hash?.toLowerCase())} -
- + {#if $debridEnabled && result.hash} +
+
{/if} {#if result.type === 'best'} diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index 2a1e7fc6..2f044f5c 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -10,7 +10,8 @@ import { anitomyscript, getMediaMaxEp, getKitsuMappings, getEpisodeMetadataForMedia } from '@/modules/anime/anime.js' import { loadedTorrent, completedTorrents, seedingTorrents, stagingTorrents } from '@/modules/torrent.js' import { dedupe, getTorrentResults, updatePeerCounts } from '@/modules/extensions/handler.js' - import { debridEnabled, debridCachedHashes, debridTransport, debridChecking, refreshDebridCache, checkDebridCache } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridAvailability, debridTransport, debridChecking, refreshDebridAvailability, checkDebridAvailability } from '@/modules/debrid/debrid.js' + import { Availability, AVAILABILITY_ORDER, availabilityOf, describeAvailability } from '@/modules/debrid/availability.js' import { listResult } from '@/modules/debrid/route.js' import { getId, getHash } from '@/modules/anime/animehash.js' import AnimeResolver from '@/modules/anime/animeresolver.js' @@ -114,33 +115,34 @@ const sameOrder = (a, b) => a.length === b.length && a.every((entry, index) => entry === b[index]) /** - * Builds the function that splits sorted results into what is listed and what is hidden. - * Kept apart from the sorting above so a debrid cache answer only redoes these passes, not - * the dedupe and sort of every result. The previous split is remembered in a closure rather - * than a component variable, so it stays out of the reactive graph. - * @returns {(sorted: Result[], debridHashes?: Set, cachedOnly?: boolean) => any} + * Builds the function that splits sorted results into what is listed and what is hidden, and + * tallies what the debrid service said about each. Kept apart from the sorting above so a + * debrid answer only redoes these passes, not the dedupe and sort of every result. The + * previous split is remembered in a closure rather than a component variable, so it stays out + * of the reactive graph. + * @returns {(sorted: Result[], availability?: Map, filters?: { cachedOnly?: boolean, only?: boolean }) => any} */ function createListResults() { let previous = null - return function listResults(sorted, debridHashes, cachedOnly) { + return function listResults(sorted, availability, filters) { const results = [] const hiddenResults = [] - let cachedCount = 0 + const counts = Object.fromEntries(AVAILABILITY_ORDER.map(state => [state, 0])) for (const entry of sorted) { - const cached = Boolean(debridHashes?.has(entry.hash?.toLowerCase())) - if (cached) cachedCount++ + const state = availability ? availabilityOf(availability, entry.hash) : Availability.UNKNOWN + counts[state]++ // this narrows what the rest of the modal sees, so the best pick and autoplay follow // it too, which is the whole point in debrid only mode - if (listResult(entry, cached, cachedOnly)) results.push(entry) + if (listResult(entry, state, filters)) results.push(entry) else hiddenResults.push(entry) } - // most cache answers only move the count, since a release with seeders was listed either - // way. Handing back the same arrays then keeps the best-release pick from being redone, - // which reparses every result and is what made answers landing feel like a freeze. + // most answers only move the counts, since a release with seeders was listed either way. + // Handing back the same arrays then keeps the best-release pick from being redone, which + // reparses every result and is what made answers landing feel like a freeze. if (previous && sameOrder(previous.results, results) && sameOrder(previous.hiddenResults, hiddenResults)) { - return { ...previous, cachedCount } + return { ...previous, counts } } - return (previous = { sorted, cachedCount, results, hiddenResults }) + return (previous = { sorted, counts, results, hiddenResults }) } } @@ -280,7 +282,7 @@ async function queryExtensions(request, resolution) { scrollTop() - if ($debridEnabled) refreshDebridCache() + if ($debridEnabled) refreshDebridAvailability() $results = {} const cachedHashes = [] for (const resolvedHash of getHash(search?.media?.id, { episode: search?.episode, client: true, batchGuess: true }, false, true, true) ?? []) { @@ -364,12 +366,15 @@ $: queries = queryExtensions({...search}, resolution) $: errors = getErrors({...search}, queries) $: cachedOnly = $debridEnabled && $settings.debridCachedOnly + $: debridFilters = { cachedOnly, only: $debridEnabled && Boolean($debridTransport?.only) } $: sortedResults = sortResults($results?.torrents, $settings.torrentSort, batch) - // confirm cache state from the top of the list down, which is where the releases worth + // ask about the results from the top of the list down, which is where the releases worth // playing are. How far it reaches is the service's call: one request for a service with a // cache endpoint, a handful of probes for one without. - $: if ($debridEnabled && $results?.resolved) checkDebridCache(sortedResults.map(result => result.hash)) - $: queryResults = listResults(sortedResults, $debridEnabled ? $debridCachedHashes : undefined, cachedOnly) + $: if ($debridEnabled && $results?.resolved) checkDebridAvailability(sortedResults.map(result => result.hash)) + $: queryResults = listResults(sortedResults, $debridEnabled ? $debridAvailability : undefined, debridFilters) + // every state and its count, for the tooltip on the cached filter + $: availabilitySummary = AVAILABILITY_ORDER.map(state => `${queryResults?.counts?.[state] ?? 0} ${describeAvailability(state, $debridTransport?.title).label}`).join(' · ') $: lookup = queryResults?.results $: (episodeSearch || resolution || $settings.torrentSort || $settings.audioLanguage) && scrollTop() @@ -524,9 +529,9 @@ {/if} {#if $debridEnabled} {/if}
diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js index b4f0e733..eed44796 100644 --- a/common/modules/debrid/alldebrid.js +++ b/common/modules/debrid/alldebrid.js @@ -6,10 +6,10 @@ import DebridService from './service.js' * * Implementation template: the base class already provides authentication, rate * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listCachedHashes`, `resolve` and `checkCachedBatch` here + * means writing `validate`, `listAvailability`, `resolve` and `checkAvailabilityBatch` here * and flipping `available` to true. Nothing outside this file has to change. Useful endpoints: * - GET /user -> account and premium status for validate() - * - GET /magnet/status -> account magnets for listCachedHashes() + * - GET /magnet/status -> account magnets for listAvailability() * - GET /magnet/upload -> add a magnet (`magnets[]=`), the `instant` flag reports cache state * - GET /link/unlock -> direct stream URL per file (`link=`) */ @@ -18,5 +18,5 @@ export default class AllDebrid extends DebridService { static title = 'AllDebrid' static auth = 'query' // the upload response carries an `instant` flag per magnet, so a batch check is possible - static cacheCheck = 'batch' + static availabilityCheck = 'batch' } diff --git a/common/modules/debrid/availability.js b/common/modules/debrid/availability.js new file mode 100644 index 00000000..f9472075 --- /dev/null +++ b/common/modules/debrid/availability.js @@ -0,0 +1,97 @@ +// The vocabulary the whole debrid layer uses to describe a release. Pure data and pure +// functions, free of UI and network imports, so it runs under plain Node for tests. + +/** + * What a debrid service can do with a release right now. + * + * Services differ wildly in how well they can answer this: some expose a cache endpoint that + * answers hundreds of hashes in one request, some have to be probed a hash at a time, some + * cannot be asked at all. They all describe themselves with these four values, so the rest of + * the app never has to care which kind it is talking to. + */ +export const Availability = Object.freeze({ + /** The service holds it and streams it immediately. */ + CACHED: 'cached', + /** The service does not hold it but can fetch it, which takes longer than playback will wait. */ + AVAILABLE: 'available', + /** The service cannot serve it at all: a dead magnet, a rejected release, a failed download. */ + UNAVAILABLE: 'unavailable', + /** Nobody asked, or nothing came back. Never report this as "not cached", it is an absence of an answer. */ + UNKNOWN: 'unknown' +}) + +/** Every state, best first. The order badges and counters are shown in. */ +export const AVAILABILITY_ORDER = Object.freeze([Availability.CACHED, Availability.AVAILABLE, Availability.UNKNOWN, Availability.UNAVAILABLE]) + +/** + * How long an answer stays trusted, in milliseconds. + * + * A hit lasts far longer than a miss: anyone can pull a release into a service's cache at any + * moment, but a release it already holds rarely disappears. Unknown is not an answer, so it is + * never stored and never expires. + */ +export const AVAILABILITY_TTL = Object.freeze({ + [Availability.CACHED]: 6 * 60 * 60_000, + [Availability.AVAILABLE]: 20 * 60_000, + [Availability.UNAVAILABLE]: 30 * 60_000, + [Availability.UNKNOWN]: 0 +}) + +const states = new Set(Object.values(Availability)) + +/** + * @param {any} value + * @returns {value is Availability[keyof Availability]} + */ +export function isAvailability (value) { + return states.has(value) +} + +/** + * Anything that is not one of the four states reads as unknown, so a service returning + * something unexpected degrades to "no answer" rather than poisoning the badges. + * @param {any} value + * @returns {string} + */ +export function normalizeAvailability (value) { + return isAvailability(value) ? value : Availability.UNKNOWN +} + +/** + * Whether playback can start on this release now. The one question the player asks. + * @param {string} state + */ +export function streamsInstantly (state) { + return state === Availability.CACHED +} + +/** + * Reads a hash's state out of an availability map, defaulting to unknown. + * Callers hold magnets and mixed-case hashes, the map is keyed by lowercase info hash. + * @param {Map | undefined} availability + * @param {string | undefined} hash + * @returns {string} + */ +export function availabilityOf (availability, hash) { + return (hash && availability?.get(String(hash).toLowerCase())) || Availability.UNKNOWN +} + +/** + * How a state is worded for the user. Kept here rather than in the components so the four + * states read consistently wherever they appear, and so the wording is testable. + * @param {string} state + * @param {string} [title] - The service's display name. + * @returns {{ label: string, description: string }} + */ +export function describeAvailability (state, title = 'your debrid service') { + switch (state) { + case Availability.CACHED: + return { label: 'Cached', description: `Cached on ${title}, streams instantly with no torrent peers involved.` } + case Availability.AVAILABLE: + return { label: 'Available', description: `${title} can fetch this release but does not hold it yet, so it cannot stream right now.` } + case Availability.UNAVAILABLE: + return { label: 'Unavailable', description: `${title} cannot serve this release at all.` } + default: + return { label: 'Unchecked', description: `${title} has not been asked about this release. It may still stream.` } + } +} diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index f74e32f5..fe10161c 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -10,8 +10,9 @@ import RealDebrid from '@/modules/debrid/realdebrid.js' import AllDebrid from '@/modules/debrid/alldebrid.js' import TorBox from '@/modules/debrid/torbox.js' import Premiumize from '@/modules/debrid/premiumize.js' -import DebridService, { DebridNotCachedError, secureFiles } from '@/modules/debrid/service.js' -import { routeDebrid } from '@/modules/debrid/route.js' +import DebridService, { availabilityFromError, secureFiles } from '@/modules/debrid/service.js' +import { Availability, describeAvailability } from '@/modules/debrid/availability.js' +import { routeDebrid, debridKey } from '@/modules/debrid/route.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -39,7 +40,7 @@ let serviceKey = null let lastRefresh = 0 /** Whether a debrid service is selected and has an API key. */ -export const debridEnabled = derived(settings, value => Boolean(debridServices[value.debridService] && value.debridApiKey)) +export const debridEnabled = derived(settings, value => Boolean(debridServices[value.debridService] && debridKey(value))) /** * How playback is routed right now, or null when no debrid service is selected. @@ -59,10 +60,14 @@ export const debridTransport = derived(settings, value => { } }) -/** Lowercase info hashes known to play instantly on the configured service. */ -export const debridCachedHashes = writable(new Set()) +/** + * What the configured service can do with each release, keyed by lowercase info hash. + * The one place the UI reads cache state from; anything absent is simply unknown. + * @type {import('simple-store-svelte').Writable>} + */ +export const debridAvailability = writable(new Map()) -/** Cache checks in flight, so the UI can show that badges are still filling in. */ +/** Availability checks in flight, so the UI can show that badges are still filling in. */ export const debridChecking = writable(0) /** @@ -73,13 +78,16 @@ export const debridChecking = writable(0) */ export const debridPlayback = writable(false) +// Switching service, or editing the key of the one in use, takes effect immediately: the old +// instance is torn down and the badges are dropped, since they described a different account. +// The next call builds the new one. settings.subscribe(value => { - const key = `${value.debridService}:${value.debridApiKey}` + const key = `${value.debridService}:${debridKey(value)}` if (serviceKey !== null && serviceKey !== key) { service?.destroy() service = null lastRefresh = 0 - debridCachedHashes.set(new Set()) + debridAvailability.set(new Map()) } serviceKey = key }) @@ -87,9 +95,10 @@ settings.subscribe(value => { function getService () { if (service) return service const Service = debridServices[settings.value.debridService] - if (!Service || !settings.value.debridApiKey) return null + const apiKey = debridKey(settings.value) + if (!Service || !apiKey) return null debug(`Initializing debrid service ${Service.title}`) - service = new Service(settings.value.debridApiKey) + service = new Service(apiKey) return service } @@ -133,14 +142,18 @@ export async function streamDebrid (torrentID, hash, search) { files.set(await resolveDebridFiles(route.id, search)) return true } catch (error) { - if (error instanceof DebridNotCachedError) { - debug(`Torrent not cached: ${error.message}`) - forgetHash(route.id) // the badge was wrong, or it aged out of the cache + // playback is the most authoritative answer there is, so whatever it just proved about + // the release is worth more than the badge that sent the user here + const proven = availabilityFromError(error) + if (proven) { + debug(`${serviceTitle()} cannot stream this release: ${error.message}`) + recordAvailability(route.id, proven) + const { description } = describeAvailability(proven, serviceTitle()) if (!debridOnly) { - toast('Debrid', { description: 'Not cached on ' + serviceTitle() + ', streaming via torrent instead.' }) + toast('Debrid', { description: `${description}\nStreaming via torrent instead.` }) return handOver(false) } - toast.error('Debrid', { description: 'This torrent is not cached on ' + serviceTitle() + '. Pick a different release or disable debrid only mode.' }) + toast.error('Debrid', { description: `${description}\nPick a different release or disable debrid only mode.` }) } else { debug('Debrid resolve failed:', error) if (!debridOnly) { @@ -176,9 +189,8 @@ export async function resolveDebridFiles (torrentID, search) { }) const files = secureFiles(resolved.files, serviceTitle()) if (files.length !== resolved.files.length) debug(`Discarded ${resolved.files.length - files.length} non-HTTPS links from ${serviceTitle()}`) - // playing it proves the service holds it, which is the best cache answer there is - service.remember(resolved.hash, true) - debridCachedHashes.update(set => new Set(set).add(resolved.hash)) + // playing it proves the service holds it, which is the best answer there is + recordAvailability(resolved.hash, Availability.CACHED) return Promise.all(files.map(async file => ({ infoHash: resolved.hash, fileHash: await sha1hex(`${resolved.hash}:${file.name}:${file.size}`), // same key the torrent client uses, so watch progress is shared @@ -193,17 +205,18 @@ export async function resolveDebridFiles (torrentID, search) { } /** - * Refreshes the badge data every service can supply for free: the torrents already on the - * account, which stream instantly. One request a minute at most. + * Refreshes what the account itself says, which every service can answer for free: what it + * holds streams instantly, what it is still fetching does not, what failed on it never will. + * One request a minute at most. */ -export function refreshDebridCache () { - const service = getService() - if (!service) return +export function refreshDebridAvailability () { + const active = getService() + if (!active) return if (Date.now() - lastRefresh < REFRESH_INTERVAL || status.value === 'offline') return lastRefresh = Date.now() - service.listCachedHashes().then(hashes => { - debridCachedHashes.update(set => new Set([...set, ...hashes])) - for (const hash of hashes) service.remember(hash, true) + active.listAvailability().then(known => { + for (const [hash, state] of known) active.remember(hash, state) + if (current(active)) publishAvailability(known) }).catch(error => { lastRefresh = 0 debug('Failed to list debrid torrents:', error) @@ -211,25 +224,33 @@ export function refreshDebridCache () { } /** - * Confirms cache state for the releases the user is looking at, so the badges say what the - * service can actually stream rather than only what this account has touched before. The - * service decides how: one batch call where its API offers a cache endpoint, a capped number - * of probes where it does not. Answers are remembered, so browsing the same show again is free. + * Whether answers from this instance still describe the configured account. A request in flight + * outlives a settings change — a probe sweep by seconds, a slow list by longer — and badging a + * new account with the previous one's answers is worse than having no badges at all. + * @param {import('@/modules/debrid/service.js').default} instance + */ +function current (instance) { + return instance === service +} + +/** + * Asks the service about the releases the user is looking at, so the badges say what it can + * actually do with them rather than only what this account has touched before. The service + * decides how: one batch call where its API offers a cache endpoint, a capped number of probes + * where it does not. Answers are remembered, so browsing the same show again is free. * @param {string[]} hashes - Candidate info hashes, most relevant first, since probing bites from the front. */ -export async function checkDebridCache (hashes) { - const service = getService() - if (!service || !settings.value.debridCacheCheck || status.value === 'offline') return - if (!service.unknownHashes(hashes).length) return // everything here already has an answer +export async function checkDebridAvailability (hashes) { + const active = getService() + if (!active || !settings.value.debridCacheCheck || status.value === 'offline') return + if (!active.unknownHashes(hashes).length) return // everything here already has an answer debridChecking.update(count => count + 1) try { // badge each release as its answer lands rather than when the sweep ends, so a probing // service marks the list up as it goes instead of all at once a minute later - await service.checkCached(hashes, { - onAnswer: (hash, hit) => { if (hit) debridCachedHashes.update(set => new Set(set).add(hash)) } - }) + await active.checkAvailability(hashes, { onAnswer: (hash, state) => { if (current(active)) queueAvailability(hash, state) } }) } catch (error) { - debug('Cache check failed:', error) + debug('Availability check failed:', error) } finally { debridChecking.update(count => count - 1) } @@ -259,17 +280,53 @@ function serviceTitle () { } /** - * Drops a hash the service turned out not to hold, so the next search does not badge it - * again and fail playback the same way a second time. + * Records one answer in both the service's memory and the badges, so the next search does not + * repeat a check playback has already settled. * @param {string} magnetOrHash + * @param {string} state - An `Availability` value. */ -function forgetHash (magnetOrHash) { +function recordAvailability (magnetOrHash, state) { const hash = DebridService.parseHash(magnetOrHash) if (!hash) return - service?.remember(hash, false) - debridCachedHashes.update(set => { - const next = new Set(set) - next.delete(hash) + service?.remember(hash, state) + publishAvailability([[hash, state]]) +} + +/** @type {Map | null} Answers waiting to reach the store. */ +let queued = null + +/** + * Collects answers arriving in one go into a single store write. A batch service answers a + * whole results list inside one loop, and writing per hash would re-render the list as many + * times; a probing service answers once every few seconds, so each still lands on its own. + * @param {string} hash + * @param {string} state + */ +function queueAvailability (hash, state) { + if (!queued) { + queued = new Map() + queueMicrotask(() => { + const answers = queued + queued = null + publishAvailability(answers) + }) + } + queued.set(hash, state) +} + +/** + * Publishes answers to the UI in one write. + * @param {Iterable<[string, string]>} answers + */ +function publishAvailability (answers) { + const entries = [...answers] + if (!entries.length) return + debridAvailability.update(known => { + const next = new Map(known) + for (const [hash, state] of entries) { + if (state === Availability.UNKNOWN) next.delete(hash) + else next.set(hash, state) + } return next }) } diff --git a/common/modules/debrid/metadata.js b/common/modules/debrid/metadata.js index 61fd9668..49ab670e 100644 --- a/common/modules/debrid/metadata.js +++ b/common/modules/debrid/metadata.js @@ -173,7 +173,8 @@ export default class DebridMetadata { * nothing. The player renderer deduplicates events, so overlapping parses are safe. */ async #pace (byteRate, start, offset) { - while (!this.destroyed && byteRate) { + if (!byteRate) return offset // no duration to estimate from, so read straight through + while (!this.destroyed) { const position = this.getTime() * byteRate const jump = Math.max(0, Math.floor(position - JUMP_BACK_SECONDS * byteRate)) // a target beyond the file means the estimate overshot, sequential reading covers it diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js index ba2f9f2d..bb4fdfed 100644 --- a/common/modules/debrid/premiumize.js +++ b/common/modules/debrid/premiumize.js @@ -6,10 +6,10 @@ import DebridService from './service.js' * * Implementation template: the base class already provides authentication, rate * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listCachedHashes`, `resolve` and `checkCachedBatch` here + * means writing `validate`, `listAvailability`, `resolve` and `checkAvailabilityBatch` here * and flipping `available` to true. Nothing outside this file has to change. Useful endpoints: * - GET /account/info -> account and premium status for validate() - * - GET /transfer/list -> account transfers for listCachedHashes() + * - GET /transfer/list -> account transfers for listAvailability() * - GET /cache/check -> Premiumize still offers a real cache check (`items[]=`) * - POST /transfer/directdl -> direct stream URLs for a magnet in one call (`src=`) */ @@ -18,5 +18,5 @@ export default class Premiumize extends DebridService { static title = 'Premiumize' static auth = 'query' // /cache/check answers for many hashes at once, so badges cost one request - static cacheCheck = 'batch' + static availabilityCheck = 'batch' } diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index 11332591..cef95f52 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -1,5 +1,6 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, archiveRx } from './service.js' +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, DebridUnavailableError, archiveRx } from './service.js' +import { Availability } from './availability.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -7,10 +8,26 @@ const API = 'https://api.real-debrid.com/rest/1.0' // the account's torrent list comes back in one request, newest first. Accounts larger than // this keep their most recent torrents badged, which is the half anyone is browsing. const LIST_LIMIT = 1_000 -// statuses that mean the torrent will never complete -const deadStatuses = ['magnet_error', 'error', 'virus', 'dead'] -// statuses that mean the torrent is being fetched fresh, so it was never cached -const downloadingStatuses = ['queued', 'downloading', 'uploading', 'compressing'] + +/** + * What each Real-Debrid torrent status means for playback. Statuses left out — magnet + * conversion and file selection — are moments in a torrent's life rather than outcomes, + * so they answer nothing and leave the release unknown. + * @type {Record} + */ +const statusAvailability = { + downloaded: Availability.CACHED, + // being fetched fresh, so Real-Debrid can serve it eventually but not now + queued: Availability.AVAILABLE, + downloading: Availability.AVAILABLE, + uploading: Availability.AVAILABLE, + compressing: Availability.AVAILABLE, + // will never complete + magnet_error: Availability.UNAVAILABLE, + error: Availability.UNAVAILABLE, + virus: Availability.UNAVAILABLE, + dead: Availability.UNAVAILABLE +} // https://api.real-debrid.com/ error_code values worth explaining, anything else // falls back to the message the API sends @@ -31,8 +48,8 @@ const authCodes = [8, 9] * * Two quirks of the live API shape this client: * - `/torrents/instantAvailability` is disabled (403 `disabled_endpoint`), so the only way to - * ask whether a release is cached is to add the magnet and read the status back. That is - * what `probeCached` does, and why the base class caps how many of them a search may cost. + * ask about a release is to add the magnet and read the status back. That is what + * `probeAvailability` does, and why the base class caps how many of them a search may cost. * - Selecting multiple files can serve a single RAR archive instead of individual links, so * when that happens the torrent is re-added selecting only the target file. */ @@ -42,8 +59,8 @@ export default class RealDebrid extends DebridService { static available = true // documented allowance is 250 requests per minute, keep some headroom static limits = { reservoir: 200, reservoirRefreshAmount: 200, reservoirRefreshInterval: 60_000, maxConcurrent: 4, minTime: 150 } - // no cache endpoint any more, so cache state has to be probed a hash at a time - static cacheCheck = 'probe' + // no cache endpoint any more, so availability has to be probed a hash at a time + static availabilityCheck = 'probe' mapError (status, json) { const code = json?.error_code @@ -60,38 +77,48 @@ export default class RealDebrid extends DebridService { return { username: user.username, expires: user.expiration } } - /** The account's torrents, the one list both cache badges and torrent reuse read from. */ - async #accountTorrents () { + /** + * The whole account in one request. The base class shares this between the badge refresh and + * playback, so a search followed by a play reads it once rather than twice. + */ + async fetchListing () { return (await this.request(`${API}/torrents?limit=${LIST_LIMIT}`)) || [] } - async listCachedHashes () { - const torrents = await this.#accountTorrents() - return torrents.filter(torrent => torrent.status === 'downloaded').map(torrent => torrent.hash.toLowerCase()) + async listAvailability () { + const torrents = await this.listing() + const known = new Map() + for (const torrent of torrents) { + const state = statusAvailability[torrent.status] + if (state && torrent.hash) known.set(torrent.hash.toLowerCase(), state) + } + return known } /** - * Finds out whether Real-Debrid can stream a release right now, the only way it still can be - * asked: add the magnet and read the status it settles on. A cached torrent reports - * 'downloaded' within a second or so of file selection, anything else is being fetched fresh. - * Costs about five requests and a few seconds, hence the cap in the base class. + * Finds out what Real-Debrid can do with a release, the only way it still can be asked: add + * the magnet and read the status it settles on. A cached torrent reports 'downloaded' within + * a second or so of file selection, anything else is being fetched fresh or is not something + * Real-Debrid can take at all. Costs about five requests and a few seconds, hence the cap in + * the base class. * * The torrent is always removed again. Adding a hash the account already holds creates a * separate entry with its own id, so this can never delete the user's own download. * - * Nothing here decides what a failure means: `#awaitStatus` raises DebridNotCachedError for - * the states that really are a no, and any other error travels up as "no answer at all". + * Nothing here decides what a failure means: `#awaitStatus` raises the typed errors that + * carry an answer, and any other error travels up as "no answer at all". * @param {string} hash - * @returns {Promise} + * @returns {Promise} */ - async probeCached (hash) { + async probeAvailability (hash) { const magnetURI = RealDebrid.toMagnet(hash) if (!magnetURI) throw new DebridError('Not a usable info hash') // no answer, rather than a made up one const timeout = this.config.timeouts.probe let torrentId = null try { torrentId = await this.#addAndSelect(magnetURI, () => true, undefined, timeout) - return (await this.#awaitStatus(torrentId, 'downloaded', timeout)).status === 'downloaded' + await this.#awaitStatus(torrentId, 'downloaded', timeout) + return Availability.CACHED } finally { // awaited, so the probe has genuinely left the account as it found it by the time it // answers. Playback waits on this before reusing a torrent, and teardown waits on it @@ -110,20 +137,23 @@ export default class RealDebrid extends DebridService { // finish first rather than reusing an id that is seconds from disappearing await this.probes.get(hash)?.catch(() => {}) // reuse a torrent that is already on the account instead of adding a duplicate - const existing = hash && (await this.#accountTorrents()).find(torrent => torrent.hash.toLowerCase() === hash) + const existing = await this.#existingTorrent(hash) + let info = null if (existing?.status === 'waiting_files_selection') { // a stale add that never got its files selected, finish the job - const info = await this.request(`${API}/torrents/info/${existing.id}`) - const ids = info.files.filter(file => fileFilter(file.path)).map(file => file.id) + const ids = existing.files.filter(file => fileFilter(file.path)).map(file => file.id) await this.request(`${API}/torrents/selectFiles/${existing.id}`, { method: 'POST', body: { files: ids.length ? ids.join(',') : 'all' } }) torrentId = existing.id - } else if (existing && existing.status !== 'downloaded') throw new DebridNotCachedError() - else if (existing) torrentId = existing.id - else { + // mid-conversion counts as not cached here: playback cannot wait for it either way + } else if (existing && existing.status !== 'downloaded') throw unstreamable(existing.status) ?? new DebridNotCachedError() + else if (existing) { + torrentId = existing.id + info = existing // already confirmed downloaded, with its files and links + } else { torrentId = await this.#addAndSelect(magnetURI, fileFilter) added = true } - let info = await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) + info ??= await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) // work out which single file playback is really after before unrestricting, so a // capped pack never drops the wanted episode, and so archives and reused torrents @@ -153,6 +183,31 @@ export default class RealDebrid extends DebridService { } } + /** + * The account's current entry for an info hash, or null when it does not hold one. + * + * The listing behind this can be up to a minute old, so the entry it names is read back from + * the API before playback acts on its id: a torrent deleted from another device in the + * meantime has to read as "not on the account" and be added again, not fail the resolve with + * an id that no longer exists. The read is also what makes the reuse path cheap — it returns + * the files and links, so nothing else has to be fetched. + * @param {string} hash + * @returns {Promise} + */ + async #existingTorrent (hash) { + if (!hash) return null + const listed = (await this.listing()).find(torrent => torrent.hash?.toLowerCase() === hash) + if (!listed) return null + try { + return await this.request(`${API}/torrents/info/${listed.id}`) + } catch (error) { + if (error.status !== 404) throw error + debug(`Account listing named a torrent that is gone (${listed.id}), adding the magnet instead`) + this.forgetListing() + return null + } + } + /** * Adds a magnet and selects either the files matching the filter or one specific file. * @param {string} magnetURI @@ -163,6 +218,7 @@ export default class RealDebrid extends DebridService { */ async #addAndSelect (magnetURI, fileFilter, fileId, timeout = this.config.timeouts.select) { const torrentId = (await this.request(`${API}/torrents/addMagnet`, { method: 'POST', body: { magnet: magnetURI } }))?.id + this.forgetListing() // the account has a torrent the remembered listing does not try { const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', timeout) if (info.status === 'waiting_files_selection') { @@ -217,15 +273,28 @@ export default class RealDebrid extends DebridService { while (true) { const info = await this.request(`${API}/torrents/info/${id}`) if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info - // a torrent the service cannot process is one it will never stream, which for playback - // is the same answer as uncached: fall back to the torrent client rather than error out - if (deadStatuses.includes(info.status)) throw new DebridNotCachedError(`Real-Debrid could not process this torrent (${info.status})`) - if (downloadingStatuses.includes(info.status)) throw new DebridNotCachedError() - // deliberately not a "not cached" answer: a rare or old release can sit in - // magnet_conversion for a while, and calling that a miss is what empties the badges on - // exactly those titles. No answer means the release stays unknown and re-checkable. + const settled = unstreamable(info.status) + if (settled) throw settled + // deliberately not an answer at all: a rare or old release can sit in magnet_conversion + // for a while, and calling that a miss is what empties the badges on exactly those + // titles. No answer means the release stays unknown and re-checkable. if (Date.now() - started > timeout) throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) } } } + +/** + * The typed answer a settled status stands for, or null while the torrent is still making up + * its mind. One mapping serves both callers: playback reads it as a reason to fall back, the + * base class reads it as the release's availability. + * @param {string} status + * @returns {import('./service.js').DebridUnstreamableError | null} + */ +function unstreamable (status) { + switch (statusAvailability[status]) { + case Availability.UNAVAILABLE: return new DebridUnavailableError(`Real-Debrid could not process this torrent (${status})`) + case Availability.AVAILABLE: return new DebridNotCachedError() + default: return null + } +} diff --git a/common/modules/debrid/route.js b/common/modules/debrid/route.js index edc7aaca..ba86cc9b 100644 --- a/common/modules/debrid/route.js +++ b/common/modules/debrid/route.js @@ -1,6 +1,7 @@ // Pure debrid policy, free of UI imports so it can be tested under plain Node. // Two decisions live here: how a play request is routed (debrid only mode must never // reach the torrent client, whatever the input), and which search results are listed. +import { Availability, streamsInstantly } from './availability.js' const magnetRx = /^magnet:.*urn:btih:[a-f\d]{40}/i const hexRx = /^[a-f\d]{40}$/i @@ -34,16 +35,40 @@ export function routeDebrid ({ torrentID, hash, serviceSelected, serviceReady, o return { action: 'resolve', id, only } } +/** + * The API key stored for a debrid service. + * + * Every service keeps its own, so switching between them in settings swaps the key rather than + * losing it, and an account on one service can never be addressed with another's key. The + * settings tab and the playback module both read through here so they cannot disagree about + * which key is in play. + * @param {{ debridApiKeys?: Record }} settings + * @param {string} [service] - Service id, defaulting to the selected one. + * @returns {string} Empty when that service has no key yet. + */ +export function debridKey (settings, service = settings?.debridService) { + return (service && settings?.debridApiKeys?.[service]) || '' +} + /** * Whether a search result belongs in the listed results rather than the hidden ones. - * With the cached filter off this is upstream's rule, widened only by the fact that a - * cached release streams without seeders. With it on, only known-cached releases list. + * + * With no filters on this is upstream's rule, widened only by the fact that a cached release + * streams without seeders. The two debrid cases that narrow it: + * - the cached filter shows nothing but confirmed cached releases; + * - debrid only mode hides releases the service has said it cannot serve, since with no + * torrent client to fall back on those cannot play at all. + * + * An *available* release is deliberately not widened in: the service would still have to pull + * it from the swarm, so a seederless one is no more playable than it was without debrid. * @param {{ seeders?: number, source?: { managed?: boolean } }} result - * @param {boolean} cached - The service is known to hold this release. - * @param {boolean} [cachedOnly] - The user asked to see cached releases only. + * @param {string} [availability] - What the service said about this release. + * @param {{ cachedOnly?: boolean, only?: boolean }} [options] - The debrid filters in force. * @returns {boolean} */ -export function listResult (result, cached, cachedOnly) { +export function listResult (result, availability, { cachedOnly, only } = {}) { + const cached = streamsInstantly(availability) if (cachedOnly) return cached + if (only && availability === Availability.UNAVAILABLE) return false return result?.seeders > 0 || Boolean(result?.source?.managed) || cached } diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index be10eccc..57b94e8d 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -1,4 +1,5 @@ import Bottleneck from 'bottleneck' +import { Availability, AVAILABILITY_TTL, normalizeAvailability } from './availability.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -33,11 +34,33 @@ export class DebridNetworkError extends DebridError { } } -/** Thrown when the service would have to download a torrent before it could stream it. */ -export class DebridNotCachedError extends DebridError { +/** + * A definite answer that playback cannot use this release now, carrying the availability it + * proves. Everything that asks a service a question — playback and cache checks alike — reads + * `availability` off the error rather than matching on error types, so a service only has to + * throw the right one and both callers behave correctly. + * @abstract + */ +export class DebridUnstreamableError extends DebridError { + /** @type {string} What this error proves about the release. */ + availability = Availability.UNKNOWN +} + +/** The service would have to download the torrent before it could stream it. */ +export class DebridNotCachedError extends DebridUnstreamableError { constructor (message = 'Torrent is not cached on the debrid service', opts) { super(message, opts) this.name = 'DebridNotCachedError' + this.availability = Availability.AVAILABLE + } +} + +/** The service cannot serve this release at all: a dead magnet, a rejected or failed torrent. */ +export class DebridUnavailableError extends DebridUnstreamableError { + constructor (message = 'The debrid service cannot serve this torrent', opts) { + super(message, opts) + this.name = 'DebridUnavailableError' + this.availability = Availability.UNAVAILABLE } } @@ -50,6 +73,19 @@ export class DebridNotImplementedError extends DebridError { } } +/** + * What an error proves about a release, or null when it proves nothing. + * + * A timeout, a rate limit or a dropped connection says something about the moment rather than + * the release, so it must leave the release unknown and re-checkable. Only the two definite + * answers count. + * @param {any} error + * @returns {string | null} + */ +export function availabilityFromError (error) { + return error instanceof DebridUnstreamableError ? normalizeAvailability(error.availability) : null +} + /** * @typedef {Object} DebridFile * @property {string} name - File name without directories. @@ -107,7 +143,7 @@ export default class DebridService { static id = '' /** @type {string} Human readable service name. */ static title = '' - /** @type {boolean} Only implemented and tested services are offered in the settings menu. */ + /** @type {boolean} Only implemented services are offered in the settings menu. */ static available = false /** @type {import('bottleneck').ConstructorOptions} Request rate limits for the service API. */ static limits = { maxConcurrent: 4, minTime: 250 } @@ -115,14 +151,16 @@ export default class DebridService { static auth = 'bearer' /** @type {string} Query parameter name used when `auth` is 'query'. */ static authParam = 'apikey' + /** @type {'form' | 'json' | 'multipart'} How request bodies are encoded, overridable per request. */ + static encoding = 'form' /** Tunable time limits in milliseconds, override only what differs for the service. */ static timeouts = { request: 30_000, // hard limit on a single HTTP request select: 12_000, // waiting for the service to accept a magnet and expose its file list ready: 5_000, // waiting for a cached torrent to report ready, anything slower is a fresh download poll: 1_000, // gap between status polls - // budget for one cache probe. Deliberately tighter than `select`: a probe that drags on - // spends requests the account needs for playback, and no answer is worth that + // budget for one availability probe. Deliberately tighter than `select`: a probe that drags + // on spends requests the account needs for playback, and no answer is worth that probe: 10_000 } @@ -130,13 +168,13 @@ export default class DebridService { static maxFiles = 60 /** - * @type {'batch' | 'probe' | 'none'} How the service can be asked whether it holds a release. + * @type {'batch' | 'probe' | 'none'} How the service can be asked about a release it has not seen. * 'batch' services answer many hashes in one cheap request, which is by far the best case. * 'probe' is for services with no cache endpoint, where the only way to find out is to add * the magnet and read the status back, costing several requests per hash. - * 'none' leaves badges to `listCachedHashes` and lets playback discover the rest. + * 'none' leaves badges to `listAvailability` and lets playback discover the rest. */ - static cacheCheck = 'none' + static availabilityCheck = 'none' /** @type {number} Hashes per batch request, so one long results list becomes a few calls. */ static maxBatch = 100 @@ -149,20 +187,26 @@ export default class DebridService { */ static maxProbes = 10 + /** @type {Record} How long each answer stays trusted, overridable per service. */ + static availabilityTTL = AVAILABILITY_TTL + /** - * How long a cache answer stays trusted, in milliseconds. A miss expires far sooner than a - * hit: anyone can pull a release into the service's cache at any moment, but a release it - * already holds rarely disappears. + * @type {number} How long the account's own torrent listing is reused before it is read again. + * Matched to how often the badges refresh, so browsing and then playing costs one read rather + * than two. */ - static cacheTTL = { hit: 6 * 60 * 60_000, miss: 20 * 60_000 } + static listingTTL = 60_000 + + /** @type {{ at: number, promise: Promise } | null} The listing read, shared by everyone waiting on it. */ + #listing = null /** @param {string} apiKey */ constructor (apiKey) { this.apiKey = apiKey this.rateLimitPromise = null - /** @type {Map} What the service has already said about a hash. */ - this.cacheState = new Map() - /** @type {Map>} Probes in flight, so a hash is never asked about twice at once. */ + /** @type {Map} What the service has already said about a hash. */ + this.availabilityState = new Map() + /** @type {Map>} Probes in flight, so a hash is never asked about twice at once. */ this.probes = new Map() /** @type {boolean} Whether a probe sweep is running, since only one may be. */ this.sweeping = false @@ -182,17 +226,57 @@ export default class DebridService { /** * Undoes something this client created on the account. Never throws: it runs from `finally`, - * where it would mask the real failure. + * where it would mask the real failure. Services whose delete is not a plain DELETE pass the + * request options they need. * @param {string} url + * @param {Parameters[1]} [opts] */ - async release (url) { + async release (url, opts) { try { - await this.request(url, { method: 'DELETE' }) + await this.request(url, { method: 'DELETE', ...opts }) } catch (error) { debug(`Cleanup failed for ${url}: ${error.message}`) + } finally { + this.forgetListing() // the account just changed, whether or not the removal worked } } + /** + * The account's own torrent listing, read at most once per `listingTTL` and shared by every + * caller waiting on it. + * + * Two things want this same list: the badge refresh, once a minute, and every resolve, which + * checks whether the account already holds the release before adding it again. Reading it per + * play put a full listing on the play path — measured at 4.6s on a 312 torrent Real-Debrid + * account — for a list the badge refresh had usually just fetched. Sharing it makes the + * common case free, and the price is that an entry can be up to a minute stale, so callers + * confirm an entry before acting on its id. + * @param {{ fresh?: boolean }} [opts] - `fresh` forces a read, for polling a change this client just made. + * @returns {Promise} + */ + listing ({ fresh = false } = {}) { + const known = this.#listing + if (!fresh && known && Date.now() - known.at < this.config.listingTTL) return known.promise + const entry = { at: Date.now(), promise: this.fetchListing() } + // a failed read must not be remembered as the state of the account + entry.promise.catch(() => { if (this.#listing === entry) this.#listing = null }) + this.#listing = entry + return entry.promise + } + + /** Drops the remembered listing, because this client just changed the account or found it wrong. */ + forgetListing () { + this.#listing = null + } + + /** + * Reads the account's torrents. Called at most once per `listingTTL`; everything else goes + * through `listing()`. + * @abstract + * @returns {Promise} + */ + async fetchListing () { throw new DebridNotImplementedError(this.config.title) } + /** The subclass's static configuration, typed so implementations get completions. */ get config () { return /** @type {typeof DebridService} */ (this.constructor) @@ -221,30 +305,49 @@ export default class DebridService { } /** - * Applies the service's authentication scheme to an outgoing request. + * Applies the service's authentication scheme to an outgoing request. Some APIs + * authenticate one odd endpoint differently, hence the per-request override. * @param {string} url + * @param {{ auth?: 'bearer' | 'query', authParam?: string }} [override] * @returns {{ url: string, headers: Record }} */ - authorize (url) { - if (this.config.auth !== 'query') return { url, headers: { Authorization: `Bearer ${this.apiKey}` } } + authorize (url, { auth = this.config.auth, authParam = this.config.authParam } = {}) { + if (auth !== 'query') return { url, headers: { Authorization: `Bearer ${this.apiKey}` } } const target = new URL(url) - target.searchParams.set(this.config.authParam, this.apiKey) + target.searchParams.set(authParam, this.apiKey) return { url: target.href, headers: {} } } + /** + * Encodes a request body the way the endpoint expects it. + * @param {Record} body + * @param {'form' | 'json' | 'multipart'} encoding + * @returns {{ body: any, headers: Record }} + */ + static encodeBody (body, encoding) { + if (encoding === 'json') return { body: JSON.stringify(body), headers: { 'Content-Type': 'application/json' } } + if (encoding === 'multipart') { + const form = new FormData() + for (const [key, value] of Object.entries(body)) form.append(key, String(value)) + return { body: form, headers: {} } // fetch sets the content type, boundary included + } + return { body: new URLSearchParams(body).toString(), headers: { 'Content-Type': 'application/x-www-form-urlencoded' } } + } + /** * @param {string} url - Absolute request URL. - * @param {{ method?: string, body?: Record, timeout?: number }} [opts] - Body is sent form-encoded. + * @param {{ method?: string, body?: Record, encoding?: 'form' | 'json' | 'multipart', auth?: 'bearer' | 'query', authParam?: string, timeout?: number }} [opts] */ - async #request (url, { method = 'GET', body, timeout = this.config.timeouts.request } = {}) { + async #request (url, { method = 'GET', body, encoding = this.config.encoding, auth, authParam, timeout = this.config.timeouts.request } = {}) { await this.rateLimitPromise if (!this.apiKey) throw new DebridAuthError('No debrid API key configured') - const authorized = this.authorize(url) + const authorized = this.authorize(url, { auth, authParam }) + const encoded = body ? DebridService.encodeBody(body, encoding) : null debug(`${method} ${url}`) // logged before authorization so query-parameter keys never reach the log const res = await fetch(authorized.url, { method, - headers: { ...authorized.headers, ...(body ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}) }, - body: body && new URLSearchParams(body).toString(), + headers: { ...authorized.headers, ...encoded?.headers }, + body: encoded?.body, signal: AbortSignal.timeout(timeout) }) // the app short-circuits external requests while it considers itself offline, @@ -258,7 +361,18 @@ export default class DebridService { throw error } if (res.status === 204) return null - return res.json().catch(() => null) // some endpoints return an empty body on success + return this.unwrap(await res.json().catch(() => null)) // some endpoints return an empty body on success + } + + /** + * Unpacks a successful response body into the payload the service's own methods work with. + * Override for APIs that wrap everything in an envelope, and that report failures inside a + * 200 response — throwing from here routes those through the same typed errors as any other. + * @param {any} json + * @returns {any} + */ + unwrap (json) { + return json } /** @@ -319,37 +433,48 @@ export default class DebridService { /** * Records what is known about a release so later checks are free. Playback feeds this too: - * a resolve that succeeded proves the service holds it, a not-cached error proves it does not. + * a resolve that succeeded proves the service holds it, and the answer it failed with proves + * whichever state that error stands for. + * + * Unknown is not an answer, so recording it forgets what was there instead of storing it. * @param {string} magnetOrHash - * @param {boolean} cached + * @param {string} state - An `Availability` value. */ - remember (magnetOrHash, cached) { + remember (magnetOrHash, state) { const hash = DebridService.parseHash(magnetOrHash) - if (hash) this.cacheState.set(hash, { cached, at: Date.now() }) + if (!hash) return + const known = normalizeAvailability(state) + if (known === Availability.UNKNOWN) this.availabilityState.delete(hash) + else this.availabilityState.set(hash, { state: known, at: Date.now() }) } /** * A remembered answer that has not expired, or undefined when the hash needs asking about. * @param {string} hash - * @returns {boolean | undefined} + * @returns {string | undefined} */ #recall (hash) { - const known = this.cacheState.get(hash) + const known = this.availabilityState.get(hash) if (!known) return undefined - if (Date.now() - known.at < (known.cached ? this.config.cacheTTL.hit : this.config.cacheTTL.miss)) return known.cached - this.cacheState.delete(hash) // stale, ask again + if (Date.now() - known.at < (this.config.availabilityTTL[known.state] ?? 0)) return known.state + this.availabilityState.delete(hash) // stale, ask again return undefined } /** * The given hashes that nothing is known about yet, in the order supplied. Callers use this - * to skip work entirely rather than to decide what to ask about, which checkCached does itself. + * to skip work entirely rather than to decide what to ask about, which checkAvailability + * does itself. * @param {string[]} magnetsOrHashes * @returns {string[]} */ unknownHashes (magnetsOrHashes) { - const limit = this.config.cacheCheck === 'probe' ? this.config.maxProbes : Infinity - return DebridService.#normalize(magnetsOrHashes, limit).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) + return DebridService.#normalize(magnetsOrHashes, this.#askLimit()).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) + } + + /** How far down a results list this service is willing to look. Probing bites, batching does not. */ + #askLimit () { + return this.config.availabilityCheck === 'probe' ? this.config.maxProbes : Infinity } /** @@ -368,57 +493,54 @@ export default class DebridService { } /** - * Reports which of the given releases the service can stream instantly. + * Reports what the service can do with each of the given releases. * * Remembered answers come back for free. Whatever is left is asked about in the cheapest way - * the service supports: one batch call where the API offers a cache endpoint, or a capped - * number of probes where it does not. Hashes that stay unanswered are simply absent from - * `checked`, which callers must treat as "unknown" rather than "not cached". + * the service supports: one batch call where the API offers a cache endpoint, a capped number + * of probes where it does not. Hashes that stay unanswered are simply absent from the result, + * which callers must treat as unknown rather than as "not cached". * * `onAnswer` fires as each answer lands, so a slow probe sweep marks the list up as it goes. * @param {string[]} magnetsOrHashes - Candidates, most relevant first, since probing bites from the front. - * @param {{ onAnswer?: (hash: string, cached: boolean) => void }} [opts] - * @returns {Promise<{ cached: Set, checked: Set }>} + * @param {{ onAnswer?: (hash: string, state: string) => void }} [opts] + * @returns {Promise>} Hash to `Availability`, answered hashes only. */ - async checkCached (magnetsOrHashes, { onAnswer } = {}) { - const cached = new Set() - const checked = new Set() - const mode = this.config.cacheCheck + async checkAvailability (magnetsOrHashes, { onAnswer } = {}) { + const answers = new Map() + const mode = this.config.availabilityCheck // probing only ever looks at the top of the list, so normalize just that much of it - const candidates = DebridService.#normalize(magnetsOrHashes, mode === 'probe' ? this.config.maxProbes : Infinity) + const candidates = DebridService.#normalize(magnetsOrHashes, this.#askLimit()) const unknown = [] for (const hash of candidates) { const known = this.#recall(hash) if (known === undefined) unknown.push(hash) - else { - checked.add(hash) - if (known) cached.add(hash) - } + else answers.set(hash, known) } - if (!unknown.length || mode === 'none') return { cached, checked } + if (!unknown.length || mode === 'none') return answers - const answer = (hash, hit) => { - checked.add(hash) - if (hit) cached.add(hash) - onAnswer?.(hash, hit) + const answer = (hash, state) => { + answers.set(hash, state) + onAnswer?.(hash, state) } if (mode === 'batch') { for (let index = 0; index < unknown.length; index += this.config.maxBatch) { const chunk = unknown.slice(index, index + this.config.maxBatch) - const hits = await this.checkCachedBatch(chunk) + const states = await this.checkAvailabilityBatch(chunk) for (const hash of chunk) { - const hit = hits.has(hash) - this.remember(hash, hit) - answer(hash, hit) + // a cache endpoint that answered but did not mention a hash has said it does not + // hold it, not that it cannot fetch it + const state = normalizeAvailability(states?.get(hash) ?? Availability.AVAILABLE) + this.remember(hash, state) + answer(hash, state) } } - return { cached, checked } + return answers } // One sweep at a time. Probing is an add/read/delete cycle and services rate limit adding // far harder than reading, so overlapping sweeps do not answer faster, they get refused. - if (this.sweeping) return { cached, checked } + if (this.sweeping) return answers this.sweeping = true try { let failures = 0 @@ -428,7 +550,7 @@ export default class DebridService { failures = 0 } catch (error) { if (error instanceof DebridAuthError) throw error // every other probe would fail too - debug(`Cache probe failed for ${hash}: ${error.message}`) + debug(`Availability probe failed for ${hash}: ${error.message}`) // being told to slow down, or a run of failures, ends the sweep. The rest stay // unknown and are asked about again later rather than being called uncached if (error?.status === 429 || ++failures >= MAX_PROBE_FAILURES) break @@ -437,28 +559,30 @@ export default class DebridService { } finally { this.sweeping = false } - return { cached, checked } + return answers } /** * Runs one probe, sharing it with any caller already waiting on that hash, and applies the - * rule for what counts as an answer: a hit is one, and so is a definite "not cached". - * Nothing else is — a timeout, a rate limit or a dropped connection says something about the - * moment rather than the release, so it is left unremembered and re-checkable. + * rule for what counts as an answer: a state the service reported, or one a definite error + * proves. Anything else is no answer at all — it throws, so the sweep counts it as a failure + * and the release is left unremembered and re-checkable rather than badged as nothing. * @param {string} hash - * @returns {Promise} + * @returns {Promise} Never resolves to `unknown`. */ #probe (hash) { let pending = this.probes.get(hash) if (!pending) { - pending = this.probeCached(hash) - .catch(error => { - if (!(error instanceof DebridNotCachedError)) throw error - return false + pending = this.probeAvailability(hash) + .then(normalizeAvailability, error => { + const proven = availabilityFromError(error) + if (!proven) throw error + return proven }) - .then(result => { - this.remember(hash, result) - return result + .then(state => { + if (state === Availability.UNKNOWN) throw new DebridError(`${this.config.title} gave no usable answer for ${hash}`) + this.remember(hash, state) + return state }) .finally(() => this.probes.delete(hash)) this.probes.set(hash, pending) @@ -467,26 +591,29 @@ export default class DebridService { } /** - * Determines whether one release is cached, for services with no cache endpoint. + * Determines what the service can do with one release, for services with no cache endpoint. * Implementations must leave the account exactly as they found it. * - * Answer `true`, or `false`/`DebridNotCachedError` when the service really does not hold it. - * Let everything else throw: the base class reads any other error as "no answer", which is - * what stops a bad minute on the wire from blanking out a whole results list. + * Return an `Availability`, or throw `DebridNotCachedError` / `DebridUnavailableError` for + * the two definite negatives. Let everything else throw untyped: the base class reads any + * other error as "no answer", which is what stops a bad minute on the wire from blanking + * out a whole results list. * @abstract * @param {string} hash - Lowercase info hash. - * @returns {Promise} + * @returns {Promise} */ - async probeCached (hash) { throw new DebridNotImplementedError(this.config.title) } + async probeAvailability (hash) { throw new DebridNotImplementedError(this.config.title) } /** * Asks the service about many releases at once. Implement this for any API that exposes a - * cache endpoint, and set `cacheCheck` to 'batch'. Chunking to `maxBatch` is already done. + * cache endpoint, and set `availabilityCheck` to 'batch'. Chunking to `maxBatch` is already + * done. Hashes left out of the answer are recorded as available, since a cache endpoint + * saying no means the service would have to fetch it rather than that it cannot. * @abstract * @param {string[]} hashes - Lowercase info hashes. - * @returns {Promise>} The subset the service can stream instantly. + * @returns {Promise>} Hash to `Availability`. */ - async checkCachedBatch (hashes) { throw new DebridNotImplementedError(this.config.title) } + async checkAvailabilityBatch (hashes) { throw new DebridNotImplementedError(this.config.title) } /** * Verifies the API key and that the account can stream torrents. @@ -496,16 +623,19 @@ export default class DebridService { async validate () { throw new DebridNotImplementedError(this.config.title) } /** - * Lists info hashes the account already holds, which stream instantly. This is the badge - * source for services with no cache endpoint, so it should cover the whole account. + * What the account itself already says about releases, which costs one request and is never + * wrong: everything it holds is cached, everything it is still fetching is available, and + * everything that failed on it is unavailable. This is the badge source every service has, + * whether or not it can be asked about releases the account has never seen. * @abstract - * @returns {Promise} Lowercase info hashes. + * @returns {Promise>} Lowercase info hash to `Availability`. */ - async listCachedHashes () { throw new DebridNotImplementedError(this.config.title) } + async listAvailability () { throw new DebridNotImplementedError(this.config.title) } /** - * Resolves a magnet to direct stream URLs, throws DebridNotCachedError when the - * service would have to download the torrent first. Returned URLs must be HTTPS. + * Resolves a magnet to direct stream URLs. Throws `DebridNotCachedError` when the service + * would have to download the torrent first, `DebridUnavailableError` when it cannot serve it + * at all. Returned URLs must be HTTPS. * @abstract * @param {string} magnet - Magnet URI or bare info hash. * @param {{ fileFilter?: (name: string) => boolean, pickFile?: (files: { id: number, path: string, size: number }[]) => Promise, maxFiles?: number }} [opts] @@ -515,7 +645,7 @@ export default class DebridService { /** Cancels queued requests, the instance must not be used afterwards. */ destroy () { - this.cacheState.clear() + this.availabilityState.clear() this.sweeping = false // probes already running own a torrent on the user's account until they tear it down, so // the limiter has to outlive them. Dropping its queue first is what strands one there. diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js index 03ba9936..8a2afe0f 100644 --- a/common/modules/debrid/torbox.js +++ b/common/modules/debrid/torbox.js @@ -1,24 +1,281 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService from './service.js' +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, DebridUnavailableError } from './service.js' +import { Availability } from './availability.js' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +const API = 'https://api.torbox.app/v1/api' +// the account's torrent list comes back in one request; the API pages at 1000 +const LIST_LIMIT = 1_000 +// seed: 1 auto, 2 always, 3 never. Shiru only streams, so the account is never asked to seed +const SEED_NEVER = 3 /** - * TorBox template, see https://api-docs.torbox.app/ + * TorBox error codes worth explaining, anything else falls back to the API's own detail line. + * https://api-docs.torbox.app/ + */ +const errorMessages = { + BAD_TOKEN: 'Invalid TorBox API key', + AUTH_ERROR: 'TorBox rejected the API key', + NO_AUTH: 'TorBox requires an API key for this request', + PLAN_RESTRICTED_FEATURE: 'This TorBox plan does not include the feature Shiru needs', + ACTIVE_LIMIT: 'Too many active TorBox downloads, wait for one to finish', + MONTHLY_LIMIT: 'This TorBox account has reached its monthly limit', + COOLDOWN_LIMIT: 'TorBox is cooling this account down, try again shortly', + DOWNLOAD_TOO_LARGE: 'This release is larger than the TorBox plan allows', + DOWNLOAD_SERVER_ERROR: 'TorBox could not reach its download server, try again shortly', + NO_SERVERS_AVAILABLE_ERROR: 'No TorBox download servers are available right now' +} +// only these mean the key or plan is the problem, the rest are per-request +const authCodes = ['BAD_TOKEN', 'AUTH_ERROR', 'NO_AUTH', 'PLAN_RESTRICTED_FEATURE'] +// download_state values that mean the torrent will never finish on its own +const deadStates = /(stalled|error|failed|missing)/i + +/** + * TorBox implementation, see https://api-docs.torbox.app/ * - * Implementation template: the base class already provides authentication, rate - * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listCachedHashes`, `resolve` and `checkCachedBatch` here - * and flipping `available` to true. Nothing outside this file has to change. TorBox uses a - * Bearer token like Real-Debrid, so the inherited `auth` default already fits. - * Useful endpoints: - * - GET /user/me -> account and plan for validate() - * - GET /torrents/mylist -> account torrents for listCachedHashes() - * - GET /torrents/checkcached -> a real cache check (`hash=`), so badges can be exact - * - POST /torrents/createtorrent -> add a magnet - * - GET /torrents/requestdl -> direct stream URL per file (`torrent_id=&file_id=`) + * The API differs from Real-Debrid's in three ways this client has to account for: + * - `/torrents/checkcached` answers many hashes in one request, so every result in a search can + * carry a real badge instead of the handful a probing service can afford. + * - Every response is wrapped in a `{ success, data }` envelope and failures can arrive with a + * 200, so `unwrap` unpacks and throws rather than each method checking. + * - `/torrents/requestdl` authenticates with a `token` query parameter while everything else + * uses a bearer header. */ export default class TorBox extends DebridService { static id = 'torbox' static title = 'TorBox' - // /torrents/checkcached answers for many hashes at once, so badges cost one request - static cacheCheck = 'batch' + static available = true + // documented allowance is 300 requests a minute per endpoint; spending it as if it were the + // budget for all of them keeps a season pack's worth of link requests well inside it + static limits = { reservoir: 300, reservoirRefreshAmount: 300, reservoirRefreshInterval: 60_000, maxConcurrent: 3, minTime: 200 } + // a real cache endpoint, so badges cost one request for the whole results list + static availabilityCheck = 'batch' + // hashes travel as repeated query parameters, so the chunk size keeps the URL sane + static maxBatch = 75 + + /** + * TorBox wraps every response in `{ success, data, error, detail }` and reports plenty of + * failures with a 200, so success is decided here rather than by the status code alone. + */ + unwrap (json) { + if (!json || typeof json !== 'object' || !('success' in json)) return json + if (!json.success) throw this.mapError(200, json) + return json.data + } + + mapError (status, json) { + const code = json?.error + // `detail` is usually a sentence, but a rejected request answers with a list of field + // problems instead, which is for the log rather than for the user + const detail = typeof json?.detail === 'string' ? json.detail : '' + const message = errorMessages[code] || detail || (typeof code === 'string' && code) || `Request failed with status ${status}` + if (authCodes.includes(code) || ((status === 401 || status === 403) && !code)) return new DebridAuthError(message, { status, code }) + return new DebridError(message, { status, code }) + } + + async validate () { + const user = await this.request(`${API}/user/me?settings=false`) + if (!user) throw new DebridAuthError('TorBox did not recognise this API key') + return { username: user.email || user.customer || 'TorBox user', expires: user.premium_expires_at } + } + + /** + * The account's torrents. TorBox caches this itself, which is fine and faster for the badge + * listing; `bypass_cache` is only worth its latency when polling a change we just made. + * @param {{ id?: string | number, fresh?: boolean }} [opts] + * @returns {Promise} + */ + async #accountTorrents ({ id, fresh } = {}) { + const query = `limit=${LIST_LIMIT}${id != null ? `&id=${id}` : ''}${fresh ? '&bypass_cache=true' : ''}` + const data = await this.request(`${API}/torrents/mylist?${query}`) + // asking for one id answers with a bare object rather than a list + return !data ? [] : Array.isArray(data) ? data : [data] + } + + /** The whole account in one request, shared by the base class between badges and playback. */ + async fetchListing () { + return this.#accountTorrents() + } + + async listAvailability () { + const known = new Map() + for (const torrent of await this.listing()) { + if (torrent?.hash) known.set(String(torrent.hash).toLowerCase(), torrentAvailability(torrent)) + } + return known + } + + /** + * The reason TorBox is pleasant to badge: one request answers the whole results list. + * Hashes the endpoint leaves out are not cached, which the base class records as available. + * @param {string[]} hashes + */ + async checkAvailabilityBatch (hashes) { + const query = hashes.map(hash => `hash=${hash}`).join('&') + const data = await this.request(`${API}/torrents/checkcached?${query}&format=list`) + // the endpoint has answered in both shapes over its life: a list of entries, or an object + // keyed by hash. Both carry the same thing, which is simply "TorBox holds this one". + const cached = Array.isArray(data) ? data.map(entry => entry?.hash) : Object.keys(data || {}) + const answers = new Map(hashes.map(hash => [hash, Availability.AVAILABLE])) + for (const hash of cached) { + const key = String(hash || '').toLowerCase() + if (answers.has(key)) answers.set(key, Availability.CACHED) + } + return answers + } + + async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = this.config.maxFiles } = {}) { + const hash = TorBox.parseHash(magnet) + if (!hash) throw new DebridError('TorBox needs a magnet link or info hash to resolve') + const magnetURI = TorBox.toMagnet(magnet) + let torrent = await this.#existingTorrent(hash) + let added = false + try { + if (!torrent) { + // ask before adding: unlike Real-Debrid, TorBox answers for free, and an uncached + // release must not be queued onto the account just to find that out — adding one spends + // from a much tighter allowance (60 an hour) than a cached add does + if ((await this.checkAvailabilityBatch([hash])).get(hash) !== Availability.CACHED) throw new DebridNotCachedError() + ;({ torrent, added } = await this.#add(magnetURI, hash)) + } + const state = torrentAvailability(torrent) + if (state === Availability.UNAVAILABLE) throw new DebridUnavailableError(`TorBox could not process this torrent (${torrent.download_state || 'failed'})`) + if (state !== Availability.CACHED) throw new DebridNotCachedError() + + const wanted = (torrent.files || []).filter(file => fileFilter(filePath(file))).map(file => ({ id: file.id, path: filePath(file), size: file.size, type: file.mimetype })) + if (!wanted.length) throw new DebridError('No playable files in this torrent') + const target = pickFile ? await pickFile(wanted) : [...wanted].sort((a, b) => b.size - a.size)[0] + const files = await this.#requestLinks(torrent, TorBox.windowFiles(wanted, target, maxFiles)) + if (!files.length) throw new DebridError('TorBox returned no links for this torrent') + debug(`Resolved ${files.length} files for ${torrent.name}`) + return { hash: String(torrent.hash || hash).toLowerCase(), name: torrent.name, files } + } catch (error) { + // only clean up a torrent this call put on the account, never the user's own + if (added && torrent?.id) await this.#delete(torrent.id) + throw error + } + } + + /** + * Adds a magnet and reads back the account entry for it. + * + * `added` reports whether this call is the one that put the torrent there, and only that + * makes it ours to remove again: the account can already hold a release the listing missed a + * moment earlier, and deleting one of the user's own downloads is not a recoverable mistake. + * @param {string} magnetURI + * @param {string} hash + * @returns {Promise<{ torrent: any, added: boolean }>} + */ + async #add (magnetURI, hash) { + // multipart is what the endpoint documents, and allow_zip off keeps a pack as individual + // files rather than one archive the player cannot seek in + const created = await this.request(`${API}/torrents/createtorrent`, { + method: 'POST', + encoding: 'multipart', + body: { magnet: magnetURI, seed: SEED_NEVER, allow_zip: false } + }).catch(error => { + // the account already held it, which is an answer rather than a failure + if (error.code !== 'DUPLICATE_ITEM') throw error + return null + }) + this.forgetListing() // the account has a torrent the remembered listing does not + const id = created?.torrent_id + try { + return { torrent: await this.#awaitTorrent(id, hash), added: id != null } + } catch (error) { + // awaited, so this call has undone itself by the time it reports failure + if (id != null) await this.#delete(id) + throw error + } + } + + /** + * Waits for a freshly added torrent to show up on the account and settle. A cached release is + * complete the moment TorBox accepts it, so this waits only `timeouts.ready` before handing + * back whatever it has, which the caller reads as a fresh download rather than a cache hit. + * @param {string | number | undefined} id + * @param {string} hash + */ + async #awaitTorrent (id, hash) { + const started = Date.now() + while (true) { + // deliberately unshared and uncached: this is polling a change made a moment ago + const torrent = id != null ? (await this.#accountTorrents({ id, fresh: true }))[0] : (await this.#accountTorrents({ fresh: true })).find(entry => String(entry?.hash || '').toLowerCase() === hash) + if (torrent && torrentAvailability(torrent) !== Availability.AVAILABLE) return torrent + if (Date.now() - started > this.config.timeouts.ready) { + if (torrent) return torrent + throw new DebridError('TorBox did not report the torrent back after adding it') + } + await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) + } + } + + /** + * The account's current entry for an info hash, which is how a release already on the account + * is reused instead of added twice. + * + * The listing behind this can be up to a minute old, so the entry it names is read back by id + * before playback acts on it: a torrent deleted from another device in the meantime has to + * read as "not on the account" and be added again, not fail the resolve with a dead id. + * @param {string} hash + * @param {{ listed?: boolean }} [opts] - `listed` false skips the listing, for a hash known to be absent from it. + * @returns {Promise} + */ + async #existingTorrent (hash, { listed = true } = {}) { + if (!hash) return null + const known = listed ? (await this.listing()).find(torrent => String(torrent?.hash || '').toLowerCase() === hash) : null + if (!known) return null + // a failed read is treated as "gone" rather than raised: the caller's next move is to check + // the cache and add the magnet, which fails loudly enough if the API is really unreachable + const [confirmed] = await this.#accountTorrents({ id: known.id, fresh: true }).catch(() => []) + if (!confirmed) { + debug(`Account listing named a torrent that is gone (${known.id}), adding the magnet instead`) + this.forgetListing() + } + return confirmed || null + } + + /** + * Turns the wanted files into direct stream links. A dead file inside a pack is skipped + * rather than failing the whole resolve, the same rule every service follows. + * @param {any} torrent + * @param {{ id: number, path: string, size: number, type?: string }[]} wanted + */ + async #requestLinks (torrent, wanted) { + return this.mapFiles(wanted, async file => { + // this one endpoint takes the key as a query parameter instead of a bearer header + const url = await this.request(`${API}/torrents/requestdl?torrent_id=${torrent.id}&file_id=${file.id}&redirect=false`, { auth: 'query', authParam: 'token' }) + if (typeof url !== 'string') return null + return { name: file.path.split('/').pop(), path: file.path, size: file.size, url, type: file.type } + }) + } + + /** @param {string | number} id */ + async #delete (id) { + await this.release(`${API}/torrents/controltorrent`, { method: 'POST', encoding: 'json', body: { torrent_id: id, operation: 'delete' } }) + } +} + +/** + * What the account says about one of its torrents. `download_present` is the field that means + * the data is actually sitting on TorBox's servers, which is the only thing that makes a + * release streamable now. + * @param {any} torrent + * @returns {string} + */ +function torrentAvailability (torrent) { + if (torrent?.download_present || (torrent?.download_finished && torrent?.progress === 1)) return Availability.CACHED + if (deadStates.test(torrent?.download_state || '')) return Availability.UNAVAILABLE + return Availability.AVAILABLE +} + +/** + * TorBox reports a file's full path in `name` and its bare filename in `short_name`, both + * without a leading slash. Shiru's file objects use a rooted path, like the torrent client's. + * @param {any} file + */ +function filePath (file) { + const path = file?.name || file?.short_name || '' + return path.startsWith('/') ? path : `/${path}` } diff --git a/common/modules/util.js b/common/modules/util.js index b0eabf4a..377647b1 100644 --- a/common/modules/util.js +++ b/common/modules/util.js @@ -697,7 +697,7 @@ export const defaults = { expandingSidebar: false, torrentPathNew: undefined, debridService: 'none', - debridApiKey: '', + debridApiKeys: {}, // one key per service, so switching between them keeps both debridMode: 'prefer', debridCachedOnly: false, debridCacheCheck: true, diff --git a/common/routes/settings/tabs/AppTab.svelte b/common/routes/settings/tabs/AppTab.svelte index ed661c72..4e17204f 100644 --- a/common/routes/settings/tabs/AppTab.svelte +++ b/common/routes/settings/tabs/AppTab.svelte @@ -182,7 +182,7 @@
- + resetSettings()} class='btn btn-danger mt-5 d-flex align-items-center justify-content-center' confirmText='Confirm Reset' confirmClass='btn-danger-dim long-button' cancelClass='btn-secondary long-button' actionClass='d-inline-flex d-md-block' dataToggle='tooltip' dataPlacement='top' dataTitle='Restores All Settings Back To Their Recommended Defaults'> Reset to Defaults diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index 3ad6d483..8f6bbfc3 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -4,10 +4,28 @@ import { Eye, EyeOff } from 'lucide-svelte' import SettingCard from '@/routes/settings/components/SettingCard.svelte' import { debridOptions, testDebrid } from '@/modules/debrid/debrid.js' + import { debridKey } from '@/modules/debrid/route.js' export let settings let showKey = false let testing = false + + // each service keeps its own key, so switching between them in this dropdown swaps the field + // rather than making the user retype + $: apiKey = debridKey(settings) + + // a revealed key is hidden again when the service changes, but not while one is being typed, + // which is what watching `settings` as a whole would do + let shownFor = settings.debridService + $: if (settings.debridService !== shownFor) { + shownFor = settings.debridService + showKey = false + } + + /** @param {string} key */ + function setApiKey (key) { + settings.debridApiKeys = { ...settings.debridApiKeys, [settings.debridService]: key } + } function testConnection () { if (testing) return testing = true @@ -29,7 +47,7 @@ {#if settings.debridService !== 'none'} - +
{ settings.debridApiKey = event.target.value.trim() }} + value={apiKey} + on:input={event => setApiKey(event.target.value.trim())} on:keydown|stopPropagation />
- +
@@ -55,7 +73,7 @@ - + {/if} From 9a41b5196ac30503664d78cc977e4dc211fc2940 Mon Sep 17 00:00:00 2001 From: zeroz Date: Mon, 10 Aug 2026 15:01:39 -0400 Subject: [PATCH 08/11] debrid cache timeout better check for rd. Add premiurize and alldebrid, need to test --- .../torrent/components/TorrentResults.svelte | 3 +- common/modules/debrid/alldebrid.js | 294 +++++++++++++++++- common/modules/debrid/debrid.js | 52 +++- common/modules/debrid/premiumize.js | 177 ++++++++++- common/modules/debrid/realdebrid.js | 50 ++- common/modules/debrid/service.js | 192 ++++++++++-- common/modules/debrid/torbox.js | 2 +- common/routes/settings/tabs/DebridTab.svelte | 2 +- 8 files changed, 698 insertions(+), 74 deletions(-) diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index 2f044f5c..5c28dfbd 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -10,7 +10,7 @@ import { anitomyscript, getMediaMaxEp, getKitsuMappings, getEpisodeMetadataForMedia } from '@/modules/anime/anime.js' import { loadedTorrent, completedTorrents, seedingTorrents, stagingTorrents } from '@/modules/torrent.js' import { dedupe, getTorrentResults, updatePeerCounts } from '@/modules/extensions/handler.js' - import { debridEnabled, debridAvailability, debridTransport, debridChecking, refreshDebridAvailability, checkDebridAvailability } from '@/modules/debrid/debrid.js' + import { debridEnabled, debridAvailability, debridTransport, debridChecking, refreshDebridAvailability, checkDebridAvailability, cancelDebridAvailability } from '@/modules/debrid/debrid.js' import { Availability, AVAILABILITY_ORDER, availabilityOf, describeAvailability } from '@/modules/debrid/availability.js' import { listResult } from '@/modules/debrid/route.js' import { getId, getHash } from '@/modules/anime/animehash.js' @@ -434,6 +434,7 @@ onDestroy(() => { clearTimeout(timeoutHandle) + cancelDebridAvailability() // nobody is looking at these results any more viewHidden = false $results = {} search = null diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js index eed44796..06caeccf 100644 --- a/common/modules/debrid/alldebrid.js +++ b/common/modules/debrid/alldebrid.js @@ -1,22 +1,292 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService from './service.js' +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, DebridUnavailableError } from './service.js' +import { Availability } from './availability.js' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +const API = 'https://api.alldebrid.com' +// magnet status and the file tree moved to v4.1, everything else is still v4 +const V4 = `${API}/v4` +const V41 = `${API}/v4.1` /** - * AllDebrid template, see https://docs.alldebrid.com/ + * AllDebrid error codes worth explaining, anything else falls back to the API's own message. + * https://docs.alldebrid.com/ + */ +const errorMessages = { + AUTH_BAD_APIKEY: 'Invalid AllDebrid API key', + AUTH_MISSING_APIKEY: 'AllDebrid requires an API key for this request', + AUTH_BLOCKED: 'AllDebrid has blocked this API key', + AUTH_USER_BANNED: 'This AllDebrid account is banned', + MUST_BE_PREMIUM: 'AllDebrid premium is required for this', + MAGNET_MUST_BE_PREMIUM: 'AllDebrid premium is required to stream torrents', + MAGNET_TOO_MANY_ACTIVE: 'Too many active AllDebrid magnets, wait for one to finish', + MAGNET_TOO_LARGE: 'This release is larger than the AllDebrid plan allows', + MAGNET_INVALID_URI: 'AllDebrid would not accept this magnet', + MAGNET_NO_SERVER: 'No AllDebrid server is available right now', + NO_SERVER: 'No AllDebrid server is available right now', + LINK_TOO_MANY_DOWNLOADS: 'Too many active AllDebrid downloads, wait for one to finish', + LINK_HOST_UNAVAILABLE: 'AllDebrid cannot serve this file right now', + LINK_DOWN: 'AllDebrid reports this file as dead', + FREE_TRIAL_LIMIT_REACHED: 'This AllDebrid trial has reached its limit' +} +// only these mean the key or plan is the problem, the rest are per-request +const authCodes = ['AUTH_BAD_APIKEY', 'AUTH_MISSING_APIKEY', 'AUTH_BLOCKED', 'AUTH_USER_BANNED', 'MUST_BE_PREMIUM', 'MAGNET_MUST_BE_PREMIUM'] +// the account cannot take on more work right now, rather than this release being a problem +const throttleCodes = ['MAGNET_TOO_MANY_ACTIVE', 'LINK_TOO_MANY_DOWNLOADS', 'MAGNET_NO_SERVER', 'NO_SERVER'] +// AllDebrid will never take this release, whoever asks and whenever +const deadCodes = ['MAGNET_INVALID_URI', 'MAGNET_INVALID_FILE', 'MAGNET_TOO_LARGE'] + +// statusCode from /magnet/status: 4 is finished, below it the magnet is still being worked on, +// above it every value is a way of having failed. See the status code table in the API docs. +const READY = 4 + +/** + * AllDebrid implementation, see https://docs.alldebrid.com/ * - * Implementation template: the base class already provides authentication, rate - * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listAvailability`, `resolve` and `checkAvailabilityBatch` here - * and flipping `available` to true. Nothing outside this file has to change. Useful endpoints: - * - GET /user -> account and premium status for validate() - * - GET /magnet/status -> account magnets for listAvailability() - * - GET /magnet/upload -> add a magnet (`magnets[]=`), the `instant` flag reports cache state - * - GET /link/unlock -> direct stream URL per file (`link=`) + * Two things about the API decide the shape of this client: + * - `/magnet/instant` is gone — the endpoint 404s exactly like one that never existed, and it is + * absent from the current docs — so, as on Real-Debrid, the only way to ask about a release is + * to put the magnet on the account and read what comes back. AllDebrid answers that in the + * upload response itself, and takes many magnets per request, so a whole page of results costs + * one upload and one delete each rather than Real-Debrid's five requests per hash. What it + * still costs is the account: every magnet checked lands there for a moment, so the base class + * cap on how far down a list to look applies here too. + * - `/magnet/status` describes a magnet by name and progress but never says which info hash it + * came from, so an entry cannot be matched back to a release. That rules out reading badges off + * the account, and it is why this client reads the account only to know which magnet ids were + * already there before it uploaded anything — the ids it did not create are the user's, and + * deleting one of those is not a recoverable mistake. */ export default class AllDebrid extends DebridService { static id = 'alldebrid' static title = 'AllDebrid' - static auth = 'query' - // the upload response carries an `instant` flag per magnet, so a batch check is possible + static available = true + // one upload answers many hashes, so the check batches even though it is not free static availabilityCheck = 'batch' + // ...and what makes it not free: every hash checked lands on the account for a moment + static checkAddsMagnets = true + // every hash in a batch briefly owns a magnet on the account, so both the chunk size and how + // far down a results list this looks stay small. Real-Debrid's probe cap, for the same reason + static maxBatch = 10 + static maxAsk = 10 + // no documented allowance; modest limits, since uploading is the expensive half of this API + static limits = { maxConcurrent: 3, minTime: 250 } + + /** AllDebrid wraps every response in `{ status, data, error }` and reports failures with a 200. */ + unwrap (json) { + if (!json || typeof json !== 'object' || !('status' in json)) return json + if (json.status !== 'success') throw this.mapError(200, json) + return json.data + } + + mapError (status, json) { + const code = json?.error?.code + const message = errorMessages[code] || json?.error?.message || `Request failed with status ${status}` + if (authCodes.includes(code) || ((status === 401 || status === 403) && !code)) return new DebridAuthError(message, { status, code }) + return new DebridError(message, { status, code }) + } + + /** @param {any} error */ + throttled (error) { + return super.throttled(error) || throttleCodes.includes(error?.code) + } + + async validate () { + const user = (await this.request(`${V4}/user`))?.user + if (!user) throw new DebridAuthError('AllDebrid did not recognise this API key') + if (!user.isPremium && !user.isTrial) throw new DebridAuthError('AllDebrid premium is required to stream torrents') + return { username: user.username || user.email || 'AllDebrid user', expires: user.premiumUntil ? new Date(user.premiumUntil * 1_000).toISOString() : undefined } + } + + /** + * The account's magnets. Read only to tell this client's magnets from the user's own, never for + * badges: the entries carry no info hash, so there is no way to say which release one describes. + */ + async fetchListing () { + return this.#magnets() + } + + /** @see fetchListing - the account listing carries no info hashes, so nothing can be read off it. */ + async listAvailability () { + return new Map() + } + + /** + * Uploads the hashes, reads the `ready` flag the upload answers with, and takes back off the + * account everything this call put there. + * + * The account is read first rather than afterwards, because that read is the only thing that + * says which magnet ids existed before: an upload of a magnet the account already holds answers + * with the existing entry, so without it a check would happily delete the user's own magnet. + * @param {string[]} hashes + */ + async checkAvailabilityBatch (hashes) { + const existing = await this.#accountIds({ fresh: true }) + const uploaded = await this.#upload(hashes) + const answers = new Map() + const ours = [] + for (const entry of uploaded) { + if (entry?.id != null && !existing.has(String(entry.id))) ours.push(entry.id) + const hash = AllDebrid.parseHash(entry?.hash || entry?.magnet) + if (!hash) continue + // a rejected magnet is an answer when the rejection is about the release itself, and no + // answer at all when it is about the account being busy + if (entry.error) { + if (deadCodes.includes(entry.error.code)) answers.set(hash, Availability.UNAVAILABLE) + else debug(`AllDebrid did not answer for ${hash}: ${entry.error.code}`) + continue + } + answers.set(hash, entry.ready ? Availability.CACHED : Availability.AVAILABLE) + } + await this.#deleteAll(ours) + return answers + } + + async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = this.config.maxFiles } = {}) { + const hash = AllDebrid.parseHash(magnet) + const magnetURI = AllDebrid.toMagnet(magnet) + if (!magnetURI) throw new DebridError('AllDebrid needs a magnet link or info hash to resolve') + // same reason as the availability check: only the ids that were not here a moment ago are + // ours to remove again if this resolve cannot go through + const existing = await this.#accountIds({ fresh: true }) + const [uploaded] = await this.#upload([magnetURI]) + if (uploaded?.error) throw uploadError(uploaded.error) + const id = uploaded?.id + if (id == null) throw new DebridError('AllDebrid did not report the magnet back after adding it') + const added = !existing.has(String(id)) + try { + if (!uploaded.ready) throw new DebridNotCachedError() + const magnetInfo = (await this.#magnets(id))[0] + // the upload already said this one is ready, so an empty read is the request failing rather + // than an answer about the release, and must not be reported as one + if (!magnetInfo) throw new DebridError('AllDebrid did not report the magnet back after adding it') + const state = magnetAvailability(magnetInfo) + if (state === Availability.UNAVAILABLE) throw new DebridUnavailableError(`AllDebrid could not process this torrent (${magnetInfo.status || 'failed'})`) + if (state !== Availability.CACHED) throw new DebridNotCachedError() + + const wanted = flattenFiles(await this.#files(magnetInfo)).filter(file => fileFilter(file.path)) + if (!wanted.length) throw new DebridError('No playable files in this torrent') + const target = pickFile ? await pickFile(wanted) : [...wanted].sort((a, b) => b.size - a.size)[0] + const files = await this.#unlockLinks(AllDebrid.windowFiles(wanted, target, maxFiles)) + if (!files.length) throw new DebridError('AllDebrid returned no links for this torrent') + debug(`Resolved ${files.length} files for ${magnetInfo.filename}`) + return { hash, name: magnetInfo.filename, files } + } catch (error) { + // only clean up a magnet this call put on the account, never the user's own + if (added) await this.#delete(id) + throw error + } + } + + /** + * Adds magnets, which is also how AllDebrid is asked whether it holds them: the response says + * `ready` per magnet. Takes many at once, and answers about each one separately. + * @param {string[]} magnetsOrHashes + * @returns {Promise} + */ + async #upload (magnetsOrHashes) { + const uploaded = await this.request(`${V4}/magnet/upload`, { method: 'POST', body: { 'magnets[]': magnetsOrHashes } }) + this.forgetListing() // the account has magnets the remembered listing does not + return uploaded?.magnets || [] + } + + /** + * The account's magnets, or one of them by id. + * @param {string | number} [id] + * @returns {Promise} + */ + async #magnets (id) { + const data = await this.request(`${V41}/magnet/status`, { method: 'POST', body: id != null ? { id } : {} }) + // asking for one id has answered with a bare object rather than a list + const magnets = data?.magnets + return !magnets ? [] : Array.isArray(magnets) ? magnets : [magnets] + } + + /** + * A magnet's file tree. Asking about one magnet by id is documented to answer with its files + * inline, and the dedicated endpoint is the fallback for when it does not — the two carry the + * same tree, so nothing downstream has to know which one it came from. + * @param {any} magnetInfo + * @returns {Promise} + */ + async #files (magnetInfo) { + if (magnetInfo.files?.length) return magnetInfo.files + const data = await this.request(`${V4}/magnet/files`, { method: 'POST', body: { 'id[]': [magnetInfo.id] } }) + return data?.magnets?.[0]?.files || [] + } + + /** + * The magnet ids currently on the account, as strings so they compare cleanly whichever way + * the API types them. + * @param {{ fresh?: boolean }} [opts] + * @returns {Promise>} + */ + async #accountIds (opts) { + return new Set((await this.listing(opts)).map(entry => String(entry?.id))) + } + + /** + * Turns the wanted files into direct stream links. A dead file inside a pack is skipped rather + * than failing the whole resolve, the same rule every service follows. + * @param {{ path: string, size: number, link: string }[]} wanted + */ + async #unlockLinks (wanted) { + return this.mapFiles(wanted, async file => { + const unlocked = await this.request(`${V4}/link/unlock?link=${encodeURIComponent(file.link)}`) + if (!unlocked?.link) return null + return { name: file.path.split('/').pop(), path: file.path, size: unlocked.filesize || file.size, url: unlocked.link } + }) + } + + /** @param {(string | number)[]} ids */ + async #deleteAll (ids) { + await Promise.all(ids.map(id => this.#delete(id))) + } + + /** @param {string | number} id */ + async #delete (id) { + await this.release(`${V4}/magnet/delete`, { method: 'POST', body: { id } }) + } +} + +/** + * The typed answer a rejected upload stands for. A release AllDebrid will never take is an + * answer; anything else is the account or the moment, which proves nothing about the release. + * @param {{ code?: string, message?: string }} error + */ +function uploadError (error) { + const message = errorMessages[error?.code] || error?.message || 'AllDebrid would not accept this magnet' + if (deadCodes.includes(error?.code)) return new DebridUnavailableError(message, { code: error?.code }) + return new DebridError(message, { code: error?.code }) +} + +/** + * What the account says about one of its magnets, read from the status code table in the API + * docs: one value means finished, everything below it is still in progress, everything above it + * is a way of having failed. + * @param {any} magnet + * @returns {string} + */ +function magnetAvailability (magnet) { + const code = Number(magnet?.statusCode) + if (!Number.isFinite(code)) return Availability.UNKNOWN + if (code === READY) return Availability.CACHED + return code < READY ? Availability.AVAILABLE : Availability.UNAVAILABLE +} + +/** + * Flattens AllDebrid's file tree into rooted paths, like the torrent client's file objects. + * An entry is a folder when it carries children in `e`, and a file when it carries a link in + * `l`; names are in `n` and sizes in `s`. + * @param {any[]} entries + * @param {string} [prefix] + * @returns {{ path: string, size: number, link: string }[]} + */ +function flattenFiles (entries, prefix = '') { + return (entries || []).flatMap(entry => { + const path = `${prefix}/${entry?.n || ''}` + if (Array.isArray(entry?.e)) return flattenFiles(entry.e, path) + return entry?.l ? [{ path, size: Number(entry.s) || 0, link: entry.l }] : [] + }) } diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index fe10161c..bc951cf7 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -16,17 +16,24 @@ import { routeDebrid, debridKey } from '@/modules/debrid/route.js' import Debug from 'debug' const debug = Debug('ui:debrid') -// register new services here, implementation templates stay hidden from the settings -// menu until their `available` flag is flipped after being implemented and tested. -// This registry is the only place that touches service classes, everything else in -// the app goes through the stores and functions exported below. -const debridServices = Object.fromEntries([RealDebrid, AllDebrid, TorBox, Premiumize].filter(Service => Service.available).map(Service => [Service.id, Service])) +// register new services here, in the order the settings menu should offer them. A service that +// is still being written stays hidden until its `available` flag is flipped. This registry is +// the only place that touches service classes, everything else in the app goes through the +// stores and functions exported below. +const debridServices = Object.fromEntries([AllDebrid, Premiumize, RealDebrid, TorBox].filter(Service => Service.available).map(Service => [Service.id, Service])) /** Selectable services for the settings menu, as plain data. */ export const debridOptions = Object.values(debridServices).map(Service => ({ id: Service.id, title: Service.title })) const REFRESH_INTERVAL = 60_000 +// How long to wait before asking a service about the releases it did not manage to answer, and +// how far that wait backs off while it keeps not answering them. A probing service stops its +// sweep whenever the account or the connection is in no state to continue, which on a slow link +// is often, so without this a results list keeps whichever handful of badges it happened to get. +const RETRY_DELAY = 10_000 +const MAX_RETRY_DELAY = 4 * 60_000 + // user facing messages for the routing policy's blocked outcomes const blockedMessages = { key: () => 'Debrid only mode is on but no API key is set. Add your key in the debrid settings or disable debrid only mode.', @@ -87,6 +94,7 @@ settings.subscribe(value => { service?.destroy() service = null lastRefresh = 0 + cancelDebridAvailability() debridAvailability.set(new Map()) } serviceKey = key @@ -233,17 +241,30 @@ function current (instance) { return instance === service } +/** @type {ReturnType | null} A retry waiting to ask about what went unanswered. */ +let retry = null +let retryDelay = RETRY_DELAY + /** * Asks the service about the releases the user is looking at, so the badges say what it can * actually do with them rather than only what this account has touched before. The service * decides how: one batch call where its API offers a cache endpoint, a capped number of probes * where it does not. Answers are remembered, so browsing the same show again is free. + * + * A service is allowed to come back having answered only part of the list — a probing one stops + * the moment the account or the link says it should — so whatever is still unanswered is asked + * about again on a backing off timer until the list is done or the user moves on. * @param {string[]} hashes - Candidate info hashes, most relevant first, since probing bites from the front. */ export async function checkDebridAvailability (hashes) { + cancelDebridAvailability() // this list supersedes whatever the last one was still waiting to retry const active = getService() if (!active || !settings.value.debridCacheCheck || status.value === 'offline') return - if (!active.unknownHashes(hashes).length) return // everything here already has an answer + const pending = active.unknownHashes(hashes) + if (!pending.length) return // everything here already has an answer + // a sweep already running owns the service, so this call only reads back what is remembered + // and must not read its own lack of progress as the service refusing to answer + const busy = active.sweeping debridChecking.update(count => count + 1) try { // badge each release as its answer lands rather than when the sweep ends, so a probing @@ -254,6 +275,25 @@ export async function checkDebridAvailability (hashes) { } finally { debridChecking.update(count => count - 1) } + if (!current(active)) return + const left = active.unknownHashes(hashes) + if (!left.length) { + retryDelay = RETRY_DELAY + return + } + // answering something means the service is willing to talk, so the next attempt starts over at + // the short wait. Only a round that got nowhere backs off, which is what keeps a service that + // is genuinely refusing from being asked every ten seconds for as long as the modal is open + if (busy || left.length < pending.length) retryDelay = RETRY_DELAY + else retryDelay = Math.min(retryDelay * 2, MAX_RETRY_DELAY) + debug(`${left.length} of ${pending.length} releases unanswered, asking again in ${retryDelay}ms`) + retry = setTimeout(() => checkDebridAvailability(hashes), retryDelay) +} + +/** Drops a pending retry, for when the results it described are no longer on screen. */ +export function cancelDebridAvailability () { + if (retry) clearTimeout(retry) + retry = null } /** diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js index bb4fdfed..3b1bb5ca 100644 --- a/common/modules/debrid/premiumize.js +++ b/common/modules/debrid/premiumize.js @@ -1,22 +1,175 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService from './service.js' +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, DebridUnavailableError } from './service.js' +import { Availability } from './availability.js' +import Debug from 'debug' +const debug = Debug('ui:debrid') + +const API = 'https://www.premiumize.me/api' + +/** + * Premiumize error codes worth explaining, anything else falls back to the API's own message. + * https://www.premiumize.me/api + */ +const errorMessages = { + authentication_failed: 'Invalid Premiumize API key', + permission_denied: 'Premiumize denied the request, check the account', + account_limit_reached: 'This Premiumize account has used up its fair use points or active jobs', + service_limit_reached: 'This Premiumize account has reached its limit for this source', + rate_limit_reached: 'Premiumize is rate limiting this account, try again shortly', + service_down: 'Premiumize cannot reach this source right now', + service_unsupported: 'Premiumize cannot process this kind of source', + link_generation_failed: 'Premiumize could not generate a stream link, try again shortly' +} +// only these mean the key or account is the problem, the rest are per-request +const authCodes = ['authentication_failed', 'permission_denied'] +// the account cannot take on more work right now, rather than this release being a problem +const throttleCodes = ['rate_limit_reached', 'account_limit_reached', 'service_limit_reached'] +// the same request will keep failing, so this release is not one Premiumize can serve +const deadCodes = ['service_unsupported', 'permanent_error'] /** - * Premiumize template, see https://www.premiumize.me/api + * Premiumize implementation, see https://www.premiumize.me/api + * + * The easiest of the services to support, because it kept the two endpoints the others dropped: + * - `/cache/check` answers a whole results list in one request and costs the account nothing, so + * every release can carry a real badge. + * - `/transfer/directdl` returns every stream link for a magnet in a single call, reading the + * cache without storing anything. Nothing is ever added to the user's cloud, which is why this + * client has no cleanup path at all. * - * Implementation template: the base class already provides authentication, rate - * limiting, typed errors and clear not-implemented reporting, so adding support - * means writing `validate`, `listAvailability`, `resolve` and `checkAvailabilityBatch` here - * and flipping `available` to true. Nothing outside this file has to change. Useful endpoints: - * - GET /account/info -> account and premium status for validate() - * - GET /transfer/list -> account transfers for listAvailability() - * - GET /cache/check -> Premiumize still offers a real cache check (`items[]=`) - * - POST /transfer/directdl -> direct stream URLs for a magnet in one call (`src=`) + * The one thing it cannot do is describe the account: `/transfer/list` names transfers but never + * says which info hash a transfer came from, so `listAvailability` has nothing to report and + * badges come from the cache endpoint alone. */ export default class Premiumize extends DebridService { static id = 'premiumize' static title = 'Premiumize' - static auth = 'query' - // /cache/check answers for many hashes at once, so badges cost one request + static available = true + // a real cache endpoint, so badges cost one request for the whole results list static availabilityCheck = 'batch' + // hashes travel in the POST body rather than the URL, so the chunk size is about keeping one + // request's work reasonable rather than about URL length + static maxBatch = 100 + // no documented allowance, so this is deliberately modest: the two endpoints in use here are + // one request per results list and one per playback + static limits = { maxConcurrent: 3, minTime: 250 } + + /** + * Premiumize reports business failures inside a 200 with `{ status: 'error', message, code }`, + * and returns its payload at the top level rather than in an envelope. + */ + unwrap (json) { + if (!json || typeof json !== 'object' || !('status' in json)) return json + if (json.status === 'error') throw this.mapError(200, json) + return json + } + + mapError (status, json) { + const code = json?.code + const message = errorMessages[code] || json?.message || `Request failed with status ${status}` + if (authCodes.includes(code) || ((status === 401 || status === 403) && !code)) return new DebridAuthError(message, { status, code }) + return new DebridError(message, { status, code }) + } + + /** @param {any} error */ + throttled (error) { + return super.throttled(error) || throttleCodes.includes(error?.code) + } + + async validate () { + const account = await this.request(`${API}/account/info`) + // free accounts stream cached content through the same endpoints, so premium is not required + if (!account?.customer_id) throw new DebridAuthError('Premiumize did not recognise this API key') + return { username: `Premiumize ${account.customer_id}`, expires: account.premium_until ? new Date(account.premium_until * 1_000).toISOString() : undefined } + } + + /** + * Nothing to read: `/transfer/list` describes transfers by name and progress and never carries + * the info hash they came from, so an entry cannot be matched to a release in the results list. + * Premiumize does not need it — its cache endpoint answers about any release, whether or not + * the account has ever touched it, which is the thing an account listing is a substitute for + * everywhere else. + */ + async listAvailability () { + return new Map() + } + + /** @see listAvailability - the account listing carries no info hashes, so nothing reads it. */ + async fetchListing () { + return [] + } + + /** + * One request, however many releases, and it costs the account nothing. + * @param {string[]} hashes + */ + async checkAvailabilityBatch (hashes) { + const checked = await this.request(`${API}/cache/check`, { method: 'POST', body: { 'items[]': hashes.map(hash => Premiumize.toMagnet(hash)) } }) + // the answer is parallel arrays indexed by request order rather than a map keyed by hash + const cached = checked?.response || [] + return new Map(hashes.map((hash, index) => [hash, cached[index] ? Availability.CACHED : Availability.AVAILABLE])) + } + + async resolve (magnet, { fileFilter = () => true, pickFile, maxFiles = this.config.maxFiles } = {}) { + const hash = Premiumize.parseHash(magnet) + const magnetURI = Premiumize.toMagnet(magnet) + if (!magnetURI) throw new DebridError('Premiumize needs a magnet link or info hash to resolve') + const content = await this.#directdl(magnetURI) + const wanted = content + .map(entry => ({ name: filePath(entry).split('/').pop(), path: filePath(entry), size: Number(entry.size) || 0, url: entry.link })) + .filter(file => fileFilter(file.path)) + if (!wanted.length) throw new DebridError('No playable files in this torrent') + const target = pickFile ? await pickFile(wanted) : [...wanted].sort((a, b) => b.size - a.size)[0] + const files = Premiumize.windowFiles(wanted, target, maxFiles) + const name = torrentName(files) + debug(`Resolved ${files.length} files for ${name}`) + return { hash, name, files } + } + + /** + * Reads every stream link for a magnet out of the cache in one call. + * + * Unlike the services that have to put a torrent on the account to find out, this touches + * nothing, so there is no cleanup path and no reason to check the cache first — a miss simply + * comes back empty or as a code, and both are turned into the answer they stand for here. + * @param {string} magnetURI + * @returns {Promise} The transfer's file entries. + */ + async #directdl (magnetURI) { + let transfer = null + try { + transfer = await this.request(`${API}/transfer/directdl`, { method: 'POST', body: { src: magnetURI } }) + } catch (error) { + // Premiumize groups its codes by whether the same request could ever succeed, which maps + // straight onto what playback needs to know + if (deadCodes.includes(error?.code)) throw new DebridUnavailableError(error.message, { status: error.status, code: error.code }) + if (error?.code === 'not_found') throw new DebridNotCachedError() // it can still fetch it, just not now + throw error + } + const content = (transfer?.content || []).filter(entry => entry?.link) + // directdl only ever reads the cache, so nothing to hand back means nothing is held + if (!content.length) throw new DebridNotCachedError() + return content + } +} + +/** + * Premiumize reports a file's path inside the source without a leading slash. Shiru's file + * objects use a rooted path, like the torrent client's. + * @param {any} entry + */ +function filePath (entry) { + const path = entry?.path || '' + return path.startsWith('/') ? path : `/${path}` +} + +/** + * A name for the release, which directdl never states outright. Everything in a pack sits under + * one folder, so that folder is the torrent name; a single file release is its own name. + * @param {{ path: string, name: string }[]} files + */ +function torrentName (files) { + const [first] = files + const folder = first.path.split('/')[1] + return files.every(file => file.path.startsWith(`/${folder}/`)) ? folder : first.name } diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index cef95f52..427871b5 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -37,11 +37,14 @@ const errorMessages = { 21: 'Too many active Real-Debrid downloads, wait for one to finish', 23: 'This Real-Debrid account has exhausted its traffic', 34: 'Real-Debrid is rate limiting this account, try again shortly', - 35: 'Real-Debrid would not accept this release, try again shortly or pick a different one', + 35: 'Real-Debrid will not serve this file, pick a different release', 36: 'Real-Debrid fair usage limit reached' } // only these mean the key or account is the problem, the rest are per-request const authCodes = [8, 9] +// codes that mean the account cannot take on more work right now rather than that this release +// is a problem: rate limiting, and the cap on how many torrents may be active at once +const throttleCodes = [21, 34] /** * Real-Debrid implementation, see https://api.real-debrid.com/ @@ -62,6 +65,27 @@ export default class RealDebrid extends DebridService { // no cache endpoint any more, so availability has to be probed a hash at a time static availabilityCheck = 'probe' + /** + * @type {number} How many times a probe reads back a torrent that is still converting its + * magnet before it gives up on it. + * + * Real-Debrid already holds the metadata for everything in its cache, so a cached release + * reaches file selection on the first read or two; one still converting after that is telling + * us it is not cached. Counted in reads rather than seconds deliberately — the point is how + * many chances the torrent has had, which does not change because the connection is slow, and + * on a slow connection waiting out a full timeout is what costs the sweep the rest of its + * list. Giving up leaves the release unknown, so the next sweep asks again. + */ + static probeConversionReads = 2 + + /** + * Cannot take on more work: rate limited, or already at the account's active torrent cap. + * @param {any} error + */ + throttled (error) { + return super.throttled(error) || throttleCodes.includes(error?.code) + } + mapError (status, json) { const code = json?.error_code const message = errorMessages[code] || json?.error || `Request failed with status ${status}` @@ -113,11 +137,10 @@ export default class RealDebrid extends DebridService { async probeAvailability (hash) { const magnetURI = RealDebrid.toMagnet(hash) if (!magnetURI) throw new DebridError('Not a usable info hash') // no answer, rather than a made up one - const timeout = this.config.timeouts.probe let torrentId = null try { - torrentId = await this.#addAndSelect(magnetURI, () => true, undefined, timeout) - await this.#awaitStatus(torrentId, 'downloaded', timeout) + torrentId = await this.#addAndSelect(magnetURI, () => true, undefined, RealDebrid.probeConversionReads) + await this.#awaitStatus(torrentId, 'downloaded', this.budget('probe')) return Availability.CACHED } finally { // awaited, so the probe has genuinely left the account as it found it by the time it @@ -153,7 +176,7 @@ export default class RealDebrid extends DebridService { torrentId = await this.#addAndSelect(magnetURI, fileFilter) added = true } - info ??= await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) + info ??= await this.#awaitStatus(torrentId, 'downloaded', this.budget('ready')) // work out which single file playback is really after before unrestricting, so a // capped pack never drops the wanted episode, and so archives and reused torrents @@ -169,7 +192,7 @@ export default class RealDebrid extends DebridService { if (added) this.release(`${API}/torrents/delete/${torrentId}`) torrentId = retryId added = true - info = await this.#awaitStatus(torrentId, 'downloaded', this.config.timeouts.ready) + info = await this.#awaitStatus(torrentId, 'downloaded', this.budget('ready')) files = await this.#unrestrictLinks(info, fileFilter, 1, null) if (!files.length) throw new DebridError('Real-Debrid only serves this torrent as an archive') } @@ -213,14 +236,14 @@ export default class RealDebrid extends DebridService { * @param {string} magnetURI * @param {((name: string) => boolean) | null} fileFilter * @param {number} [fileId] - * @param {number} [timeout] - Budget for the service to accept the magnet, shortened for probes. + * @param {number} [reads] - How many status reads the magnet gets to convert, capped for probes. * @returns {Promise} The new torrent id. */ - async #addAndSelect (magnetURI, fileFilter, fileId, timeout = this.config.timeouts.select) { + async #addAndSelect (magnetURI, fileFilter, fileId, reads = Infinity) { const torrentId = (await this.request(`${API}/torrents/addMagnet`, { method: 'POST', body: { magnet: magnetURI } }))?.id this.forgetListing() // the account has a torrent the remembered listing does not try { - const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', timeout) + const info = await this.#awaitStatus(torrentId, 'waiting_files_selection', this.budget('select'), reads) if (info.status === 'waiting_files_selection') { const ids = fileId ? [fileId] : info.files.filter(file => fileFilter(file.path)).map(file => file.id) await this.request(`${API}/torrents/selectFiles/${torrentId}`, { method: 'POST', body: { files: ids.length ? ids.join(',') : 'all' } }) @@ -266,11 +289,12 @@ export default class RealDebrid extends DebridService { * fresh, or cannot process at all, is not something playback can stream now. * @param {string} id * @param {string} wanted - * @param {number} timeout + * @param {number} timeout - Deadline in milliseconds. + * @param {number} [reads] - Status reads allowed, for callers that want a fixed number of chances. */ - async #awaitStatus (id, wanted, timeout) { + async #awaitStatus (id, wanted, timeout, reads = Infinity) { const started = Date.now() - while (true) { + for (let read = 1; ; read++) { const info = await this.request(`${API}/torrents/info/${id}`) if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info const settled = unstreamable(info.status) @@ -278,7 +302,7 @@ export default class RealDebrid extends DebridService { // deliberately not an answer at all: a rare or old release can sit in magnet_conversion // for a while, and calling that a miss is what empties the badges on exactly those // titles. No answer means the release stays unknown and re-checkable. - if (Date.now() - started > timeout) throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) + if (read >= reads || Date.now() - started > timeout) throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) } } diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index 57b94e8d..9ac28500 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -128,6 +128,8 @@ const RATE_LIMIT_FALLBACK = 5 // seconds to wait when a 429 carries no retry-aft const NETWORK_RETRY_DELAY = 3_000 // consecutive unanswered probes before a sweep gives up on the rest of its list const MAX_PROBE_FAILURES = 3 +// how far a poll budget may stretch on a slow link, as a multiple of what it was written for +const MAX_STRETCH = 3 /** * Base class for debrid services, providing rate limited requests and typed errors. @@ -153,7 +155,13 @@ export default class DebridService { static authParam = 'apikey' /** @type {'form' | 'json' | 'multipart'} How request bodies are encoded, overridable per request. */ static encoding = 'form' - /** Tunable time limits in milliseconds, override only what differs for the service. */ + /** + * Tunable time limits in milliseconds, override only what differs for the service. + * + * Everything except `request` is a budget for a poll loop, so it is read through `budget()` + * and stretches to fit a slow connection. `request` is an absolute ceiling on one round trip + * and deliberately does not. + */ static timeouts = { request: 30_000, // hard limit on a single HTTP request select: 12_000, // waiting for the service to accept a magnet and expose its file list @@ -164,6 +172,21 @@ export default class DebridService { probe: 10_000 } + /** + * @type {number} Round trip time in milliseconds the limits above are written for. Measured + * latency is compared against this to work out how far a budget has to stretch. + */ + static nominalLatency = 300 + + /** + * @type {number} Probes running at once during a sweep. + * + * A probe is mostly spent waiting on the service, so running a few at a time cuts what a + * results list costs in wall clock without asking the API to do any more work. Kept small + * because each one briefly owns a torrent on the user's account. + */ + static maxProbeConcurrency = 3 + /** @type {number} Most files one resolve turns into stream links, guards against huge season packs. */ static maxFiles = 60 @@ -179,6 +202,24 @@ export default class DebridService { /** @type {number} Hashes per batch request, so one long results list becomes a few calls. */ static maxBatch = 100 + /** + * Whether asking about a release means putting a magnet on the user's account and taking it + * away again, rather than reading a cache index the service already keeps. + * + * Two things follow, and they are the same fact twice. Only one such check may be in flight, + * because adding is what services rate limit hardest. And a hash the answer leaves out has not + * thereby been called "not cached" — a check that adds magnets answers about the ones it + * managed to take, so silence there means unasked, where silence from a real cache endpoint + * means a miss. + * + * Probing is always this. Override it where a service batches its check but still adds a magnet + * per hash to run it. + * @returns {boolean} + */ + static get checkAddsMagnets () { + return this.availabilityCheck === 'probe' + } + /** * @type {number} How far down the results a probing service looks, and so the most probes * one results list can ever cost. Probing is expensive — several requests and a few seconds @@ -187,6 +228,19 @@ export default class DebridService { */ static maxProbes = 10 + /** + * How far down a results list this service is willing to look at all. + * + * A cache endpoint answers the whole list for one request, so there is no reason to stop. + * Anything that has to add a magnet to find out costs the account something per hash, so it + * only asks about the releases most likely to be played. Override where a service batches its + * check but still pays per hash. + * @returns {number} + */ + static get maxAsk () { + return this.availabilityCheck === 'probe' ? this.maxProbes : Infinity + } + /** @type {Record} How long each answer stays trusted, overridable per service. */ static availabilityTTL = AVAILABILITY_TTL @@ -204,6 +258,8 @@ export default class DebridService { constructor (apiKey) { this.apiKey = apiKey this.rateLimitPromise = null + /** @type {number} Rolling estimate of one round trip to this service, 0 until the first answer. */ + this.latency = 0 /** @type {Map} What the service has already said about a hash. */ this.availabilityState = new Map() /** @type {Map>} Probes in flight, so a hash is never asked about twice at once. */ @@ -320,18 +376,26 @@ export default class DebridService { /** * Encodes a request body the way the endpoint expects it. + * + * An array value is sent as the same key repeated once per item, which is how the APIs that + * take many things at once — a list of hashes to check, a list of magnets to add — read their + * `name[]` parameters. Joining them into one value instead is silently accepted and then + * understood as a single nonsense item, so it has to be done here rather than by each caller. * @param {Record} body * @param {'form' | 'json' | 'multipart'} encoding * @returns {{ body: any, headers: Record }} */ static encodeBody (body, encoding) { if (encoding === 'json') return { body: JSON.stringify(body), headers: { 'Content-Type': 'application/json' } } + const fields = Object.entries(body).flatMap(([key, value]) => Array.isArray(value) ? value.map(item => [key, item]) : [[key, value]]) if (encoding === 'multipart') { const form = new FormData() - for (const [key, value] of Object.entries(body)) form.append(key, String(value)) + for (const [key, value] of fields) form.append(key, String(value)) return { body: form, headers: {} } // fetch sets the content type, boundary included } - return { body: new URLSearchParams(body).toString(), headers: { 'Content-Type': 'application/x-www-form-urlencoded' } } + const params = new URLSearchParams() + for (const [key, value] of fields) params.append(key, String(value)) + return { body: params.toString(), headers: { 'Content-Type': 'application/x-www-form-urlencoded' } } } /** @@ -344,12 +408,16 @@ export default class DebridService { const authorized = this.authorize(url, { auth, authParam }) const encoded = body ? DebridService.encodeBody(body, encoding) : null debug(`${method} ${url}`) // logged before authorization so query-parameter keys never reach the log + const sent = Date.now() const res = await fetch(authorized.url, { method, headers: { ...authorized.headers, ...encoded?.headers }, body: encoded?.body, signal: AbortSignal.timeout(timeout) }) + // only round trips that came back are measured, so a request that timed out or was + // abandoned cannot inflate the estimate the time limits are derived from + this.observeLatency(Date.now() - sent) // the app short-circuits external requests while it considers itself offline, // handing back a plain object instead of a Response if (typeof res?.json !== 'function') throw new DebridNetworkError(res?.message?.replace(/^failed to fetch: /i, '') || 'Network request failed') @@ -364,6 +432,42 @@ export default class DebridService { return this.unwrap(await res.json().catch(() => null)) // some endpoints return an empty body on success } + /** + * Folds one round trip into the latency estimate, weighted towards recent requests so a link + * that degrades part way through a session is noticed within a few calls. + * @param {number} ms + */ + observeLatency (ms) { + this.latency = this.latency ? Math.round(this.latency * 0.7 + ms * 0.3) : ms + } + + /** + * A time limit from `timeouts`, stretched to fit the connection actually in use. + * + * The defaults describe how many round trips a step is worth, written for a healthy link where + * a request is a few hundred milliseconds. On a slow one the same budget buys a single request, + * so every poll loop times out and reports no answer — precisely where an answer is worth the + * most. Scaling the limits by measured latency keeps each one worth the same number of turns, + * up to a ceiling, since a link slow enough to need more than that is not one to wait on. + * @param {string} kind - A key of the service's `timeouts`. + * @returns {number} + */ + budget (kind) { + const base = this.config.timeouts[kind] + return Math.round(base * Math.min(Math.max(1, this.latency / this.config.nominalLatency), MAX_STRETCH)) + } + + /** + * Whether an error means the service wants fewer requests rather than that this release is + * a problem. A sweep stops on one of these: the next probe would be refused too. + * Override for the service specific codes that mean the same thing. + * @param {any} error + * @returns {boolean} + */ + throttled (error) { + return error?.status === 429 + } + /** * Unpacks a successful response body into the payload the service's own methods work with. * Override for APIs that wrap everything in an envelope, and that report failures inside a @@ -474,7 +578,7 @@ export default class DebridService { /** How far down a results list this service is willing to look. Probing bites, batching does not. */ #askLimit () { - return this.config.availabilityCheck === 'probe' ? this.config.maxProbes : Infinity + return this.config.maxAsk } /** @@ -523,43 +627,75 @@ export default class DebridService { onAnswer?.(hash, state) } - if (mode === 'batch') { - for (let index = 0; index < unknown.length; index += this.config.maxBatch) { - const chunk = unknown.slice(index, index + this.config.maxBatch) - const states = await this.checkAvailabilityBatch(chunk) - for (const hash of chunk) { - // a cache endpoint that answered but did not mention a hash has said it does not - // hold it, not that it cannot fetch it - const state = normalizeAvailability(states?.get(hash) ?? Availability.AVAILABLE) - this.remember(hash, state) - answer(hash, state) - } + // One check at a time where asking means putting magnets on the account: services rate limit + // adding far harder than reading, so overlapping checks do not answer faster, they get + // refused. A free cache lookup has nothing to protect and runs whenever it is asked. + if (this.config.checkAddsMagnets) { + if (this.sweeping) return answers + this.sweeping = true + } + try { + if (mode === 'batch') await this.#batch(unknown, answer) + else await this.#sweep(unknown, answer) + } finally { + this.sweeping = false + } + return answers + } + + /** + * Asks about the hashes in as few requests as the service allows. + * @param {string[]} hashes + * @param {(hash: string, state: string) => void} answer + */ + async #batch (hashes, answer) { + for (let index = 0; index < hashes.length; index += this.config.maxBatch) { + const chunk = hashes.slice(index, index + this.config.maxBatch) + const states = await this.checkAvailabilityBatch(chunk) + for (const hash of chunk) { + // a cache endpoint that answered but did not mention a hash has said it does not hold it, + // not that it cannot fetch it. A check that works by adding magnets gets no such reading: + // it answers about the magnets it managed to take, so unmentioned means unasked + const state = normalizeAvailability(states?.get(hash) ?? (this.config.checkAddsMagnets ? Availability.UNKNOWN : Availability.AVAILABLE)) + this.remember(hash, state) + if (state !== Availability.UNKNOWN) answer(hash, state) } - return answers } + } - // One sweep at a time. Probing is an add/read/delete cycle and services rate limit adding - // far harder than reading, so overlapping sweeps do not answer faster, they get refused. - if (this.sweeping) return answers - this.sweeping = true - try { - let failures = 0 - for (const hash of unknown) { + /** + * Probes a list of hashes a few at a time, stopping early once the service is clearly in no + * state to answer any more of them. + * + * Stopping is not the same as finishing: whatever is left stays unknown and re-checkable, and + * the caller is expected to come back to it. That matters most on a link where probes time out + * — giving up on the list permanently is what leaves a results list with two badges on it. + * @param {string[]} hashes + * @param {(hash: string, state: string) => void} answer + */ + async #sweep (hashes, answer) { + const queue = [...hashes] + let failures = 0 + /** @type {any} Why the sweep stopped, or null while it is still going. */ + let stopped = null + const worker = async () => { + while (queue.length && !stopped) { + const hash = queue.shift() try { answer(hash, await this.#probe(hash)) failures = 0 } catch (error) { - if (error instanceof DebridAuthError) throw error // every other probe would fail too + if (error instanceof DebridAuthError) { stopped = error; return } // every other probe would fail too debug(`Availability probe failed for ${hash}: ${error.message}`) // being told to slow down, or a run of failures, ends the sweep. The rest stay // unknown and are asked about again later rather than being called uncached - if (error?.status === 429 || ++failures >= MAX_PROBE_FAILURES) break + if (this.throttled(error) || ++failures >= MAX_PROBE_FAILURES) stopped = error } } - } finally { - this.sweeping = false } - return answers + await Promise.all(Array.from({ length: Math.min(this.config.maxProbeConcurrency, queue.length) }, worker)) + if (stopped) debug(`Probe sweep stopped with ${queue.length} hashes left to ask about: ${stopped.message}`) + if (stopped instanceof DebridAuthError) throw stopped } /** diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js index 8a2afe0f..e3562186 100644 --- a/common/modules/debrid/torbox.js +++ b/common/modules/debrid/torbox.js @@ -203,7 +203,7 @@ export default class TorBox extends DebridService { // deliberately unshared and uncached: this is polling a change made a moment ago const torrent = id != null ? (await this.#accountTorrents({ id, fresh: true }))[0] : (await this.#accountTorrents({ fresh: true })).find(entry => String(entry?.hash || '').toLowerCase() === hash) if (torrent && torrentAvailability(torrent) !== Availability.AVAILABLE) return torrent - if (Date.now() - started > this.config.timeouts.ready) { + if (Date.now() - started > this.budget('ready')) { if (torrent) return torrent throw new DebridError('TorBox did not report the torrent back after adding it') } diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index 8f6bbfc3..9521bc43 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -73,7 +73,7 @@ - + {/if} From 52d55c3385ba3e353f1fee2acaac9e9e142e3cdf Mon Sep 17 00:00:00 2001 From: zeroz Date: Mon, 10 Aug 2026 19:38:55 -0400 Subject: [PATCH 09/11] update pnpmlock --- pnpm-lock.yaml | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index ee2543e2..2e520fb2 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -1974,12 +1974,10 @@ packages: conventional-changelog-atom@2.0.8: resolution: {integrity: sha512-xo6v46icsFTK3bb7dY/8m2qvc8sZemRgdqLb/bjpBsH2UyOS8rKNTgcb5025Hri6IpANPApbXMg15QLb1LJpBw==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-codemirror@2.0.8: resolution: {integrity: sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-conventionalcommits@4.6.3: resolution: {integrity: sha512-LTTQV4fwOM4oLPad317V/QNQ1FY4Hju5qeBIM1uTHbrnCE+Eg4CdRZ3gO2pUeR+tzWdp80M2j3qFFEDWVqOV4g==} @@ -1988,32 +1986,26 @@ packages: conventional-changelog-core@4.2.4: resolution: {integrity: sha512-gDVS+zVJHE2v4SLc6B0sLsPiloR0ygU7HaDW14aNJE1v4SlqJPILPl/aJC7YdtRE4CybBf8gDwObBvKha8Xlyg==} engines: {node: '>=10'} - deprecated: Deprecated and no longer maintained. Please use conventional-changelog instead. conventional-changelog-ember@2.0.9: resolution: {integrity: sha512-ulzIReoZEvZCBDhcNYfDIsLTHzYHc7awh+eI44ZtV5cx6LVxLlVtEmcO+2/kGIHGtw+qVabJYjdI5cJOQgXh1A==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-eslint@3.0.9: resolution: {integrity: sha512-6NpUCMgU8qmWmyAMSZO5NrRd7rTgErjrm4VASam2u5jrZS0n38V7Y9CzTtLT2qwz5xEChDR4BduoWIr8TfwvXA==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-express@2.0.6: resolution: {integrity: sha512-SDez2f3iVJw6V563O3pRtNwXtQaSmEfTCaTBPCqn0oG0mfkq0rX4hHBq5P7De2MncoRixrALj3u3oQsNK+Q0pQ==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-jquery@3.0.11: resolution: {integrity: sha512-x8AWz5/Td55F7+o/9LQ6cQIPwrCjfJQ5Zmfqi8thwUEKHstEn4kTIofXub7plf1xvFA2TqhZlq7fy5OmV6BOMw==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-jshint@2.0.9: resolution: {integrity: sha512-wMLdaIzq6TNnMHMy31hql02OEQ8nCQfExw1SE0hYL5KvU+JCTuPaDO+7JiogGT2gJAxiUGATdtYYfh+nT+6riA==} engines: {node: '>=10'} - deprecated: This preset is deprecated. Please use conventional-changelog-conventionalcommits or conventional-changelog-angular instead. conventional-changelog-preset-loader@2.3.4: resolution: {integrity: sha512-GEKRWkrSAZeTq5+YjUZOYxdHq+ci4dNwHvpaBC3+ENalzFWuCWa9EZXSuZBpkr72sMdKB+1fyDV4takK1Lf58g==} @@ -2347,7 +2339,7 @@ packages: resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==} ebml-iterator@https://codeload.github.com/cedarpolar/ebml-iterator/tar.gz/10bd04f977cdd747c7cc41135cf04f8b91fb024d: - resolution: {gitHosted: true, integrity: sha512-fogU5IZc6+Hay7Hg0XNIsrby9sRsAWC0cUTBc2rNVAawu7OMHNa2cAvAZS7k2O+BTrUF+mP7HCYjcz86kqH0Mw==, tarball: https://codeload.github.com/cedarpolar/ebml-iterator/tar.gz/10bd04f977cdd747c7cc41135cf04f8b91fb024d} + resolution: {gitHosted: true, tarball: https://codeload.github.com/cedarpolar/ebml-iterator/tar.gz/10bd04f977cdd747c7cc41135cf04f8b91fb024d} version: 1.0.5 ee-first@1.1.1: @@ -2913,7 +2905,7 @@ packages: git-raw-commits@2.0.11: resolution: {integrity: sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A==} engines: {node: '>=10'} - deprecated: Deprecated and no longer maintained. Use @conventional-changelog/git-client instead. + deprecated: This package is no longer maintained. For the JavaScript API, please use @conventional-changelog/git-client instead. hasBin: true git-remote-origin-url@2.0.0: @@ -2923,7 +2915,7 @@ packages: git-semver-tags@4.1.1: resolution: {integrity: sha512-OWyMt5zBe7xFs8vglMmhM9lRQzCWL3WjHtxNNfJTMngGym7pC1kh8sP6jevfydJ6LP3ZvGxfb6ABYgPUM0mtsA==} engines: {node: '>=10'} - deprecated: Deprecated and no longer maintained. Use @conventional-changelog/git-client instead. + deprecated: This package is no longer maintained. For the JavaScript API, please use @conventional-changelog/git-client instead. hasBin: true gitconfiglocal@1.0.0: From 3d89a7bcb5aca45af83e55e6ab261662263e9aae Mon Sep 17 00:00:00 2001 From: zeroz Date: Mon, 10 Aug 2026 19:40:15 -0400 Subject: [PATCH 10/11] cleanup comments. Cleanup potential debrid cache of probe if error closed app --- common/modules/debrid/alldebrid.js | 81 ++--- common/modules/debrid/availability.js | 27 +- common/modules/debrid/debrid.js | 77 ++--- common/modules/debrid/premiumize.js | 63 +--- common/modules/debrid/realdebrid.js | 110 +++--- common/modules/debrid/route.js | 31 +- common/modules/debrid/service.js | 331 +++++++------------ common/modules/debrid/torbox.js | 85 ++--- common/routes/settings/tabs/DebridTab.svelte | 6 +- 9 files changed, 289 insertions(+), 522 deletions(-) diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js index 06caeccf..04883f52 100644 --- a/common/modules/debrid/alldebrid.js +++ b/common/modules/debrid/alldebrid.js @@ -9,10 +9,7 @@ const API = 'https://api.alldebrid.com' const V4 = `${API}/v4` const V41 = `${API}/v4.1` -/** - * AllDebrid error codes worth explaining, anything else falls back to the API's own message. - * https://docs.alldebrid.com/ - */ +// error codes worth explaining, anything else falls back to the API's own message const errorMessages = { AUTH_BAD_APIKEY: 'Invalid AllDebrid API key', AUTH_MISSING_APIKEY: 'AllDebrid requires an API key for this request', @@ -44,34 +41,23 @@ const READY = 4 /** * AllDebrid implementation, see https://docs.alldebrid.com/ * - * Two things about the API decide the shape of this client: - * - `/magnet/instant` is gone — the endpoint 404s exactly like one that never existed, and it is - * absent from the current docs — so, as on Real-Debrid, the only way to ask about a release is - * to put the magnet on the account and read what comes back. AllDebrid answers that in the - * upload response itself, and takes many magnets per request, so a whole page of results costs - * one upload and one delete each rather than Real-Debrid's five requests per hash. What it - * still costs is the account: every magnet checked lands there for a moment, so the base class - * cap on how far down a list to look applies here too. - * - `/magnet/status` describes a magnet by name and progress but never says which info hash it - * came from, so an entry cannot be matched back to a release. That rules out reading badges off - * the account, and it is why this client reads the account only to know which magnet ids were - * already there before it uploaded anything — the ids it did not create are the user's, and - * deleting one of those is not a recoverable mistake. + * Two API quirks shape this client: + * - `/magnet/instant` is gone, so availability is read off the upload response instead, which + * answers `ready` per magnet and takes many at once. Cheap in requests, but every hash checked + * lands on the account for a moment, hence the small caps below. + * - `/magnet/status` never says which info hash a magnet came from, so the account cannot be + * read for badges, only for which ids were already there before we uploaded anything. */ export default class AllDebrid extends DebridService { static id = 'alldebrid' static title = 'AllDebrid' static available = true - // one upload answers many hashes, so the check batches even though it is not free + // one upload answers many hashes, but each one lands on the account, so the caps stay small static availabilityCheck = 'batch' - // ...and what makes it not free: every hash checked lands on the account for a moment static checkAddsMagnets = true - // every hash in a batch briefly owns a magnet on the account, so both the chunk size and how - // far down a results list this looks stay small. Real-Debrid's probe cap, for the same reason static maxBatch = 10 static maxAsk = 10 - // no documented allowance; modest limits, since uploading is the expensive half of this API - static limits = { maxConcurrent: 3, minTime: 250 } + static limits = { maxConcurrent: 3, minTime: 250 } // no documented allowance, so be modest /** AllDebrid wraps every response in `{ status, data, error }` and reports failures with a 200. */ unwrap (json) { @@ -99,26 +85,20 @@ export default class AllDebrid extends DebridService { return { username: user.username || user.email || 'AllDebrid user', expires: user.premiumUntil ? new Date(user.premiumUntil * 1_000).toISOString() : undefined } } - /** - * The account's magnets. Read only to tell this client's magnets from the user's own, never for - * badges: the entries carry no info hash, so there is no way to say which release one describes. - */ + /** Read only to tell this client's magnets from the user's own, never for badges. */ async fetchListing () { return this.#magnets() } - /** @see fetchListing - the account listing carries no info hashes, so nothing can be read off it. */ + /** Nothing to read: account entries carry no info hash, so none can be matched to a release. */ async listAvailability () { return new Map() } /** - * Uploads the hashes, reads the `ready` flag the upload answers with, and takes back off the - * account everything this call put there. - * - * The account is read first rather than afterwards, because that read is the only thing that - * says which magnet ids existed before: an upload of a magnet the account already holds answers - * with the existing entry, so without it a check would happily delete the user's own magnet. + * Uploads the hashes, reads the `ready` flag back, and removes everything this call added. + * The account is read first because an upload of a magnet it already holds answers with the + * existing entry, so without that read the cleanup would delete the user's own magnet. * @param {string[]} hashes */ async checkAvailabilityBatch (hashes) { @@ -130,8 +110,7 @@ export default class AllDebrid extends DebridService { if (entry?.id != null && !existing.has(String(entry.id))) ours.push(entry.id) const hash = AllDebrid.parseHash(entry?.hash || entry?.magnet) if (!hash) continue - // a rejected magnet is an answer when the rejection is about the release itself, and no - // answer at all when it is about the account being busy + // a rejection about the release is an answer, one about the account being busy is not if (entry.error) { if (deadCodes.includes(entry.error.code)) answers.set(hash, Availability.UNAVAILABLE) else debug(`AllDebrid did not answer for ${hash}: ${entry.error.code}`) @@ -147,8 +126,7 @@ export default class AllDebrid extends DebridService { const hash = AllDebrid.parseHash(magnet) const magnetURI = AllDebrid.toMagnet(magnet) if (!magnetURI) throw new DebridError('AllDebrid needs a magnet link or info hash to resolve') - // same reason as the availability check: only the ids that were not here a moment ago are - // ours to remove again if this resolve cannot go through + // as in the check: only ids that were not here a moment ago are ours to remove again const existing = await this.#accountIds({ fresh: true }) const [uploaded] = await this.#upload([magnetURI]) if (uploaded?.error) throw uploadError(uploaded.error) @@ -158,8 +136,7 @@ export default class AllDebrid extends DebridService { try { if (!uploaded.ready) throw new DebridNotCachedError() const magnetInfo = (await this.#magnets(id))[0] - // the upload already said this one is ready, so an empty read is the request failing rather - // than an answer about the release, and must not be reported as one + // the upload already said ready, so an empty read is the request failing, not an answer if (!magnetInfo) throw new DebridError('AllDebrid did not report the magnet back after adding it') const state = magnetAvailability(magnetInfo) if (state === Availability.UNAVAILABLE) throw new DebridUnavailableError(`AllDebrid could not process this torrent (${magnetInfo.status || 'failed'})`) @@ -180,8 +157,7 @@ export default class AllDebrid extends DebridService { } /** - * Adds magnets, which is also how AllDebrid is asked whether it holds them: the response says - * `ready` per magnet. Takes many at once, and answers about each one separately. + * Adds magnets, which is also how AllDebrid is asked whether it holds them. * @param {string[]} magnetsOrHashes * @returns {Promise} */ @@ -204,9 +180,7 @@ export default class AllDebrid extends DebridService { } /** - * A magnet's file tree. Asking about one magnet by id is documented to answer with its files - * inline, and the dedicated endpoint is the fallback for when it does not — the two carry the - * same tree, so nothing downstream has to know which one it came from. + * A magnet's file tree. Status answers with it inline; the files endpoint is the fallback. * @param {any} magnetInfo * @returns {Promise} */ @@ -217,8 +191,7 @@ export default class AllDebrid extends DebridService { } /** - * The magnet ids currently on the account, as strings so they compare cleanly whichever way - * the API types them. + * The magnet ids on the account, as strings so they compare however the API types them. * @param {{ fresh?: boolean }} [opts] * @returns {Promise>} */ @@ -227,8 +200,7 @@ export default class AllDebrid extends DebridService { } /** - * Turns the wanted files into direct stream links. A dead file inside a pack is skipped rather - * than failing the whole resolve, the same rule every service follows. + * Turns the wanted files into direct stream links, skipping dead ones. * @param {{ path: string, size: number, link: string }[]} wanted */ async #unlockLinks (wanted) { @@ -251,8 +223,7 @@ export default class AllDebrid extends DebridService { } /** - * The typed answer a rejected upload stands for. A release AllDebrid will never take is an - * answer; anything else is the account or the moment, which proves nothing about the release. + * The typed answer a rejected upload stands for. Only a release it will never take is an answer. * @param {{ code?: string, message?: string }} error */ function uploadError (error) { @@ -262,9 +233,7 @@ function uploadError (error) { } /** - * What the account says about one of its magnets, read from the status code table in the API - * docs: one value means finished, everything below it is still in progress, everything above it - * is a way of having failed. + * What the account says about one magnet, per the status code table in the API docs. * @param {any} magnet * @returns {string} */ @@ -276,9 +245,7 @@ function magnetAvailability (magnet) { } /** - * Flattens AllDebrid's file tree into rooted paths, like the torrent client's file objects. - * An entry is a folder when it carries children in `e`, and a file when it carries a link in - * `l`; names are in `n` and sizes in `s`. + * Flattens the file tree into rooted paths. `n` name, `s` size, `l` link, `e` folder children. * @param {any[]} entries * @param {string} [prefix] * @returns {{ path: string, size: number, link: string }[]} diff --git a/common/modules/debrid/availability.js b/common/modules/debrid/availability.js index f9472075..d69cdeab 100644 --- a/common/modules/debrid/availability.js +++ b/common/modules/debrid/availability.js @@ -2,12 +2,9 @@ // functions, free of UI and network imports, so it runs under plain Node for tests. /** - * What a debrid service can do with a release right now. - * - * Services differ wildly in how well they can answer this: some expose a cache endpoint that - * answers hundreds of hashes in one request, some have to be probed a hash at a time, some - * cannot be asked at all. They all describe themselves with these four values, so the rest of - * the app never has to care which kind it is talking to. + * What a debrid service can do with a release right now. Services differ wildly in how well they + * can answer, but all describe themselves with these four values, so the rest of the app never + * has to care which kind it is talking to. */ export const Availability = Object.freeze({ /** The service holds it and streams it immediately. */ @@ -24,11 +21,8 @@ export const Availability = Object.freeze({ export const AVAILABILITY_ORDER = Object.freeze([Availability.CACHED, Availability.AVAILABLE, Availability.UNKNOWN, Availability.UNAVAILABLE]) /** - * How long an answer stays trusted, in milliseconds. - * - * A hit lasts far longer than a miss: anyone can pull a release into a service's cache at any - * moment, but a release it already holds rarely disappears. Unknown is not an answer, so it is - * never stored and never expires. + * How long an answer stays trusted. A hit lasts far longer than a miss: anyone can pull a release + * into a cache at any moment, but one already held rarely disappears. */ export const AVAILABILITY_TTL = Object.freeze({ [Availability.CACHED]: 6 * 60 * 60_000, @@ -48,8 +42,8 @@ export function isAvailability (value) { } /** - * Anything that is not one of the four states reads as unknown, so a service returning - * something unexpected degrades to "no answer" rather than poisoning the badges. + * Anything unrecognised reads as unknown, so a service returning something unexpected degrades + * to "no answer" rather than poisoning the badges. * @param {any} value * @returns {string} */ @@ -66,8 +60,8 @@ export function streamsInstantly (state) { } /** - * Reads a hash's state out of an availability map, defaulting to unknown. - * Callers hold magnets and mixed-case hashes, the map is keyed by lowercase info hash. + * A hash's state out of an availability map, defaulting to unknown. The map is keyed by + * lowercase info hash. * @param {Map | undefined} availability * @param {string | undefined} hash * @returns {string} @@ -77,8 +71,7 @@ export function availabilityOf (availability, hash) { } /** - * How a state is worded for the user. Kept here rather than in the components so the four - * states read consistently wherever they appear, and so the wording is testable. + * How a state is worded for the user, kept here so it reads the same wherever it appears. * @param {string} state * @param {string} [title] - The service's display name. * @returns {{ label: string, description: string }} diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index bc951cf7..5e6650c7 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -16,10 +16,8 @@ import { routeDebrid, debridKey } from '@/modules/debrid/route.js' import Debug from 'debug' const debug = Debug('ui:debrid') -// register new services here, in the order the settings menu should offer them. A service that -// is still being written stays hidden until its `available` flag is flipped. This registry is -// the only place that touches service classes, everything else in the app goes through the -// stores and functions exported below. +// register new services here, in the order the settings menu offers them. The only place that +// touches service classes; everything else goes through the stores and functions below. const debridServices = Object.fromEntries([AllDebrid, Premiumize, RealDebrid, TorBox].filter(Service => Service.available).map(Service => [Service.id, Service])) /** Selectable services for the settings menu, as plain data. */ @@ -27,10 +25,8 @@ export const debridOptions = Object.values(debridServices).map(Service => ({ id: const REFRESH_INTERVAL = 60_000 -// How long to wait before asking a service about the releases it did not manage to answer, and -// how far that wait backs off while it keeps not answering them. A probing service stops its -// sweep whenever the account or the connection is in no state to continue, which on a slow link -// is often, so without this a results list keeps whichever handful of badges it happened to get. +// how long before re-asking about releases a check could not answer, and how far that backs off +// while it keeps not answering. Without it a bad minute leaves a results list half badged const RETRY_DELAY = 10_000 const MAX_RETRY_DELAY = 4 * 60_000 @@ -60,6 +56,7 @@ export const debridTransport = derived(settings, value => { return { title: Service.title, only, + checksAddMagnets: Service.checkAddsMagnets, // the only thing worth offering an opt out for label: only ? 'Debrid Only' : 'Debrid First', description: only ? `Debrid Only: playback always uses ${Service.title}, torrents never start.` @@ -78,16 +75,13 @@ export const debridAvailability = writable(new Map()) export const debridChecking = writable(0) /** - * Whether debrid owns what the player is showing. Set the moment playback is routed to a - * service, before the resolve that takes a few seconds, because the player opens straight - * away and must not look like a torrent while it waits. Cleared whenever playback goes to - * the torrent client instead. + * Whether debrid owns what the player is showing. Set the moment playback is routed, before the + * resolve, since the player opens straight away and must not look like a torrent while it waits. */ export const debridPlayback = writable(false) -// Switching service, or editing the key of the one in use, takes effect immediately: the old -// instance is torn down and the badges are dropped, since they described a different account. -// The next call builds the new one. +// switching service or key takes effect immediately: the old instance is torn down and the +// badges dropped, since they described a different account settings.subscribe(value => { const key = `${value.debridService}:${debridKey(value)}` if (serviceKey !== null && serviceKey !== key) { @@ -119,10 +113,8 @@ export async function testDebrid () { } /** - * Attempts to stream a torrent through the configured debrid service. - * Returns true when playback was handled, either with resolved files or a - * final error in debrid only mode. Returns false to fall back to torrents. - * The routing policy lives in route.js, debrid only never reaches the torrent client. + * Streams a torrent through the configured debrid service. Returns true when playback was + * handled, false to fall back to torrents. Routing policy lives in route.js. * @param {string} torrentID - Magnet URI, info hash, or .torrent link. * @param {string} [hash] - Info hash when known. * @param {{ episode?: number }} [search] - Playback context for picking the right file in packs. @@ -150,8 +142,7 @@ export async function streamDebrid (torrentID, hash, search) { files.set(await resolveDebridFiles(route.id, search)) return true } catch (error) { - // playback is the most authoritative answer there is, so whatever it just proved about - // the release is worth more than the badge that sent the user here + // playback is the most authoritative answer there is, worth more than the badge const proven = availabilityFromError(error) if (proven) { debug(`${serviceTitle()} cannot stream this release: ${error.message}`) @@ -212,11 +203,7 @@ export async function resolveDebridFiles (torrentID, search) { }))) } -/** - * Refreshes what the account itself says, which every service can answer for free: what it - * holds streams instantly, what it is still fetching does not, what failed on it never will. - * One request a minute at most. - */ +/** Refreshes what the account itself says, which is free. One request a minute at most. */ export function refreshDebridAvailability () { const active = getService() if (!active) return @@ -233,8 +220,8 @@ export function refreshDebridAvailability () { /** * Whether answers from this instance still describe the configured account. A request in flight - * outlives a settings change — a probe sweep by seconds, a slow list by longer — and badging a - * new account with the previous one's answers is worse than having no badges at all. + * outlives a settings change, and badging a new account with the old one's answers is worse + * than no badges at all. * @param {import('@/modules/debrid/service.js').default} instance */ function current (instance) { @@ -246,15 +233,11 @@ let retry = null let retryDelay = RETRY_DELAY /** - * Asks the service about the releases the user is looking at, so the badges say what it can - * actually do with them rather than only what this account has touched before. The service - * decides how: one batch call where its API offers a cache endpoint, a capped number of probes - * where it does not. Answers are remembered, so browsing the same show again is free. - * - * A service is allowed to come back having answered only part of the list — a probing one stops - * the moment the account or the link says it should — so whatever is still unanswered is asked - * about again on a backing off timer until the list is done or the user moves on. - * @param {string[]} hashes - Candidate info hashes, most relevant first, since probing bites from the front. + * Asks the service about the releases on screen, so badges say what it can actually do with them + * rather than only what the account has touched. Answers are remembered, so browsing the same + * show again is free. A service may answer only part of the list, so whatever is left is asked + * about again on a backing off timer until it is done or the user moves on. + * @param {string[]} hashes - Candidates, most relevant first, since probing bites from the front. */ export async function checkDebridAvailability (hashes) { cancelDebridAvailability() // this list supersedes whatever the last one was still waiting to retry @@ -262,8 +245,7 @@ export async function checkDebridAvailability (hashes) { if (!active || !settings.value.debridCacheCheck || status.value === 'offline') return const pending = active.unknownHashes(hashes) if (!pending.length) return // everything here already has an answer - // a sweep already running owns the service, so this call only reads back what is remembered - // and must not read its own lack of progress as the service refusing to answer + // a check already running owns the service, so this call only reads back what is remembered const busy = active.sweeping debridChecking.update(count => count + 1) try { @@ -281,9 +263,8 @@ export async function checkDebridAvailability (hashes) { retryDelay = RETRY_DELAY return } - // answering something means the service is willing to talk, so the next attempt starts over at - // the short wait. Only a round that got nowhere backs off, which is what keeps a service that - // is genuinely refusing from being asked every ten seconds for as long as the modal is open + // any progress means the service is willing to talk, so start over at the short wait. Only a + // round that got nowhere backs off if (busy || left.length < pending.length) retryDelay = RETRY_DELAY else retryDelay = Math.min(retryDelay * 2, MAX_RETRY_DELAY) debug(`${left.length} of ${pending.length} releases unanswered, asking again in ${retryDelay}ms`) @@ -297,8 +278,8 @@ export function cancelDebridAvailability () { } /** - * Picks the file for the requested episode out of a pack using the same - * anitomy parsing the rest of the app relies on, largest file as fallback. + * Picks the requested episode out of a pack with the same anitomy parsing the rest of the app + * uses, largest file as fallback. * @param {{ id: number, path: string, size: number }[]} files * @param {number} episode */ @@ -320,8 +301,7 @@ function serviceTitle () { } /** - * Records one answer in both the service's memory and the badges, so the next search does not - * repeat a check playback has already settled. + * Records one answer in both the service's memory and the badges. * @param {string} magnetOrHash * @param {string} state - An `Availability` value. */ @@ -336,9 +316,8 @@ function recordAvailability (magnetOrHash, state) { let queued = null /** - * Collects answers arriving in one go into a single store write. A batch service answers a - * whole results list inside one loop, and writing per hash would re-render the list as many - * times; a probing service answers once every few seconds, so each still lands on its own. + * Collects answers arriving together into one store write, so a batch answer does not re-render + * the list once per hash. A probing service answers slowly enough that each still lands alone. * @param {string} hash * @param {string} state */ diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js index 3b1bb5ca..fa248877 100644 --- a/common/modules/debrid/premiumize.js +++ b/common/modules/debrid/premiumize.js @@ -6,10 +6,7 @@ const debug = Debug('ui:debrid') const API = 'https://www.premiumize.me/api' -/** - * Premiumize error codes worth explaining, anything else falls back to the API's own message. - * https://www.premiumize.me/api - */ +// error codes worth explaining, anything else falls back to the API's own message const errorMessages = { authentication_failed: 'Invalid Premiumize API key', permission_denied: 'Premiumize denied the request, check the account', @@ -22,7 +19,7 @@ const errorMessages = { } // only these mean the key or account is the problem, the rest are per-request const authCodes = ['authentication_failed', 'permission_denied'] -// the account cannot take on more work right now, rather than this release being a problem +// the account cannot take more work right now, rather than this release being a problem const throttleCodes = ['rate_limit_reached', 'account_limit_reached', 'service_limit_reached'] // the same request will keep failing, so this release is not one Premiumize can serve const deadCodes = ['service_unsupported', 'permanent_error'] @@ -30,16 +27,12 @@ const deadCodes = ['service_unsupported', 'permanent_error'] /** * Premiumize implementation, see https://www.premiumize.me/api * - * The easiest of the services to support, because it kept the two endpoints the others dropped: - * - `/cache/check` answers a whole results list in one request and costs the account nothing, so - * every release can carry a real badge. - * - `/transfer/directdl` returns every stream link for a magnet in a single call, reading the - * cache without storing anything. Nothing is ever added to the user's cloud, which is why this - * client has no cleanup path at all. + * The easiest service to support, having kept the endpoints the others dropped: `/cache/check` + * answers a whole results list for free, and `/transfer/directdl` returns every stream link for + * a magnet in one call without storing anything, so there is no add or cleanup path at all. * - * The one thing it cannot do is describe the account: `/transfer/list` names transfers but never - * says which info hash a transfer came from, so `listAvailability` has nothing to report and - * badges come from the cache endpoint alone. + * `/transfer/list` never says which info hash a transfer came from, so badges come from the + * cache endpoint alone. */ export default class Premiumize extends DebridService { static id = 'premiumize' @@ -47,17 +40,10 @@ export default class Premiumize extends DebridService { static available = true // a real cache endpoint, so badges cost one request for the whole results list static availabilityCheck = 'batch' - // hashes travel in the POST body rather than the URL, so the chunk size is about keeping one - // request's work reasonable rather than about URL length static maxBatch = 100 - // no documented allowance, so this is deliberately modest: the two endpoints in use here are - // one request per results list and one per playback - static limits = { maxConcurrent: 3, minTime: 250 } + static limits = { maxConcurrent: 3, minTime: 250 } // no documented allowance, so be modest - /** - * Premiumize reports business failures inside a 200 with `{ status: 'error', message, code }`, - * and returns its payload at the top level rather than in an envelope. - */ + /** Failures arrive inside a 200; the payload is top level rather than in an envelope. */ unwrap (json) { if (!json || typeof json !== 'object' || !('status' in json)) return json if (json.status === 'error') throw this.mapError(200, json) @@ -83,18 +69,12 @@ export default class Premiumize extends DebridService { return { username: `Premiumize ${account.customer_id}`, expires: account.premium_until ? new Date(account.premium_until * 1_000).toISOString() : undefined } } - /** - * Nothing to read: `/transfer/list` describes transfers by name and progress and never carries - * the info hash they came from, so an entry cannot be matched to a release in the results list. - * Premiumize does not need it — its cache endpoint answers about any release, whether or not - * the account has ever touched it, which is the thing an account listing is a substitute for - * everywhere else. - */ + /** Nothing to read: transfers carry no info hash. The cache endpoint covers this instead. */ async listAvailability () { return new Map() } - /** @see listAvailability - the account listing carries no info hashes, so nothing reads it. */ + /** @see listAvailability - nothing reads the account listing. */ async fetchListing () { return [] } @@ -105,8 +85,7 @@ export default class Premiumize extends DebridService { */ async checkAvailabilityBatch (hashes) { const checked = await this.request(`${API}/cache/check`, { method: 'POST', body: { 'items[]': hashes.map(hash => Premiumize.toMagnet(hash)) } }) - // the answer is parallel arrays indexed by request order rather than a map keyed by hash - const cached = checked?.response || [] + const cached = checked?.response || [] // parallel arrays indexed by request order, not keyed by hash return new Map(hashes.map((hash, index) => [hash, cached[index] ? Availability.CACHED : Availability.AVAILABLE])) } @@ -127,11 +106,8 @@ export default class Premiumize extends DebridService { } /** - * Reads every stream link for a magnet out of the cache in one call. - * - * Unlike the services that have to put a torrent on the account to find out, this touches - * nothing, so there is no cleanup path and no reason to check the cache first — a miss simply - * comes back empty or as a code, and both are turned into the answer they stand for here. + * Every stream link for a magnet, read out of the cache in one call. Touches nothing, so a + * miss comes back empty or as a code rather than needing a check first. * @param {string} magnetURI * @returns {Promise} The transfer's file entries. */ @@ -140,22 +116,20 @@ export default class Premiumize extends DebridService { try { transfer = await this.request(`${API}/transfer/directdl`, { method: 'POST', body: { src: magnetURI } }) } catch (error) { - // Premiumize groups its codes by whether the same request could ever succeed, which maps + // the API groups its codes by whether the same request could ever succeed, which maps // straight onto what playback needs to know if (deadCodes.includes(error?.code)) throw new DebridUnavailableError(error.message, { status: error.status, code: error.code }) if (error?.code === 'not_found') throw new DebridNotCachedError() // it can still fetch it, just not now throw error } const content = (transfer?.content || []).filter(entry => entry?.link) - // directdl only ever reads the cache, so nothing to hand back means nothing is held - if (!content.length) throw new DebridNotCachedError() + if (!content.length) throw new DebridNotCachedError() // directdl only reads the cache return content } } /** - * Premiumize reports a file's path inside the source without a leading slash. Shiru's file - * objects use a rooted path, like the torrent client's. + * Paths arrive without a leading slash; Shiru's file objects are rooted like the torrent client's. * @param {any} entry */ function filePath (entry) { @@ -164,8 +138,7 @@ function filePath (entry) { } /** - * A name for the release, which directdl never states outright. Everything in a pack sits under - * one folder, so that folder is the torrent name; a single file release is its own name. + * A name for the release, which directdl never states: the folder a pack sits under, or the file. * @param {{ path: string, name: string }[]} files */ function torrentName (files) { diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index 427871b5..b7799d2d 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -5,14 +5,11 @@ import Debug from 'debug' const debug = Debug('ui:debrid') const API = 'https://api.real-debrid.com/rest/1.0' -// the account's torrent list comes back in one request, newest first. Accounts larger than -// this keep their most recent torrents badged, which is the half anyone is browsing. -const LIST_LIMIT = 1_000 +const LIST_LIMIT = 1_000 // the whole account in one request, newest first /** - * What each Real-Debrid torrent status means for playback. Statuses left out — magnet - * conversion and file selection — are moments in a torrent's life rather than outcomes, - * so they answer nothing and leave the release unknown. + * What each torrent status means for playback. Magnet conversion and file selection are left out + * on purpose: they are moments in a torrent's life, not outcomes, so they answer nothing. * @type {Record} */ const statusAvailability = { @@ -29,8 +26,7 @@ const statusAvailability = { dead: Availability.UNAVAILABLE } -// https://api.real-debrid.com/ error_code values worth explaining, anything else -// falls back to the message the API sends +// error_code values worth explaining, anything else falls back to the API's own message const errorMessages = { 8: 'Invalid Real-Debrid API key', 9: 'Real-Debrid denied the request, check the account permissions', @@ -42,19 +38,18 @@ const errorMessages = { } // only these mean the key or account is the problem, the rest are per-request const authCodes = [8, 9] -// codes that mean the account cannot take on more work right now rather than that this release -// is a problem: rate limiting, and the cap on how many torrents may be active at once +// the account cannot take more work right now: rate limited, or at its active torrent cap const throttleCodes = [21, 34] /** * Real-Debrid implementation, see https://api.real-debrid.com/ * - * Two quirks of the live API shape this client: - * - `/torrents/instantAvailability` is disabled (403 `disabled_endpoint`), so the only way to - * ask about a release is to add the magnet and read the status back. That is what - * `probeAvailability` does, and why the base class caps how many of them a search may cost. - * - Selecting multiple files can serve a single RAR archive instead of individual links, so - * when that happens the torrent is re-added selecting only the target file. + * Two API quirks shape this client: + * - `/torrents/instantAvailability` is disabled (403 `disabled_endpoint`), so a release can only + * be asked about by adding the magnet and reading the status back. Hence `probeAvailability`, + * and the base class cap on how many of those a search may cost. + * - Selecting multiple files can serve one RAR archive instead of individual links, so when that + * happens the torrent is re-added selecting only the target file. */ export default class RealDebrid extends DebridService { static id = 'realdebrid' @@ -66,22 +61,17 @@ export default class RealDebrid extends DebridService { static availabilityCheck = 'probe' /** - * @type {number} How many times a probe reads back a torrent that is still converting its - * magnet before it gives up on it. + * @type {number} Status reads a probe gives a magnet still converting before giving up. * - * Real-Debrid already holds the metadata for everything in its cache, so a cached release - * reaches file selection on the first read or two; one still converting after that is telling - * us it is not cached. Counted in reads rather than seconds deliberately — the point is how - * many chances the torrent has had, which does not change because the connection is slow, and - * on a slow connection waiting out a full timeout is what costs the sweep the rest of its - * list. Giving up leaves the release unknown, so the next sweep asks again. + * Real-Debrid holds the metadata for anything cached, so a cached release reaches file + * selection within a read or two; one still converting is telling us it is not. Counted in + * reads rather than seconds so a slow link does not change how many chances it gets — waiting + * out a full timeout is what costs the sweep the rest of its list. Giving up leaves the + * release unknown, so the next sweep asks again. */ static probeConversionReads = 2 - /** - * Cannot take on more work: rate limited, or already at the account's active torrent cap. - * @param {any} error - */ + /** @param {any} error */ throttled (error) { return super.throttled(error) || throttleCodes.includes(error?.code) } @@ -101,10 +91,7 @@ export default class RealDebrid extends DebridService { return { username: user.username, expires: user.expiration } } - /** - * The whole account in one request. The base class shares this between the badge refresh and - * playback, so a search followed by a play reads it once rather than twice. - */ + /** The whole account in one request, shared by the base class between badges and playback. */ async fetchListing () { return (await this.request(`${API}/torrents?limit=${LIST_LIMIT}`)) || [] } @@ -120,17 +107,12 @@ export default class RealDebrid extends DebridService { } /** - * Finds out what Real-Debrid can do with a release, the only way it still can be asked: add - * the magnet and read the status it settles on. A cached torrent reports 'downloaded' within - * a second or so of file selection, anything else is being fetched fresh or is not something - * Real-Debrid can take at all. Costs about five requests and a few seconds, hence the cap in - * the base class. - * - * The torrent is always removed again. Adding a hash the account already holds creates a - * separate entry with its own id, so this can never delete the user's own download. + * The only way Real-Debrid can still be asked about a release: add the magnet and read the + * status it settles on. A cached torrent reports 'downloaded' within a second of file + * selection. Costs about five requests, hence the cap in the base class. * - * Nothing here decides what a failure means: `#awaitStatus` raises the typed errors that - * carry an answer, and any other error travels up as "no answer at all". + * The torrent is always removed again, and adding a hash the account already holds creates a + * separate entry, so this can never delete the user's own download. * @param {string} hash * @returns {Promise} */ @@ -143,9 +125,8 @@ export default class RealDebrid extends DebridService { await this.#awaitStatus(torrentId, 'downloaded', this.budget('probe')) return Availability.CACHED } finally { - // awaited, so the probe has genuinely left the account as it found it by the time it - // answers. Playback waits on this before reusing a torrent, and teardown waits on it - // before stopping the limiter, so neither can trip over a half-finished probe. + // awaited, so the account is as we found it by the time this answers. Playback and teardown + // both wait on it, so neither can trip over a half-finished probe if (torrentId) await this.release(`${API}/torrents/delete/${torrentId}`) } } @@ -178,17 +159,15 @@ export default class RealDebrid extends DebridService { } info ??= await this.#awaitStatus(torrentId, 'downloaded', this.budget('ready')) - // work out which single file playback is really after before unrestricting, so a - // capped pack never drops the wanted episode, and so archives and reused torrents - // that are missing it can be recovered from + // work out which file playback is after before unrestricting, so a capped pack never drops + // the wanted episode and archives can be recovered from const wanted = info.files.filter(file => fileFilter(file.path)).map(file => ({ id: file.id, path: file.path, size: file.bytes })) const target = wanted.length ? (pickFile ? await pickFile(wanted) : [...wanted].sort((a, b) => b.size - a.size)[0]) : null let files = await this.#unrestrictLinks(info, fileFilter, maxFiles, target) if (target && !files.some(file => file.name === target.path.split('/').pop())) { debug(`Re-adding torrent to select only ${target.path}`) const retryId = await this.#addAndSelect(magnetURI, null, target.id) - // not awaited, unlike the failure paths: the user is sat in front of an open player - // waiting for this resolve, and removing the superseded torrent can catch up later + // not awaited: the player is already open waiting on this, cleanup can catch up if (added) this.release(`${API}/torrents/delete/${torrentId}`) torrentId = retryId added = true @@ -207,13 +186,8 @@ export default class RealDebrid extends DebridService { } /** - * The account's current entry for an info hash, or null when it does not hold one. - * - * The listing behind this can be up to a minute old, so the entry it names is read back from - * the API before playback acts on its id: a torrent deleted from another device in the - * meantime has to read as "not on the account" and be added again, not fail the resolve with - * an id that no longer exists. The read is also what makes the reuse path cheap — it returns - * the files and links, so nothing else has to be fetched. + * The account's entry for an info hash, or null. Read back by id because the listing can be a + * minute stale, so one deleted elsewhere must read as absent rather than fail the resolve. * @param {string} hash * @returns {Promise} */ @@ -257,10 +231,9 @@ export default class RealDebrid extends DebridService { } /** - * Unrestricts a torrent's links into direct stream files. The cached copy may - * serve fewer links than the files selected: when the lists align filter by - * path up front, otherwise unrestrict and filter by the reported filename. - * RD-generated archives are dropped, the caller recovers via single file selection. + * Unrestricts a torrent's links into direct stream files. The cached copy may serve fewer links + * than files selected, so filter by path when the lists align and by filename otherwise. + * Archives are dropped; the caller recovers via single file selection. * @param {any} info * @param {(name: string) => boolean} fileFilter * @param {number} maxFiles @@ -273,8 +246,7 @@ export default class RealDebrid extends DebridService { const candidates = RealDebrid.windowFiles(aligned ? selected.map((file, index) => ({ link: info.links[index], path: file.path, size: file.bytes })).filter(file => fileFilter(file.path)) : info.links.map(link => ({ link })), target, maxFiles) - // dead files inside a pack are skipped by mapFiles, the caller checks separately that - // the episode actually wanted came back and recovers if it did not + // dead files are skipped by mapFiles; the caller checks the wanted episode came back return this.mapFiles(candidates, async ({ link, path, size }) => { const unrestricted = await this.request(`${API}/unrestrict/link`, { method: 'POST', body: { link } }) const name = path?.split('/').pop() || unrestricted.filename @@ -285,8 +257,7 @@ export default class RealDebrid extends DebridService { } /** - * Polls torrent info until it reaches the wanted status. A torrent the service has to fetch - * fresh, or cannot process at all, is not something playback can stream now. + * Polls torrent info until it reaches the wanted status. * @param {string} id * @param {string} wanted * @param {number} timeout - Deadline in milliseconds. @@ -299,9 +270,8 @@ export default class RealDebrid extends DebridService { if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info const settled = unstreamable(info.status) if (settled) throw settled - // deliberately not an answer at all: a rare or old release can sit in magnet_conversion - // for a while, and calling that a miss is what empties the badges on exactly those - // titles. No answer means the release stays unknown and re-checkable. + // deliberately no answer at all: a rare release can sit in magnet_conversion a while, and + // calling that a miss is what empties the badges on exactly those titles if (read >= reads || Date.now() - started > timeout) throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) } @@ -309,9 +279,7 @@ export default class RealDebrid extends DebridService { } /** - * The typed answer a settled status stands for, or null while the torrent is still making up - * its mind. One mapping serves both callers: playback reads it as a reason to fall back, the - * base class reads it as the release's availability. + * The typed answer a settled status stands for, or null while the torrent is still deciding. * @param {string} status * @returns {import('./service.js').DebridUnstreamableError | null} */ diff --git a/common/modules/debrid/route.js b/common/modules/debrid/route.js index ba86cc9b..d37a7358 100644 --- a/common/modules/debrid/route.js +++ b/common/modules/debrid/route.js @@ -1,6 +1,5 @@ -// Pure debrid policy, free of UI imports so it can be tested under plain Node. -// Two decisions live here: how a play request is routed (debrid only mode must never -// reach the torrent client, whatever the input), and which search results are listed. +// Pure debrid policy, free of UI imports so it can be tested under plain Node: how a play +// request is routed, and which search results are listed. import { Availability, streamsInstantly } from './availability.js' const magnetRx = /^magnet:.*urn:btih:[a-f\d]{40}/i @@ -21,8 +20,7 @@ function usable (torrentID) { * @param {boolean} options.offline - The client has no network connection. * @param {string} options.mode - The debridMode setting, 'prefer' or 'only'. * @returns {{ action: 'torrent', only: boolean } | { action: 'block', reason: 'key' | 'offline' | 'source', only: boolean } | { action: 'resolve', id: string, only: boolean }} - * `only` reports whether debrid only mode governs this decision, so callers never - * have to re-derive the fallback rules that were already applied here. + * `only` reports whether debrid only mode governs the decision, so callers need not re-derive it. */ export function routeDebrid ({ torrentID, hash, serviceSelected, serviceReady, offline, mode }) { // with no service selected debrid is entirely out of the picture, only mode included @@ -36,12 +34,8 @@ export function routeDebrid ({ torrentID, hash, serviceSelected, serviceReady, o } /** - * The API key stored for a debrid service. - * - * Every service keeps its own, so switching between them in settings swaps the key rather than - * losing it, and an account on one service can never be addressed with another's key. The - * settings tab and the playback module both read through here so they cannot disagree about - * which key is in play. + * The API key stored for a debrid service. Every service keeps its own, so switching in settings + * swaps the key rather than losing it, and one service's key can never reach another's API. * @param {{ debridApiKeys?: Record }} settings * @param {string} [service] - Service id, defaulting to the selected one. * @returns {string} Empty when that service has no key yet. @@ -51,16 +45,11 @@ export function debridKey (settings, service = settings?.debridService) { } /** - * Whether a search result belongs in the listed results rather than the hidden ones. - * - * With no filters on this is upstream's rule, widened only by the fact that a cached release - * streams without seeders. The two debrid cases that narrow it: - * - the cached filter shows nothing but confirmed cached releases; - * - debrid only mode hides releases the service has said it cannot serve, since with no - * torrent client to fall back on those cannot play at all. - * - * An *available* release is deliberately not widened in: the service would still have to pull - * it from the swarm, so a seederless one is no more playable than it was without debrid. + * Whether a search result belongs in the listed results rather than the hidden ones. With no + * filters this is upstream's rule, widened only because a cached release streams without seeders. + * The cached filter narrows it to confirmed hits, and debrid only mode hides releases the service + * cannot serve. An *available* release is deliberately not widened in: the service would still + * have to pull it from the swarm. * @param {{ seeders?: number, source?: { managed?: boolean } }} result * @param {string} [availability] - What the service said about this release. * @param {{ cachedOnly?: boolean, only?: boolean }} [options] - The debrid filters in force. diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index 9ac28500..7da3bfed 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -3,7 +3,7 @@ import { Availability, AVAILABILITY_TTL, normalizeAvailability } from './availab import Debug from 'debug' const debug = Debug('ui:debrid') -// This module is intentionally free of UI imports so it can also run under plain Node for testing. +// No UI imports here, so this module also runs under plain Node for testing. export class DebridError extends Error { /** @@ -18,7 +18,7 @@ export class DebridError extends Error { } } -/** Thrown when the API key is missing, invalid or the account lacks the required plan. */ +/** The API key is missing, invalid, or the account lacks the required plan. */ export class DebridAuthError extends DebridError { constructor (message, opts) { super(message, opts) @@ -26,7 +26,7 @@ export class DebridAuthError extends DebridError { } } -/** Thrown when the service could not be reached at all, usually because the client is offline. */ +/** The service could not be reached at all, usually because the client is offline. */ export class DebridNetworkError extends DebridError { constructor (message, opts) { super(message, opts) @@ -35,10 +35,8 @@ export class DebridNetworkError extends DebridError { } /** - * A definite answer that playback cannot use this release now, carrying the availability it - * proves. Everything that asks a service a question — playback and cache checks alike — reads - * `availability` off the error rather than matching on error types, so a service only has to - * throw the right one and both callers behave correctly. + * Playback cannot use this release now, carrying the availability it proves. Callers read + * `availability` off the error rather than matching on error types. * @abstract */ export class DebridUnstreamableError extends DebridError { @@ -64,7 +62,7 @@ export class DebridUnavailableError extends DebridUnstreamableError { } } -/** Thrown by the base class for any method a service template has not filled in yet. */ +/** Thrown by the base class for any method a service has not filled in yet. */ export class DebridNotImplementedError extends DebridError { /** @param {string} title - The service's display name. */ constructor (title) { @@ -74,11 +72,8 @@ export class DebridNotImplementedError extends DebridError { } /** - * What an error proves about a release, or null when it proves nothing. - * - * A timeout, a rate limit or a dropped connection says something about the moment rather than - * the release, so it must leave the release unknown and re-checkable. Only the two definite - * answers count. + * What an error proves about a release, or null when it proves nothing. A timeout or a rate + * limit describes the moment, not the release, so it leaves it unknown and re-checkable. * @param {any} error * @returns {string | null} */ @@ -103,12 +98,11 @@ export function availabilityFromError (error) { */ /** - * Holds services to the HTTPS half of the DebridFile contract. Debrid links are account - * bound, so a cleartext link would put the user's traffic and their link on the wire in - * the clear. Dropped rather than downgraded. + * Drops any link that is not HTTPS. Debrid links are account bound, so a cleartext one would put + * the user's traffic and their link on the wire in the clear. * @param {DebridFile[]} files * @param {string} title - Service name, for the message the user sees. - * @returns {DebridFile[]} The files safe to stream. + * @returns {DebridFile[]} */ export function secureFiles (files, title) { const secure = (files || []).filter(file => /^https:\/\//i.test(file?.url)) @@ -122,22 +116,20 @@ export const archiveRx = /\.(rar|zip|7z)$/i const magnetHashRx = /urn:btih:([a-f\d]{40})/i const bareHashRx = /^[a-f\d]{40}$/i -// retry policy for the shared limiter, applies to every service const RATE_LIMIT_RETRIES = 2 const RATE_LIMIT_FALLBACK = 5 // seconds to wait when a 429 carries no retry-after header const NETWORK_RETRY_DELAY = 3_000 -// consecutive unanswered probes before a sweep gives up on the rest of its list -const MAX_PROBE_FAILURES = 3 -// how far a poll budget may stretch on a slow link, as a multiple of what it was written for -const MAX_STRETCH = 3 +const MAX_PROBE_FAILURES = 3 // consecutive unanswered probes before a sweep gives up +const MAX_STRETCH = 3 // how far a poll budget may stretch on a slow link +const MAX_CLEANUP_ATTEMPTS = 3 /** - * Base class for debrid services, providing rate limited requests and typed errors. + * Base class for debrid services: rate limited requests, typed errors, availability bookkeeping. * Implementations only talk HTTP, state is per-instance so services stay swappable. * * Adding a service means subclassing this, setting the statics below, and implementing the - * abstract methods. Nothing outside the new file needs to change apart from one entry in the - * registry in `debrid.js`. Anything left unimplemented reports itself clearly. + * abstract methods. Nothing outside the new file changes apart from one registry entry in + * `debrid.js`. * @abstract */ export default class DebridService { @@ -155,88 +147,49 @@ export default class DebridService { static authParam = 'apikey' /** @type {'form' | 'json' | 'multipart'} How request bodies are encoded, overridable per request. */ static encoding = 'form' - /** - * Tunable time limits in milliseconds, override only what differs for the service. - * - * Everything except `request` is a budget for a poll loop, so it is read through `budget()` - * and stretches to fit a slow connection. `request` is an absolute ceiling on one round trip - * and deliberately does not. - */ + + /** Time limits in milliseconds. All but `request` are poll budgets, read through `budget()`. */ static timeouts = { - request: 30_000, // hard limit on a single HTTP request + request: 30_000, // hard ceiling on one round trip, deliberately does not stretch select: 12_000, // waiting for the service to accept a magnet and expose its file list ready: 5_000, // waiting for a cached torrent to report ready, anything slower is a fresh download poll: 1_000, // gap between status polls - // budget for one availability probe. Deliberately tighter than `select`: a probe that drags - // on spends requests the account needs for playback, and no answer is worth that - probe: 10_000 + probe: 10_000 // tighter than `select`: a probe that drags on spends requests playback needs } - /** - * @type {number} Round trip time in milliseconds the limits above are written for. Measured - * latency is compared against this to work out how far a budget has to stretch. - */ + /** @type {number} Round trip time the limits above are written for, in milliseconds. */ static nominalLatency = 300 - /** - * @type {number} Probes running at once during a sweep. - * - * A probe is mostly spent waiting on the service, so running a few at a time cuts what a - * results list costs in wall clock without asking the API to do any more work. Kept small - * because each one briefly owns a torrent on the user's account. - */ + /** @type {number} Probes running at once. Small, since each briefly owns a torrent on the account. */ static maxProbeConcurrency = 3 /** @type {number} Most files one resolve turns into stream links, guards against huge season packs. */ static maxFiles = 60 /** - * @type {'batch' | 'probe' | 'none'} How the service can be asked about a release it has not seen. - * 'batch' services answer many hashes in one cheap request, which is by far the best case. - * 'probe' is for services with no cache endpoint, where the only way to find out is to add - * the magnet and read the status back, costing several requests per hash. - * 'none' leaves badges to `listAvailability` and lets playback discover the rest. + * @type {'batch' | 'probe' | 'none'} How the service can be asked about a release it has not + * seen. 'batch' answers many hashes per request, 'probe' adds the magnet and reads the status + * back, 'none' leaves badges to `listAvailability`. */ static availabilityCheck = 'none' - /** @type {number} Hashes per batch request, so one long results list becomes a few calls. */ + /** @type {number} Hashes per batch request. */ static maxBatch = 100 /** - * Whether asking about a release means putting a magnet on the user's account and taking it - * away again, rather than reading a cache index the service already keeps. - * - * Two things follow, and they are the same fact twice. Only one such check may be in flight, - * because adding is what services rate limit hardest. And a hash the answer leaves out has not - * thereby been called "not cached" — a check that adds magnets answers about the ones it - * managed to take, so silence there means unasked, where silence from a real cache endpoint - * means a miss. - * - * Probing is always this. Override it where a service batches its check but still adds a magnet - * per hash to run it. + * Whether asking about a release puts a magnet on the account rather than reading a cache + * index. Two things follow: only one such check may be in flight, and a hash the answer leaves + * out is unasked rather than "not cached". * @returns {boolean} */ static get checkAddsMagnets () { return this.availabilityCheck === 'probe' } - /** - * @type {number} How far down the results a probing service looks, and so the most probes - * one results list can ever cost. Probing is expensive — several requests and a few seconds - * each — so this buys confirmed answers for the releases most likely to be played rather - * than trying to answer the whole list. Everything past it stays unknown. - */ + /** @type {number} Most probes one results list may cost, since each is several requests. */ static maxProbes = 10 - /** - * How far down a results list this service is willing to look at all. - * - * A cache endpoint answers the whole list for one request, so there is no reason to stop. - * Anything that has to add a magnet to find out costs the account something per hash, so it - * only asks about the releases most likely to be played. Override where a service batches its - * check but still pays per hash. - * @returns {number} - */ + /** How far down a results list this service looks. Override where a batch still pays per hash. */ static get maxAsk () { return this.availabilityCheck === 'probe' ? this.maxProbes : Infinity } @@ -244,27 +197,26 @@ export default class DebridService { /** @type {Record} How long each answer stays trusted, overridable per service. */ static availabilityTTL = AVAILABILITY_TTL - /** - * @type {number} How long the account's own torrent listing is reused before it is read again. - * Matched to how often the badges refresh, so browsing and then playing costs one read rather - * than two. - */ + /** @type {number} How long the account listing is reused. Matched to the badge refresh. */ static listingTTL = 60_000 /** @type {{ at: number, promise: Promise } | null} The listing read, shared by everyone waiting on it. */ #listing = null + /** @type {Map} Removals that failed, to try again. */ + #orphans = new Map() + /** @param {string} apiKey */ constructor (apiKey) { this.apiKey = apiKey this.rateLimitPromise = null - /** @type {number} Rolling estimate of one round trip to this service, 0 until the first answer. */ + /** @type {number} Rolling estimate of one round trip, 0 until the first answer. */ this.latency = 0 /** @type {Map} What the service has already said about a hash. */ this.availabilityState = new Map() /** @type {Map>} Probes in flight, so a hash is never asked about twice at once. */ this.probes = new Map() - /** @type {boolean} Whether a probe sweep is running, since only one may be. */ + /** @type {boolean} Whether a check that adds magnets is running, since only one may be. */ this.sweeping = false this.limiter = new Bottleneck(this.config.limits) this.limiter.on('failed', (error, jobInfo) => { @@ -282,52 +234,67 @@ export default class DebridService { /** * Undoes something this client created on the account. Never throws: it runs from `finally`, - * where it would mask the real failure. Services whose delete is not a plain DELETE pass the - * request options they need. + * where it would mask the real failure. A removal that fails is remembered and retried, since + * the limiter does not retry the offline case that most often causes one. * @param {string} url * @param {Parameters[1]} [opts] */ async release (url, opts) { try { await this.request(url, { method: 'DELETE', ...opts }) + this.#orphans.delete(url) } catch (error) { - debug(`Cleanup failed for ${url}: ${error.message}`) + if (error?.status === 404) return this.#orphans.delete(url) // already gone is what we wanted + const attempts = (this.#orphans.get(url)?.attempts ?? 0) + 1 + debug(`Cleanup failed for ${url} (attempt ${attempts}): ${error.message}`) + if (attempts < MAX_CLEANUP_ATTEMPTS) this.#orphans.set(url, { url, opts, attempts }) + else this.#orphans.delete(url) } finally { this.forgetListing() // the account just changed, whether or not the removal worked } } + /** + * Retries removals that failed earlier. Only ever replays a removal `release()` was already + * asked to make, so it can no more reach a torrent the user wanted than the original call + * could. Never persisted: a stale id would eventually name something else. + */ + async retryCleanup () { + const pending = [...this.#orphans.values()] + if (!pending.length) return + debug(`Retrying ${pending.length} removal(s) that failed earlier`) + await Promise.all(pending.map(entry => this.release(entry.url, entry.opts))) + } + + /** How many removals are still outstanding. */ + get orphaned () { + return this.#orphans.size + } + /** * The account's own torrent listing, read at most once per `listingTTL` and shared by every - * caller waiting on it. - * - * Two things want this same list: the badge refresh, once a minute, and every resolve, which - * checks whether the account already holds the release before adding it again. Reading it per - * play put a full listing on the play path — measured at 4.6s on a 312 torrent Real-Debrid - * account — for a list the badge refresh had usually just fetched. Sharing it makes the - * common case free, and the price is that an entry can be up to a minute stale, so callers - * confirm an entry before acting on its id. - * @param {{ fresh?: boolean }} [opts] - `fresh` forces a read, for polling a change this client just made. + * caller. Both the badge refresh and every resolve want it, and reading it per play put a full + * listing on the play path. An entry can be a minute stale, so callers confirm it before + * acting on its id. + * @param {{ fresh?: boolean }} [opts] - `fresh` forces a read, for polling a change just made. * @returns {Promise} */ listing ({ fresh = false } = {}) { const known = this.#listing if (!fresh && known && Date.now() - known.at < this.config.listingTTL) return known.promise const entry = { at: Date.now(), promise: this.fetchListing() } - // a failed read must not be remembered as the state of the account - entry.promise.catch(() => { if (this.#listing === entry) this.#listing = null }) + entry.promise.catch(() => { if (this.#listing === entry) this.#listing = null }) // never remember a failed read this.#listing = entry return entry.promise } - /** Drops the remembered listing, because this client just changed the account or found it wrong. */ + /** Drops the remembered listing, because the account just changed. */ forgetListing () { this.#listing = null } /** - * Reads the account's torrents. Called at most once per `listingTTL`; everything else goes - * through `listing()`. + * Reads the account's torrents. Everything else goes through `listing()`. * @abstract * @returns {Promise} */ @@ -340,7 +307,6 @@ export default class DebridService { /** * The lowercase info hash of a magnet URI or bare hash, empty when there is none. - * Every service takes the same input shape, so the parsing lives here once. * @param {any} magnetOrHash * @returns {string} */ @@ -350,7 +316,7 @@ export default class DebridService { } /** - * Normalizes a magnet URI or bare info hash into a magnet URI to hand to the API. + * A magnet URI to hand to the API, from a magnet URI or bare info hash. * @param {any} magnetOrHash * @returns {string} Empty when the input holds no usable hash. */ @@ -361,8 +327,8 @@ export default class DebridService { } /** - * Applies the service's authentication scheme to an outgoing request. Some APIs - * authenticate one odd endpoint differently, hence the per-request override. + * Applies the service's authentication scheme. Some APIs authenticate one odd endpoint + * differently, hence the per-request override. * @param {string} url * @param {{ auth?: 'bearer' | 'query', authParam?: string }} [override] * @returns {{ url: string, headers: Record }} @@ -375,12 +341,8 @@ export default class DebridService { } /** - * Encodes a request body the way the endpoint expects it. - * - * An array value is sent as the same key repeated once per item, which is how the APIs that - * take many things at once — a list of hashes to check, a list of magnets to add — read their - * `name[]` parameters. Joining them into one value instead is silently accepted and then - * understood as a single nonsense item, so it has to be done here rather than by each caller. + * Encodes a request body. An array value becomes the same key repeated per item, which is how + * `name[]` parameters are read; joining them into one value is silently taken as one item. * @param {Record} body * @param {'form' | 'json' | 'multipart'} encoding * @returns {{ body: any, headers: Record }} @@ -415,9 +377,7 @@ export default class DebridService { body: encoded?.body, signal: AbortSignal.timeout(timeout) }) - // only round trips that came back are measured, so a request that timed out or was - // abandoned cannot inflate the estimate the time limits are derived from - this.observeLatency(Date.now() - sent) + this.observeLatency(Date.now() - sent) // only round trips that came back, so a timeout cannot inflate it // the app short-circuits external requests while it considers itself offline, // handing back a plain object instead of a Response if (typeof res?.json !== 'function') throw new DebridNetworkError(res?.message?.replace(/^failed to fetch: /i, '') || 'Network request failed') @@ -433,8 +393,7 @@ export default class DebridService { } /** - * Folds one round trip into the latency estimate, weighted towards recent requests so a link - * that degrades part way through a session is noticed within a few calls. + * Folds one round trip into the latency estimate, weighted towards recent requests. * @param {number} ms */ observeLatency (ms) { @@ -442,13 +401,9 @@ export default class DebridService { } /** - * A time limit from `timeouts`, stretched to fit the connection actually in use. - * - * The defaults describe how many round trips a step is worth, written for a healthy link where - * a request is a few hundred milliseconds. On a slow one the same budget buys a single request, - * so every poll loop times out and reports no answer — precisely where an answer is worth the - * most. Scaling the limits by measured latency keeps each one worth the same number of turns, - * up to a ceiling, since a link slow enough to need more than that is not one to wait on. + * A poll budget stretched to fit the connection in use, up to `MAX_STRETCH`. The defaults are + * written for a healthy link; on a slow one the same budget buys a single request, so every + * poll loop times out and reports no answer. * @param {string} kind - A key of the service's `timeouts`. * @returns {number} */ @@ -458,9 +413,8 @@ export default class DebridService { } /** - * Whether an error means the service wants fewer requests rather than that this release is - * a problem. A sweep stops on one of these: the next probe would be refused too. - * Override for the service specific codes that mean the same thing. + * Whether an error means the service wants fewer requests rather than that this release is a + * problem. A sweep stops on one. Override for service specific codes. * @param {any} error * @returns {boolean} */ @@ -469,9 +423,8 @@ export default class DebridService { } /** - * Unpacks a successful response body into the payload the service's own methods work with. - * Override for APIs that wrap everything in an envelope, and that report failures inside a - * 200 response — throwing from here routes those through the same typed errors as any other. + * Unpacks a successful response body. Override for APIs that wrap everything in an envelope and + * report failures inside a 200 — throwing from here routes those through the same typed errors. * @param {any} json * @returns {any} */ @@ -492,10 +445,9 @@ export default class DebridService { } /** - * Caps a pack's file list, keeping a window centred on the file playback wants rather - * than its first N entries. Every service hits this: a season pack can hold hundreds of - * files, the wanted episode is often a late one, and dropping it forces an expensive - * re-add. Torrent order is preserved so in-player next/previous still works. + * Caps a pack's file list around the file playback wants rather than taking the first N. The + * wanted episode is often a late one, and dropping it forces an expensive re-add. Torrent order + * is preserved so in-player next/previous still works. * @template T * @param {T[]} files - Candidate files, in torrent order. * @param {T | null} target - The file playback asked for, or null when there is none. @@ -512,10 +464,9 @@ export default class DebridService { } /** - * Turns candidate files into stream links concurrently, skipping the individual ones the - * service cannot serve. Packs really do contain dead files (Real-Debrid answers - * `hoster_unavailable`), and one of those must not fail the whole resolve. Authentication - * failures still abort, since every other link would fail for the same reason. + * Turns candidates into stream links concurrently, skipping ones the service cannot serve — + * packs do contain dead files, and one must not fail the whole resolve. Auth failures still + * abort, since every other link would fail the same way. * @template T * @param {T[]} candidates * @param {(candidate: T) => Promise} toFile - Unrestricts one file, may return null to drop it. @@ -536,11 +487,8 @@ export default class DebridService { } /** - * Records what is known about a release so later checks are free. Playback feeds this too: - * a resolve that succeeded proves the service holds it, and the answer it failed with proves - * whichever state that error stands for. - * - * Unknown is not an answer, so recording it forgets what was there instead of storing it. + * Records what is known about a release so later checks are free. Playback feeds this too. + * Unknown is not an answer, so recording it forgets what was there. * @param {string} magnetOrHash * @param {string} state - An `Availability` value. */ @@ -566,25 +514,19 @@ export default class DebridService { } /** - * The given hashes that nothing is known about yet, in the order supplied. Callers use this - * to skip work entirely rather than to decide what to ask about, which checkAvailability - * does itself. + * The given hashes nothing is known about yet, in the order supplied. Callers use this to skip + * work entirely, not to decide what to ask about. * @param {string[]} magnetsOrHashes * @returns {string[]} */ unknownHashes (magnetsOrHashes) { - return DebridService.#normalize(magnetsOrHashes, this.#askLimit()).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) - } - - /** How far down a results list this service is willing to look. Probing bites, batching does not. */ - #askLimit () { - return this.config.maxAsk + return DebridService.#normalize(magnetsOrHashes, this.config.maxAsk).filter(hash => this.#recall(hash) === undefined && !this.probes.has(hash)) } /** * Lowercase, deduplicated hashes, order preserved. * @param {string[]} magnetsOrHashes - * @param {number} [limit] - Stop after this many usable hashes, so a long list costs nothing to trim. + * @param {number} [limit] - Stop after this many, so a long list costs nothing to trim. */ static #normalize (magnetsOrHashes, limit = Infinity) { const hashes = new Set() @@ -597,23 +539,17 @@ export default class DebridService { } /** - * Reports what the service can do with each of the given releases. - * - * Remembered answers come back for free. Whatever is left is asked about in the cheapest way - * the service supports: one batch call where the API offers a cache endpoint, a capped number - * of probes where it does not. Hashes that stay unanswered are simply absent from the result, - * which callers must treat as unknown rather than as "not cached". - * - * `onAnswer` fires as each answer lands, so a slow probe sweep marks the list up as it goes. + * What the service can do with each of the given releases. Remembered answers come back free, + * the rest are asked about the cheapest way the service supports. Hashes that stay unanswered + * are absent from the result, which callers must read as unknown rather than "not cached". * @param {string[]} magnetsOrHashes - Candidates, most relevant first, since probing bites from the front. - * @param {{ onAnswer?: (hash: string, state: string) => void }} [opts] + * @param {{ onAnswer?: (hash: string, state: string) => void }} [opts] - Fires as each answer lands. * @returns {Promise>} Hash to `Availability`, answered hashes only. */ async checkAvailability (magnetsOrHashes, { onAnswer } = {}) { const answers = new Map() const mode = this.config.availabilityCheck - // probing only ever looks at the top of the list, so normalize just that much of it - const candidates = DebridService.#normalize(magnetsOrHashes, this.#askLimit()) + const candidates = DebridService.#normalize(magnetsOrHashes, this.config.maxAsk) const unknown = [] for (const hash of candidates) { const known = this.#recall(hash) @@ -627,14 +563,14 @@ export default class DebridService { onAnswer?.(hash, state) } - // One check at a time where asking means putting magnets on the account: services rate limit - // adding far harder than reading, so overlapping checks do not answer faster, they get - // refused. A free cache lookup has nothing to protect and runs whenever it is asked. + // one at a time where asking adds magnets: services rate limit adding far harder than + // reading, so overlapping checks do not answer faster, they get refused if (this.config.checkAddsMagnets) { if (this.sweeping) return answers this.sweeping = true } try { + if (this.orphaned) await this.retryCleanup() // clear our own leftovers before adding more if (mode === 'batch') await this.#batch(unknown, answer) else await this.#sweep(unknown, answer) } finally { @@ -653,9 +589,8 @@ export default class DebridService { const chunk = hashes.slice(index, index + this.config.maxBatch) const states = await this.checkAvailabilityBatch(chunk) for (const hash of chunk) { - // a cache endpoint that answered but did not mention a hash has said it does not hold it, - // not that it cannot fetch it. A check that works by adding magnets gets no such reading: - // it answers about the magnets it managed to take, so unmentioned means unasked + // a cache endpoint that answered without mentioning a hash has said it does not hold it. + // A check that adds magnets has only said it never got to it const state = normalizeAvailability(states?.get(hash) ?? (this.config.checkAddsMagnets ? Availability.UNKNOWN : Availability.AVAILABLE)) this.remember(hash, state) if (state !== Availability.UNKNOWN) answer(hash, state) @@ -664,19 +599,14 @@ export default class DebridService { } /** - * Probes a list of hashes a few at a time, stopping early once the service is clearly in no - * state to answer any more of them. - * - * Stopping is not the same as finishing: whatever is left stays unknown and re-checkable, and - * the caller is expected to come back to it. That matters most on a link where probes time out - * — giving up on the list permanently is what leaves a results list with two badges on it. + * Probes hashes a few at a time, stopping early once the service is in no state to answer more. + * Stopping is not finishing: what is left stays unknown and the caller comes back to it. * @param {string[]} hashes * @param {(hash: string, state: string) => void} answer */ async #sweep (hashes, answer) { const queue = [...hashes] let failures = 0 - /** @type {any} Why the sweep stopped, or null while it is still going. */ let stopped = null const worker = async () => { while (queue.length && !stopped) { @@ -687,8 +617,6 @@ export default class DebridService { } catch (error) { if (error instanceof DebridAuthError) { stopped = error; return } // every other probe would fail too debug(`Availability probe failed for ${hash}: ${error.message}`) - // being told to slow down, or a run of failures, ends the sweep. The rest stay - // unknown and are asked about again later rather than being called uncached if (this.throttled(error) || ++failures >= MAX_PROBE_FAILURES) stopped = error } } @@ -699,10 +627,8 @@ export default class DebridService { } /** - * Runs one probe, sharing it with any caller already waiting on that hash, and applies the - * rule for what counts as an answer: a state the service reported, or one a definite error - * proves. Anything else is no answer at all — it throws, so the sweep counts it as a failure - * and the release is left unremembered and re-checkable rather than badged as nothing. + * Runs one probe, shared with any caller already waiting on that hash. Only a reported state or + * a definite error counts as an answer; anything else throws, so the release stays re-checkable. * @param {string} hash * @returns {Promise} Never resolves to `unknown`. */ @@ -727,13 +653,10 @@ export default class DebridService { } /** - * Determines what the service can do with one release, for services with no cache endpoint. - * Implementations must leave the account exactly as they found it. - * - * Return an `Availability`, or throw `DebridNotCachedError` / `DebridUnavailableError` for - * the two definite negatives. Let everything else throw untyped: the base class reads any - * other error as "no answer", which is what stops a bad minute on the wire from blanking - * out a whole results list. + * What the service can do with one release, for APIs with no cache endpoint. Must leave the + * account exactly as it found it. Return an `Availability`, or throw `DebridNotCachedError` / + * `DebridUnavailableError`. Let everything else throw untyped: the base class reads any other + * error as "no answer". * @abstract * @param {string} hash - Lowercase info hash. * @returns {Promise} @@ -741,10 +664,8 @@ export default class DebridService { async probeAvailability (hash) { throw new DebridNotImplementedError(this.config.title) } /** - * Asks the service about many releases at once. Implement this for any API that exposes a - * cache endpoint, and set `availabilityCheck` to 'batch'. Chunking to `maxBatch` is already - * done. Hashes left out of the answer are recorded as available, since a cache endpoint - * saying no means the service would have to fetch it rather than that it cannot. + * Asks about many releases at once, for APIs with a cache endpoint. Chunking to `maxBatch` is + * already done. Hashes left out are recorded as available unless `checkAddsMagnets`. * @abstract * @param {string[]} hashes - Lowercase info hashes. * @returns {Promise>} Hash to `Availability`. @@ -759,19 +680,16 @@ export default class DebridService { async validate () { throw new DebridNotImplementedError(this.config.title) } /** - * What the account itself already says about releases, which costs one request and is never - * wrong: everything it holds is cached, everything it is still fetching is available, and - * everything that failed on it is unavailable. This is the badge source every service has, - * whether or not it can be asked about releases the account has never seen. + * What the account itself says: what it holds is cached, what it is fetching is available, what + * failed on it is unavailable. The free badge source, where the API exposes info hashes. * @abstract * @returns {Promise>} Lowercase info hash to `Availability`. */ async listAvailability () { throw new DebridNotImplementedError(this.config.title) } /** - * Resolves a magnet to direct stream URLs. Throws `DebridNotCachedError` when the service - * would have to download the torrent first, `DebridUnavailableError` when it cannot serve it - * at all. Returned URLs must be HTTPS. + * Resolves a magnet to direct stream URLs. Throws `DebridNotCachedError` when the service would + * have to download it first, `DebridUnavailableError` when it cannot serve it. URLs must be HTTPS. * @abstract * @param {string} magnet - Magnet URI or bare info hash. * @param {{ fileFilter?: (name: string) => boolean, pickFile?: (files: { id: number, path: string, size: number }[]) => Promise, maxFiles?: number }} [opts] @@ -783,10 +701,13 @@ export default class DebridService { destroy () { this.availabilityState.clear() this.sweeping = false - // probes already running own a torrent on the user's account until they tear it down, so - // the limiter has to outlive them. Dropping its queue first is what strands one there. + // running probes own a torrent until they tear it down, so the limiter has to outlive them, + // and anything left unremoved gets a last attempt — nothing else holds those ids const pending = [...this.probes.values()] this.probes.clear() - Promise.allSettled(pending).finally(() => this.limiter.stop({ dropWaitingJobs: true }).catch(() => {})) + Promise.allSettled(pending) + .then(() => this.retryCleanup()) + .catch(() => {}) + .finally(() => this.limiter.stop({ dropWaitingJobs: true }).catch(() => {})) } } diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js index e3562186..cbbf7f72 100644 --- a/common/modules/debrid/torbox.js +++ b/common/modules/debrid/torbox.js @@ -5,15 +5,10 @@ import Debug from 'debug' const debug = Debug('ui:debrid') const API = 'https://api.torbox.app/v1/api' -// the account's torrent list comes back in one request; the API pages at 1000 -const LIST_LIMIT = 1_000 -// seed: 1 auto, 2 always, 3 never. Shiru only streams, so the account is never asked to seed -const SEED_NEVER = 3 +const LIST_LIMIT = 1_000 // the whole account in one request; the API pages at 1000 +const SEED_NEVER = 3 // 1 auto, 2 always, 3 never. Shiru only streams, so never seed -/** - * TorBox error codes worth explaining, anything else falls back to the API's own detail line. - * https://api-docs.torbox.app/ - */ +// error codes worth explaining, anything else falls back to the API's own detail line const errorMessages = { BAD_TOKEN: 'Invalid TorBox API key', AUTH_ERROR: 'TorBox rejected the API key', @@ -34,30 +29,24 @@ const deadStates = /(stalled|error|failed|missing)/i /** * TorBox implementation, see https://api-docs.torbox.app/ * - * The API differs from Real-Debrid's in three ways this client has to account for: - * - `/torrents/checkcached` answers many hashes in one request, so every result in a search can - * carry a real badge instead of the handful a probing service can afford. - * - Every response is wrapped in a `{ success, data }` envelope and failures can arrive with a - * 200, so `unwrap` unpacks and throws rather than each method checking. - * - `/torrents/requestdl` authenticates with a `token` query parameter while everything else - * uses a bearer header. + * Three differences from Real-Debrid shape this client: `/torrents/checkcached` answers many + * hashes in one request, every response is wrapped in `{ success, data }` with failures arriving + * inside a 200, and `/torrents/requestdl` authenticates with a `token` query parameter while + * everything else uses a bearer header. */ export default class TorBox extends DebridService { static id = 'torbox' static title = 'TorBox' static available = true - // documented allowance is 300 requests a minute per endpoint; spending it as if it were the - // budget for all of them keeps a season pack's worth of link requests well inside it + // documented allowance is 300 a minute per endpoint; spending it as if it covered all of them + // keeps a season pack's worth of link requests well inside it static limits = { reservoir: 300, reservoirRefreshAmount: 300, reservoirRefreshInterval: 60_000, maxConcurrent: 3, minTime: 200 } // a real cache endpoint, so badges cost one request for the whole results list static availabilityCheck = 'batch' // hashes travel as repeated query parameters, so the chunk size keeps the URL sane static maxBatch = 75 - /** - * TorBox wraps every response in `{ success, data, error, detail }` and reports plenty of - * failures with a 200, so success is decided here rather than by the status code alone. - */ + /** Failures arrive inside a 200, so success is decided here rather than by the status code. */ unwrap (json) { if (!json || typeof json !== 'object' || !('success' in json)) return json if (!json.success) throw this.mapError(200, json) @@ -67,7 +56,7 @@ export default class TorBox extends DebridService { mapError (status, json) { const code = json?.error // `detail` is usually a sentence, but a rejected request answers with a list of field - // problems instead, which is for the log rather than for the user + // problems instead, which is for the log rather than the user const detail = typeof json?.detail === 'string' ? json.detail : '' const message = errorMessages[code] || detail || (typeof code === 'string' && code) || `Request failed with status ${status}` if (authCodes.includes(code) || ((status === 401 || status === 403) && !code)) return new DebridAuthError(message, { status, code }) @@ -81,8 +70,8 @@ export default class TorBox extends DebridService { } /** - * The account's torrents. TorBox caches this itself, which is fine and faster for the badge - * listing; `bypass_cache` is only worth its latency when polling a change we just made. + * The account's torrents. TorBox caches this itself, which is faster for the badge listing; + * `bypass_cache` is only worth its latency when polling a change just made. * @param {{ id?: string | number, fresh?: boolean }} [opts] * @returns {Promise} */ @@ -107,8 +96,8 @@ export default class TorBox extends DebridService { } /** - * The reason TorBox is pleasant to badge: one request answers the whole results list. - * Hashes the endpoint leaves out are not cached, which the base class records as available. + * One request answers the whole results list. Hashes left out are not cached, which the base + * class records as available. * @param {string[]} hashes */ async checkAvailabilityBatch (hashes) { @@ -133,9 +122,8 @@ export default class TorBox extends DebridService { let added = false try { if (!torrent) { - // ask before adding: unlike Real-Debrid, TorBox answers for free, and an uncached - // release must not be queued onto the account just to find that out — adding one spends - // from a much tighter allowance (60 an hour) than a cached add does + // ask before adding: the answer is free, and adding an uncached torrent spends from a + // much tighter allowance (60 an hour) than a cached add does if ((await this.checkAvailabilityBatch([hash])).get(hash) !== Availability.CACHED) throw new DebridNotCachedError() ;({ torrent, added } = await this.#add(magnetURI, hash)) } @@ -158,18 +146,14 @@ export default class TorBox extends DebridService { } /** - * Adds a magnet and reads back the account entry for it. - * - * `added` reports whether this call is the one that put the torrent there, and only that - * makes it ours to remove again: the account can already hold a release the listing missed a - * moment earlier, and deleting one of the user's own downloads is not a recoverable mistake. + * Adds a magnet and reads back the account entry for it. `added` reports whether this call is + * what put it there, which is the only thing that makes it ours to remove again. * @param {string} magnetURI * @param {string} hash * @returns {Promise<{ torrent: any, added: boolean }>} */ async #add (magnetURI, hash) { - // multipart is what the endpoint documents, and allow_zip off keeps a pack as individual - // files rather than one archive the player cannot seek in + // allow_zip off keeps a pack as individual files rather than one archive the player cannot seek const created = await this.request(`${API}/torrents/createtorrent`, { method: 'POST', encoding: 'multipart', @@ -191,9 +175,8 @@ export default class TorBox extends DebridService { } /** - * Waits for a freshly added torrent to show up on the account and settle. A cached release is - * complete the moment TorBox accepts it, so this waits only `timeouts.ready` before handing - * back whatever it has, which the caller reads as a fresh download rather than a cache hit. + * Waits for a freshly added torrent to show up and settle. A cached release is complete the + * moment TorBox accepts it, so anything slower reads as a fresh download. * @param {string | number | undefined} id * @param {string} hash */ @@ -212,12 +195,9 @@ export default class TorBox extends DebridService { } /** - * The account's current entry for an info hash, which is how a release already on the account - * is reused instead of added twice. - * - * The listing behind this can be up to a minute old, so the entry it names is read back by id - * before playback acts on it: a torrent deleted from another device in the meantime has to - * read as "not on the account" and be added again, not fail the resolve with a dead id. + * The account's entry for an info hash, which is how a release already there is reused rather + * than added twice. Read back by id because the listing can be a minute stale, so one deleted + * elsewhere must read as absent rather than fail the resolve. * @param {string} hash * @param {{ listed?: boolean }} [opts] - `listed` false skips the listing, for a hash known to be absent from it. * @returns {Promise} @@ -226,8 +206,8 @@ export default class TorBox extends DebridService { if (!hash) return null const known = listed ? (await this.listing()).find(torrent => String(torrent?.hash || '').toLowerCase() === hash) : null if (!known) return null - // a failed read is treated as "gone" rather than raised: the caller's next move is to check - // the cache and add the magnet, which fails loudly enough if the API is really unreachable + // a failed read reads as "gone": the caller then checks the cache and adds the magnet, which + // fails loudly enough if the API is really unreachable const [confirmed] = await this.#accountTorrents({ id: known.id, fresh: true }).catch(() => []) if (!confirmed) { debug(`Account listing named a torrent that is gone (${known.id}), adding the magnet instead`) @@ -237,8 +217,7 @@ export default class TorBox extends DebridService { } /** - * Turns the wanted files into direct stream links. A dead file inside a pack is skipped - * rather than failing the whole resolve, the same rule every service follows. + * Turns the wanted files into direct stream links, skipping dead ones. * @param {any} torrent * @param {{ id: number, path: string, size: number, type?: string }[]} wanted */ @@ -258,9 +237,8 @@ export default class TorBox extends DebridService { } /** - * What the account says about one of its torrents. `download_present` is the field that means - * the data is actually sitting on TorBox's servers, which is the only thing that makes a - * release streamable now. + * What the account says about one of its torrents. `download_present` means the data really is on + * TorBox's servers, which is the only thing that makes a release streamable now. * @param {any} torrent * @returns {string} */ @@ -271,8 +249,7 @@ function torrentAvailability (torrent) { } /** - * TorBox reports a file's full path in `name` and its bare filename in `short_name`, both - * without a leading slash. Shiru's file objects use a rooted path, like the torrent client's. + * Full path is in `name`, bare filename in `short_name`, neither rooted. Shiru's file objects are. * @param {any} file */ function filePath (file) { diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index 9521bc43..b7c8c670 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -73,7 +73,7 @@ - - - + {/if} From f6008c853f52688d91b4ebe1d2917c8cab1ab000 Mon Sep 17 00:00:00 2001 From: zeroz Date: Mon, 10 Aug 2026 23:15:46 -0400 Subject: [PATCH 11/11] attempt to bring font and external subtitle handling from debrid to parity with all torrent options --- client/core/webtorrent.js | 76 +++++++++---------- .../torrent/components/TorrentCard.svelte | 4 +- .../torrent/components/TorrentResults.svelte | 18 ++--- common/modules/debrid/alldebrid.js | 10 +-- common/modules/debrid/availability.js | 12 +-- common/modules/debrid/debrid.js | 75 +++++++++--------- common/modules/debrid/metadata.js | 45 ++++++----- common/modules/debrid/premiumize.js | 8 +- common/modules/debrid/realdebrid.js | 41 +++++----- common/modules/debrid/route.js | 2 +- common/modules/debrid/service.js | 51 ++++++++----- common/modules/debrid/services.js | 20 +++++ common/modules/debrid/torbox.js | 14 ++-- common/modules/torrent.js | 7 +- common/modules/util.js | 23 +++++- common/routes/settings/tabs/DebridTab.svelte | 17 ++++- 16 files changed, 236 insertions(+), 187 deletions(-) create mode 100644 common/modules/debrid/services.js diff --git a/client/core/webtorrent.js b/client/core/webtorrent.js index c331faa6..cc2ba984 100644 --- a/client/core/webtorrent.js +++ b/client/core/webtorrent.js @@ -3,7 +3,7 @@ import HTTPTracker from 'http-tracker' import Client from 'bittorrent-tracker' import { hex2bin, arr2hex, text2arr } from 'uint8-util' import { makeHash, getInfoHash, hasIntegrity, getProgressAndSize, stringifyQuery, errorToString, TMP } from '@client/lib/util.js' -import { fontRx, sleep, matchSubtitleFiles, isValidNumber } from '@/modules/util.js' +import { sleep, matchFontFiles, matchSubtitleFiles, isValidNumber } from '@/modules/util.js' import { SUPPORTS } from '@/modules/support.js' import { spawn } from 'node:child_process' import Metadata from '@client/lib/metadata.js' @@ -198,6 +198,26 @@ export default class TorrentClient extends WebTorrent { timeout.unref?.() } + /** + * Detaches whatever was playing: the external player, the streamed file and its metadata parser. + * Shared with debrid playback, which has the same to let go of and nothing to attach after. + * @param {number} [progress] - Progress of the file taking over, which decides whether the + * outgoing one keeps downloading. Defaults to the outgoing file's own progress. + */ + releaseCurrentFile(progress = this.currentFile?.progress) { + if (this.playerProcess) { + this.playerProcess.kill() + this.playerProcess = null + } + if (this.currentFile) { + this.currentFile.removeAllListeners('stream') + this.currentFile.removeAllListeners('iterator') + if (this.settings.torrentStreamedDownload && !this.currentFile._destroyed && progress < 1) this.currentFile.deselect() + } + this.metadata?.destroy?.() + this.metadata = null + } + /** * Searches the current torrent for embedded font files and sends them to the renderer for use. * @param {object} targetFile - File currently being processed. @@ -205,17 +225,11 @@ export default class TorrentClient extends WebTorrent { async findFontFiles(targetFile) { const currentTorrent = this.torrents.find(torrent => torrent.current) if (!currentTorrent?.files) return - const fontFiles = currentTorrent.files.filter(file => fontRx.test(file.name)) - const map = {} + // shared with debrid playback so both lanes deduplicate a release's fonts the same way + const fontFiles = matchFontFiles(currentTorrent.files) + debug(`Found ${fontFiles.length} font files`) - // deduplicate fonts - // some releases have duplicate fonts for diff languages - // if they have different chars, we can't find that out anyways - // so some chars might fail, on REALLY bad releases - for (const file of fontFiles) map[file.name] = file - debug(`Found ${Object.keys(map).length} font files`) - - for (const file of Object.values(map)) { + for (const file of fontFiles) { const data = await file.arrayBuffer() if (targetFile !== this.currentFile) return this.dispatch('file', { data: new Uint8Array(data) }, [data]) @@ -490,22 +504,12 @@ export default class TorrentClient extends WebTorrent { } case 'current': { if (data.data) { if (data.data.current.debrid) { - // debrid files stream straight from the service over HTTPS and never join the - // torrent client, so there is nothing to attach, only the previous playback to release - if (this.playerProcess) { - this.playerProcess.kill() - this.playerProcess = null - } - if (this.currentFile) { - this.currentFile.removeAllListeners('stream') - this.currentFile.removeAllListeners('iterator') - if (this.settings.torrentStreamedDownload && !this.currentFile._destroyed && this.currentFile.progress < 1) this.currentFile.deselect() - this.currentFile = null - } - this.metadata?.destroy?.() - this.metadata = null - // nothing is playing from the client anymore, so stop reporting the old torrent - // as current or its peers and speeds keep flowing to the player and torrent manager + // debrid files stream straight from the service over HTTPS and never join the client, + // so there is nothing to attach, only the previous playback to release + this.releaseCurrentFile() + this.currentFile = null + // nothing is playing from the client anymore, so stop reporting the old torrent as + // current or its peers and speeds keep flowing to the player and torrent manager const lastTorrent = this.torrents.find(_torrent => _torrent.current) if (lastTorrent) { lastTorrent.current = false @@ -518,15 +522,7 @@ export default class TorrentClient extends WebTorrent { if (!torrent || torrent.destroyed) return const found = torrent.files.find(file => file.path === data.data.current.path) if (!found || found._destroyed) return - if (this.playerProcess) { - this.playerProcess.kill() - this.playerProcess = null - } - if (this.currentFile) { - this.currentFile.removeAllListeners('stream') - this.currentFile.removeAllListeners('iterator') - if (this.settings.torrentStreamedDownload && !this.currentFile._destroyed && found.progress < 1) this.currentFile.deselect() - } + this.releaseCurrentFile(found.progress) if (this.settings.torrentStreamedDownload && found.progress < 1) { this.torrents.filter(_torrent => (_torrent.staging || _torrent.seeding) && Array.isArray(_torrent.files)).forEach(_torrent => { _torrent.files.forEach(file => { @@ -534,8 +530,6 @@ export default class TorrentClient extends WebTorrent { }) }) } - this.metadata?.destroy?.() - this.metadata = null found.select() if (this.settings.torrentStreamedDownload && (found.length > await this.storageQuota(torrent.path))) this.dispatchError('File Too Big! This File Exceeds The Selected Drive\'s Available Space. Change Download Location In Torrent Settings To A Drive With More Space And Restart The App!') @@ -585,8 +579,10 @@ export default class TorrentClient extends WebTorrent { this.playerProcess.kill() this.playerProcess = null } + // a debrid file carries its own HTTPS url, a torrent file streams from the local server + const url = current?.debrid ? found.url : `http://localhost:${this.server.address().port}${found.streamURL}` if (this.player) { - this.playerProcess = spawn(this.player, ['' + new URL(current?.debrid ? found.url : 'http://localhost:' + this.server.address().port + found.streamURL)]) + this.playerProcess = spawn(this.player, ['' + new URL(url)]) this.playerProcess.stdout.on('data', () => {}) this.playerProcess.once('close', () => { if (this.destroyed) return @@ -594,7 +590,7 @@ export default class TorrentClient extends WebTorrent { const seconds = (Date.now() - startTime) / 1000 this.dispatch('externalWatched', seconds) }) - } else if (SUPPORTS.isAndroid) this.dispatch('androidExternal', current?.debrid ? `intent://${found.url.replace(/^https?:\/\//, '')}#Intent;type=video/any;scheme=${found.url.startsWith('https') ? 'https' : 'http'};end;` : `intent://localhost:${this.server.address().port}${found.streamURL}#Intent;type=video/any;scheme=http;end;`) + } else if (SUPPORTS.isAndroid) this.dispatch('androidExternal', `intent://${url.replace(/^https?:\/\//, '')}#Intent;type=video/any;scheme=${url.startsWith('https:') ? 'https' : 'http'};end;`) break } case 'torrent': { const hash = data.data && data.data.hash diff --git a/common/modals/torrent/components/TorrentCard.svelte b/common/modals/torrent/components/TorrentCard.svelte index b30f64bb..d8e3aa4f 100644 --- a/common/modals/torrent/components/TorrentCard.svelte +++ b/common/modals/torrent/components/TorrentCard.svelte @@ -11,8 +11,8 @@ import { settings } from '@/modules/settings.js' import { Database, BadgeCheck, HardDrive, FileQuestion, AlertCircle, TriangleAlert, Cloud, CloudDownload, CloudOff, CloudAlert } from 'lucide-svelte' - // one badge per availability state, so a glance at the list separates what streams instantly - // from what the service would have to fetch, from what it cannot serve at all + // one badge per availability state, so a glance separates what streams instantly from what the + // service would have to fetch, from what it cannot serve at all const availabilityBadges = { [Availability.CACHED]: { icon: Cloud, style: 'background: hsla(var(--primary-color-dim-hsl), .15); border-color: var(--primary-color-light) !important; color: var(--primary-color-light)' }, [Availability.AVAILABLE]: { icon: CloudDownload, style: 'background: hsla(var(--warning-color-dim-hsl), .15); border-color: var(--warning-color-dim) !important; color: var(--warning-color-dim)' }, diff --git a/common/modals/torrent/components/TorrentResults.svelte b/common/modals/torrent/components/TorrentResults.svelte index 5c28dfbd..66edc536 100644 --- a/common/modals/torrent/components/TorrentResults.svelte +++ b/common/modals/torrent/components/TorrentResults.svelte @@ -115,11 +115,10 @@ const sameOrder = (a, b) => a.length === b.length && a.every((entry, index) => entry === b[index]) /** - * Builds the function that splits sorted results into what is listed and what is hidden, and - * tallies what the debrid service said about each. Kept apart from the sorting above so a - * debrid answer only redoes these passes, not the dedupe and sort of every result. The - * previous split is remembered in a closure rather than a component variable, so it stays out - * of the reactive graph. + * Splits sorted results into what is listed and what is hidden, and tallies what the debrid + * service said about each. Kept apart from the sorting above so an answer landing only redoes + * these passes, not the dedupe and sort. The previous split lives in the closure rather than a + * component variable to stay out of the reactive graph. * @returns {(sorted: Result[], availability?: Map, filters?: { cachedOnly?: boolean, only?: boolean }) => any} */ function createListResults() { @@ -131,14 +130,13 @@ for (const entry of sorted) { const state = availability ? availabilityOf(availability, entry.hash) : Availability.UNKNOWN counts[state]++ - // this narrows what the rest of the modal sees, so the best pick and autoplay follow - // it too, which is the whole point in debrid only mode + // narrows what the rest of the modal sees, so the best pick and autoplay follow it too if (listResult(entry, state, filters)) results.push(entry) else hiddenResults.push(entry) } - // most answers only move the counts, since a release with seeders was listed either way. - // Handing back the same arrays then keeps the best-release pick from being redone, which - // reparses every result and is what made answers landing feel like a freeze. + // most answers only move the counts, since a seeded release was listed either way. Handing + // back the same arrays keeps the best-release pick from being redone, which reparses every + // result and is what made answers landing feel like a freeze if (previous && sameOrder(previous.results, results) && sameOrder(previous.hiddenResults, hiddenResults)) { return { ...previous, counts } } diff --git a/common/modules/debrid/alldebrid.js b/common/modules/debrid/alldebrid.js index 04883f52..3d6a4fc7 100644 --- a/common/modules/debrid/alldebrid.js +++ b/common/modules/debrid/alldebrid.js @@ -42,11 +42,11 @@ const READY = 4 * AllDebrid implementation, see https://docs.alldebrid.com/ * * Two API quirks shape this client: - * - `/magnet/instant` is gone, so availability is read off the upload response instead, which - * answers `ready` per magnet and takes many at once. Cheap in requests, but every hash checked - * lands on the account for a moment, hence the small caps below. - * - `/magnet/status` never says which info hash a magnet came from, so the account cannot be - * read for badges, only for which ids were already there before we uploaded anything. + * - `/magnet/instant` is gone, so availability is read off the upload response, which answers + * `ready` per magnet and takes many at once. Cheap in requests, but every hash checked lands on + * the account for a moment, hence the small caps below. + * - `/magnet/status` never says which info hash a magnet came from, so the account is only good + * for telling this client's uploads from the user's own, never for badges. */ export default class AllDebrid extends DebridService { static id = 'alldebrid' diff --git a/common/modules/debrid/availability.js b/common/modules/debrid/availability.js index d69cdeab..044f5b30 100644 --- a/common/modules/debrid/availability.js +++ b/common/modules/debrid/availability.js @@ -1,10 +1,10 @@ -// The vocabulary the whole debrid layer uses to describe a release. Pure data and pure -// functions, free of UI and network imports, so it runs under plain Node for tests. +// The vocabulary the whole debrid layer uses to describe a release. Pure data and pure functions, +// free of UI and network imports, so it runs under plain Node for tests. /** * What a debrid service can do with a release right now. Services differ wildly in how well they - * can answer, but all describe themselves with these four values, so the rest of the app never - * has to care which kind it is talking to. + * can answer, but all speak these four values, so the rest of the app never has to care which + * kind it is talking to. */ export const Availability = Object.freeze({ /** The service holds it and streams it immediately. */ @@ -42,8 +42,8 @@ export function isAvailability (value) { } /** - * Anything unrecognised reads as unknown, so a service returning something unexpected degrades - * to "no answer" rather than poisoning the badges. + * Anything unrecognised reads as unknown, so a service answering something unexpected degrades to + * "no answer" rather than poisoning the badges. * @param {any} value * @returns {string} */ diff --git a/common/modules/debrid/debrid.js b/common/modules/debrid/debrid.js index 5e6650c7..c7ff6770 100644 --- a/common/modules/debrid/debrid.js +++ b/common/modules/debrid/debrid.js @@ -1,36 +1,32 @@ import { files } from '@/components/MediaHandler.svelte' import { settings } from '@/modules/settings.js' import { status } from '@/modules/networking.js' -import { videoRx, subRx } from '@/modules/util.js' +import { videoRx, subRx, fontRx } from '@/modules/util.js' import { anitomyscript } from '@/modules/anime/anime.js' import { writable } from 'simple-store-svelte' import { derived } from 'svelte/store' import { toast } from 'svelte-sonner' -import RealDebrid from '@/modules/debrid/realdebrid.js' -import AllDebrid from '@/modules/debrid/alldebrid.js' -import TorBox from '@/modules/debrid/torbox.js' -import Premiumize from '@/modules/debrid/premiumize.js' import DebridService, { availabilityFromError, secureFiles } from '@/modules/debrid/service.js' +import { debridServices, debridService } from '@/modules/debrid/services.js' import { Availability, describeAvailability } from '@/modules/debrid/availability.js' import { routeDebrid, debridKey } from '@/modules/debrid/route.js' import Debug from 'debug' const debug = Debug('ui:debrid') -// register new services here, in the order the settings menu offers them. The only place that -// touches service classes; everything else goes through the stores and functions below. -const debridServices = Object.fromEntries([AllDebrid, Premiumize, RealDebrid, TorBox].filter(Service => Service.available).map(Service => [Service.id, Service])) - /** Selectable services for the settings menu, as plain data. */ export const debridOptions = Object.values(debridServices).map(Service => ({ id: Service.id, title: Service.title })) +/** Files worth resolving: the video, its subtitles, and the fonts those subtitles need. */ +const playbackRx = new RegExp(`${videoRx.source}|${subRx.source}|${fontRx.source}`, 'i') + const REFRESH_INTERVAL = 60_000 -// how long before re-asking about releases a check could not answer, and how far that backs off -// while it keeps not answering. Without it a bad minute leaves a results list half badged +// how long before asking again about releases a check could not answer, and how far that backs +// off while it keeps not answering. Without it a bad minute leaves a results list half badged const RETRY_DELAY = 10_000 const MAX_RETRY_DELAY = 4 * 60_000 -// user facing messages for the routing policy's blocked outcomes +/** What the user is told when the routing policy blocks playback. */ const blockedMessages = { key: () => 'Debrid only mode is on but no API key is set. Add your key in the debrid settings or disable debrid only mode.', offline: () => 'Shiru is currently offline, so ' + serviceTitle() + ' cannot be reached.', @@ -43,20 +39,17 @@ let serviceKey = null let lastRefresh = 0 /** Whether a debrid service is selected and has an API key. */ -export const debridEnabled = derived(settings, value => Boolean(debridServices[value.debridService] && debridKey(value))) +export const debridEnabled = derived(settings, value => Boolean(debridService(value.debridService) && debridKey(value))) -/** - * How playback is routed right now, or null when no debrid service is selected. - * The single source the UI reads to describe the active transport. - */ +/** How playback is routed right now, or null when no service is selected. The UI reads this to describe the active transport. */ export const debridTransport = derived(settings, value => { - const Service = debridServices[value.debridService] + const Service = debridService(value.debridService) if (!Service) return null const only = value.debridMode === 'only' return { title: Service.title, only, - checksAddMagnets: Service.checkAddsMagnets, // the only thing worth offering an opt out for + checksAddMagnets: Service.checkAddsMagnets, label: only ? 'Debrid Only' : 'Debrid First', description: only ? `Debrid Only: playback always uses ${Service.title}, torrents never start.` @@ -65,8 +58,8 @@ export const debridTransport = derived(settings, value => { }) /** - * What the configured service can do with each release, keyed by lowercase info hash. - * The one place the UI reads cache state from; anything absent is simply unknown. + * What the service can do with each release, keyed by lowercase info hash. The only place the UI + * reads cache state from; anything absent is unknown rather than uncached. * @type {import('simple-store-svelte').Writable>} */ export const debridAvailability = writable(new Map()) @@ -75,13 +68,13 @@ export const debridAvailability = writable(new Map()) export const debridChecking = writable(0) /** - * Whether debrid owns what the player is showing. Set the moment playback is routed, before the - * resolve, since the player opens straight away and must not look like a torrent while it waits. + * Whether debrid owns what the player is showing. Set the moment playback is routed rather than + * once it resolves, since the player opens straight away and must not look like a torrent. */ export const debridPlayback = writable(false) -// switching service or key takes effect immediately: the old instance is torn down and the -// badges dropped, since they described a different account +// switching service or key takes effect immediately: tear the old instance down and drop the +// badges, which described a different account settings.subscribe(value => { const key = `${value.debridService}:${debridKey(value)}` if (serviceKey !== null && serviceKey !== key) { @@ -96,7 +89,7 @@ settings.subscribe(value => { function getService () { if (service) return service - const Service = debridServices[settings.value.debridService] + const Service = debridService(settings.value.debridService) const apiKey = debridKey(settings.value) if (!Service || !apiKey) return null debug(`Initializing debrid service ${Service.title}`) @@ -117,10 +110,10 @@ export async function testDebrid () { * handled, false to fall back to torrents. Routing policy lives in route.js. * @param {string} torrentID - Magnet URI, info hash, or .torrent link. * @param {string} [hash] - Info hash when known. - * @param {{ episode?: number }} [search] - Playback context for picking the right file in packs. + * @param {{ episode?: number }} [search] - Playback context, for picking the right file in packs. */ export async function streamDebrid (torrentID, hash, search) { - const serviceSelected = Boolean(debridServices[settings.value.debridService]) + const serviceSelected = Boolean(debridService(settings.value.debridService)) const route = routeDebrid({ torrentID, hash, @@ -183,14 +176,14 @@ export async function resolveDebridFiles (torrentID, search) { const service = getService() const episode = Number(search?.episode) const resolved = await service.resolve(torrentID, { - fileFilter: name => videoRx.test(name) || subRx.test(name), + fileFilter: name => playbackRx.test(name), pickFile: Number.isFinite(episode) ? files => pickEpisodeFile(files, episode) : undefined }) - const files = secureFiles(resolved.files, serviceTitle()) - if (files.length !== resolved.files.length) debug(`Discarded ${resolved.files.length - files.length} non-HTTPS links from ${serviceTitle()}`) + const secure = secureFiles(resolved.files, serviceTitle()) + if (secure.length !== resolved.files.length) debug(`Discarded ${resolved.files.length - secure.length} non-HTTPS links from ${serviceTitle()}`) // playing it proves the service holds it, which is the best answer there is recordAvailability(resolved.hash, Availability.CACHED) - return Promise.all(files.map(async file => ({ + return Promise.all(secure.map(async file => ({ infoHash: resolved.hash, fileHash: await sha1hex(`${resolved.hash}:${file.name}:${file.size}`), // same key the torrent client uses, so watch progress is shared torrent_name: resolved.name, @@ -220,8 +213,8 @@ export function refreshDebridAvailability () { /** * Whether answers from this instance still describe the configured account. A request in flight - * outlives a settings change, and badging a new account with the old one's answers is worse - * than no badges at all. + * outlives a settings change, and badging a new account with the old one's answers is worse than + * no badges at all. * @param {import('@/modules/debrid/service.js').default} instance */ function current (instance) { @@ -234,13 +227,13 @@ let retryDelay = RETRY_DELAY /** * Asks the service about the releases on screen, so badges say what it can actually do with them - * rather than only what the account has touched. Answers are remembered, so browsing the same - * show again is free. A service may answer only part of the list, so whatever is left is asked - * about again on a backing off timer until it is done or the user moves on. + * rather than only what the account has touched. Answers are remembered, so browsing the same show + * again is free. A service may answer only part of the list, so whatever is left is asked about + * again on a backing off timer until it is done or the user moves on. * @param {string[]} hashes - Candidates, most relevant first, since probing bites from the front. */ export async function checkDebridAvailability (hashes) { - cancelDebridAvailability() // this list supersedes whatever the last one was still waiting to retry + cancelDebridAvailability() // this list supersedes whatever the last one was waiting to retry const active = getService() if (!active || !settings.value.debridCacheCheck || status.value === 'offline') return const pending = active.unknownHashes(hashes) @@ -278,8 +271,8 @@ export function cancelDebridAvailability () { } /** - * Picks the requested episode out of a pack with the same anitomy parsing the rest of the app - * uses, largest file as fallback. + * Picks the requested episode out of a pack, using the same anitomy parsing as the rest of the + * app. Falls back to the largest video. * @param {{ id: number, path: string, size: number }[]} files * @param {number} episode */ @@ -297,7 +290,7 @@ async function pickEpisodeFile (files, episode) { } function serviceTitle () { - return debridServices[settings.value.debridService]?.title || 'debrid' + return debridService(settings.value.debridService)?.title || 'debrid' } /** diff --git a/common/modules/debrid/metadata.js b/common/modules/debrid/metadata.js index 49ab670e..ea338855 100644 --- a/common/modules/debrid/metadata.js +++ b/common/modules/debrid/metadata.js @@ -1,6 +1,6 @@ import Metadata from 'matroska-metadata' import { arr2hex, hex2bin } from 'uint8-util' -import { fontRx, matroskaRx, matchSubtitleFiles, sleep } from '@/modules/util.js' +import { fontRx, matroskaRx, matchFontFiles, matchSubtitleFiles, sleep } from '@/modules/util.js' import { SUPPORTS } from '@/modules/support.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -10,10 +10,11 @@ const AHEAD_SECONDS = 120 // land this many seconds of video before a seek, so a rough byte estimate still covers it const JUMP_BACK_SECONDS = 15 const RETRIES = 3 +const MAX_ANDROID_FONT = 15_000_000 // matches the torrent client's guard /** - * Blob-like wrapper around a remote URL so matroska-metadata can read it - * through HTTP range requests, mirroring how it reads torrent files. + * Blob-like wrapper around a remote URL so matroska-metadata can read it through HTTP range + * requests, mirroring how it reads torrent files. */ class RemoteFile { /** @@ -61,10 +62,10 @@ class RemoteFile { } /** - * Extracts embedded tracks, fonts, chapters and subtitles from a debrid HTTP - * stream and feeds them into the same Subtitles pipeline torrents use. Unlike - * torrents the playback bytes can't be tapped, so subtitle events come from a - * second range request that is paced to stay just ahead of the play position. + * Extracts embedded tracks, fonts, chapters and subtitles from a debrid HTTP stream and feeds + * them into the same Subtitles pipeline torrents use. Unlike torrents the playback bytes can't be + * tapped, so subtitle events come from a second range request paced to stay just ahead of the + * play position. */ export default class DebridMetadata { destroyed = false @@ -84,13 +85,23 @@ export default class DebridMetadata { this.file = file this.getTime = getTime - // external subtitle files that were resolved alongside the video, matched to it - // exactly like the torrent client does so season packs load one episode's subs - for (const sub of matchSubtitleFiles(files, file.name)) { + // external subtitles and the fonts they style with, matched exactly like the torrent client + // does so a season pack loads one episode's subs + const subFiles = matchSubtitleFiles(files, file.name) + debug(`Found ${subFiles.length} subtitle files`) + for (const sub of subFiles) { fetch(sub.url).then(res => res.arrayBuffer()).then(data => { if (!this.destroyed) subtitles.handleSubtitleFile({ name: sub.name, data }) }).catch(error => debug(`Failed to fetch subtitle file ${sub.name}:`, error)) } + const fontFiles = matchFontFiles(files) + debug(`Found ${fontFiles.length} font files`) + for (const font of fontFiles) { + fetch(font.url).then(res => res.arrayBuffer()).then(data => { + if (this.destroyed || (SUPPORTS.isAndroid && data.byteLength > MAX_ANDROID_FONT)) return + subtitles.handleFile(hex2bin(arr2hex(new Uint8Array(data)))) + }).catch(error => debug(`Failed to fetch font file ${font.name}:`, error)) + } // everything below reads the Matroska container, which only these formats have if (!matroskaRx.test(file.name)) { @@ -99,8 +110,8 @@ export default class DebridMetadata { } this.remote = new RemoteFile(file.url, file.size, file.name) this.metadata = new Metadata(this.remote) - // the parser starts several reads in its constructor, settle the ones nothing may - // ever await (duration when no tracks stream) so they cannot reject unhandled + // the parser starts several reads in its constructor, settle the ones nothing may ever await + // (duration when no tracks stream) so they cannot reject unhandled for (const pending of [this.metadata.segment, this.metadata.seekHead, this.metadata.duration]) Promise.resolve(pending).catch(() => {}) this.metadata.getTracks().then(tracks => { @@ -123,7 +134,7 @@ export default class DebridMetadata { debug(`Found ${attachments?.length} attachments`) for (const attachment of attachments) { if (fontRx.test(attachment.filename) || attachment.mimetype?.toLowerCase().includes('font')) { - if (SUPPORTS.isAndroid && attachment.data.length > 15_000_000) continue // matches the torrent client's large font guard + if (SUPPORTS.isAndroid && attachment.data.length > MAX_ANDROID_FONT) continue subtitles.handleFile(hex2bin(arr2hex(attachment.data))) } } @@ -167,10 +178,10 @@ export default class DebridMetadata { } /** - * Waits until the parser should read further and reports where from: the current - * offset while playback approaches it, or a fresh one when a seek left the parsed - * window, where reading on sequentially would download everything in between for - * nothing. The player renderer deduplicates events, so overlapping parses are safe. + * Waits until the parser should read further, and says where from: the current offset while + * playback approaches it, or a fresh one when a seek left the parsed window, where reading on + * sequentially would download everything in between for nothing. The renderer deduplicates + * events, so overlapping parses are safe. */ async #pace (byteRate, start, offset) { if (!byteRate) return offset // no duration to estimate from, so read straight through diff --git a/common/modules/debrid/premiumize.js b/common/modules/debrid/premiumize.js index fa248877..b2c63554 100644 --- a/common/modules/debrid/premiumize.js +++ b/common/modules/debrid/premiumize.js @@ -28,11 +28,11 @@ const deadCodes = ['service_unsupported', 'permanent_error'] * Premiumize implementation, see https://www.premiumize.me/api * * The easiest service to support, having kept the endpoints the others dropped: `/cache/check` - * answers a whole results list for free, and `/transfer/directdl` returns every stream link for - * a magnet in one call without storing anything, so there is no add or cleanup path at all. + * answers a whole results list for free, and `/transfer/directdl` returns every stream link for a + * magnet in one call without storing anything, so there is no add or cleanup path at all. * - * `/transfer/list` never says which info hash a transfer came from, so badges come from the - * cache endpoint alone. + * `/transfer/list` never says which info hash a transfer came from, so badges come from the cache + * endpoint alone. */ export default class Premiumize extends DebridService { static id = 'premiumize' diff --git a/common/modules/debrid/realdebrid.js b/common/modules/debrid/realdebrid.js index b7799d2d..9bd21489 100644 --- a/common/modules/debrid/realdebrid.js +++ b/common/modules/debrid/realdebrid.js @@ -1,5 +1,5 @@ // relative import keeps this module loadable under plain Node for API tests -import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, DebridUnavailableError, archiveRx } from './service.js' +import DebridService, { DebridError, DebridAuthError, DebridNotCachedError, DebridTimeoutError, DebridUnavailableError, archiveRx } from './service.js' import { Availability } from './availability.js' import Debug from 'debug' const debug = Debug('ui:debrid') @@ -63,10 +63,9 @@ export default class RealDebrid extends DebridService { /** * @type {number} Status reads a probe gives a magnet still converting before giving up. * - * Real-Debrid holds the metadata for anything cached, so a cached release reaches file - * selection within a read or two; one still converting is telling us it is not. Counted in - * reads rather than seconds so a slow link does not change how many chances it gets — waiting - * out a full timeout is what costs the sweep the rest of its list. Giving up leaves the + * Real-Debrid holds the metadata for anything cached, so a cached release reaches file selection + * within a read or two; one still converting is telling us it is not. Counted in reads rather + * than seconds so a slow link does not change how many chances it gets. Giving up leaves the * release unknown, so the next sweep asks again. */ static probeConversionReads = 2 @@ -79,8 +78,8 @@ export default class RealDebrid extends DebridService { mapError (status, json) { const code = json?.error_code const message = errorMessages[code] || json?.error || `Request failed with status ${status}` - // a blocked or unavailable file also answers 403, and must stay a plain error: an auth - // error aborts the whole resolve, where one bad file in a pack should only be skipped + // a blocked or unavailable file also answers 403, and must stay a plain error: an auth error + // aborts the whole resolve, where one bad file in a pack should only be skipped if (authCodes.includes(code) || ((status === 401 || status === 403) && code == null)) return new DebridAuthError(message, { status, code }) return new DebridError(message, { status, code }) } @@ -108,8 +107,8 @@ export default class RealDebrid extends DebridService { /** * The only way Real-Debrid can still be asked about a release: add the magnet and read the - * status it settles on. A cached torrent reports 'downloaded' within a second of file - * selection. Costs about five requests, hence the cap in the base class. + * status it settles on. A cached torrent reports 'downloaded' within a second of file selection. + * Costs about five requests, hence the cap in the base class. * * The torrent is always removed again, and adding a hash the account already holds creates a * separate entry, so this can never delete the user's own download. @@ -121,7 +120,7 @@ export default class RealDebrid extends DebridService { if (!magnetURI) throw new DebridError('Not a usable info hash') // no answer, rather than a made up one let torrentId = null try { - torrentId = await this.#addAndSelect(magnetURI, () => true, undefined, RealDebrid.probeConversionReads) + torrentId = await this.#addAndSelect(magnetURI, () => true, { reads: RealDebrid.probeConversionReads }) await this.#awaitStatus(torrentId, 'downloaded', this.budget('probe')) return Availability.CACHED } finally { @@ -137,8 +136,8 @@ export default class RealDebrid extends DebridService { let torrentId = null let added = false try { - // a cache probe of this same release is about to delete its own torrent, so let it - // finish first rather than reusing an id that is seconds from disappearing + // a cache probe of this same release is about to delete its own torrent, so let it finish + // first rather than reusing an id that is seconds from disappearing await this.probes.get(hash)?.catch(() => {}) // reuse a torrent that is already on the account instead of adding a duplicate const existing = await this.#existingTorrent(hash) @@ -166,7 +165,7 @@ export default class RealDebrid extends DebridService { let files = await this.#unrestrictLinks(info, fileFilter, maxFiles, target) if (target && !files.some(file => file.name === target.path.split('/').pop())) { debug(`Re-adding torrent to select only ${target.path}`) - const retryId = await this.#addAndSelect(magnetURI, null, target.id) + const retryId = await this.#addAndSelect(magnetURI, null, { fileId: target.id }) // not awaited: the player is already open waiting on this, cleanup can catch up if (added) this.release(`${API}/torrents/delete/${torrentId}`) torrentId = retryId @@ -181,7 +180,9 @@ export default class RealDebrid extends DebridService { } catch (error) { // only clean up torrents this call added, never the user's own downloads if (added && torrentId) await this.release(`${API}/torrents/delete/${torrentId}`) - throw error + // playback has waited as long as it can, so a magnet still converting is one it cannot use. + // A probe leaves the same timeout unanswered instead, since Real-Debrid may just be slow + throw error instanceof DebridTimeoutError ? new DebridNotCachedError() : error } } @@ -209,11 +210,11 @@ export default class RealDebrid extends DebridService { * Adds a magnet and selects either the files matching the filter or one specific file. * @param {string} magnetURI * @param {((name: string) => boolean) | null} fileFilter - * @param {number} [fileId] - * @param {number} [reads] - How many status reads the magnet gets to convert, capped for probes. + * @param {{ fileId?: number, reads?: number }} [opts] - `fileId` selects one file outright, + * `reads` caps how many status reads the magnet gets to convert, for probes. * @returns {Promise} The new torrent id. */ - async #addAndSelect (magnetURI, fileFilter, fileId, reads = Infinity) { + async #addAndSelect (magnetURI, fileFilter, { fileId, reads } = {}) { const torrentId = (await this.request(`${API}/torrents/addMagnet`, { method: 'POST', body: { magnet: magnetURI } }))?.id this.forgetListing() // the account has a torrent the remembered listing does not try { @@ -270,9 +271,9 @@ export default class RealDebrid extends DebridService { if (info.status === wanted || (wanted === 'waiting_files_selection' && info.status === 'downloaded')) return info const settled = unstreamable(info.status) if (settled) throw settled - // deliberately no answer at all: a rare release can sit in magnet_conversion a while, and - // calling that a miss is what empties the badges on exactly those titles - if (read >= reads || Date.now() - started > timeout) throw new DebridError(`Timed out waiting for Real-Debrid (${info.status})`) + // a rare release can sit in magnet_conversion a while, so running out of time proves nothing + // about it. Callers decide: playback treats it as uncached, a probe leaves it re-checkable + if (read >= reads || Date.now() - started > timeout) throw new DebridTimeoutError(`Timed out waiting for Real-Debrid (${info.status})`) await new Promise(resolve => setTimeout(resolve, this.config.timeouts.poll).unref?.()) } } diff --git a/common/modules/debrid/route.js b/common/modules/debrid/route.js index d37a7358..d3323e9c 100644 --- a/common/modules/debrid/route.js +++ b/common/modules/debrid/route.js @@ -49,7 +49,7 @@ export function debridKey (settings, service = settings?.debridService) { * filters this is upstream's rule, widened only because a cached release streams without seeders. * The cached filter narrows it to confirmed hits, and debrid only mode hides releases the service * cannot serve. An *available* release is deliberately not widened in: the service would still - * have to pull it from the swarm. + * have to pull it from the swarm first. * @param {{ seeders?: number, source?: { managed?: boolean } }} result * @param {string} [availability] - What the service said about this release. * @param {{ cachedOnly?: boolean, only?: boolean }} [options] - The debrid filters in force. diff --git a/common/modules/debrid/service.js b/common/modules/debrid/service.js index 7da3bfed..24db4d15 100644 --- a/common/modules/debrid/service.js +++ b/common/modules/debrid/service.js @@ -1,10 +1,9 @@ +// No UI imports here, so this module also runs under plain Node for testing. import Bottleneck from 'bottleneck' import { Availability, AVAILABILITY_TTL, normalizeAvailability } from './availability.js' import Debug from 'debug' const debug = Debug('ui:debrid') -// No UI imports here, so this module also runs under plain Node for testing. - export class DebridError extends Error { /** * @param {string} message @@ -34,6 +33,17 @@ export class DebridNetworkError extends DebridError { } } +/** + * The service kept us waiting past the budget. It says nothing about the release, so whoever + * asked decides what to make of it: playback cannot wait, a badge check can come back later. + */ +export class DebridTimeoutError extends DebridError { + constructor (message, opts) { + super(message, opts) + this.name = 'DebridTimeoutError' + } +} + /** * Playback cannot use this release now, carrying the availability it proves. Callers read * `availability` off the error rather than matching on error types. @@ -72,8 +82,8 @@ export class DebridNotImplementedError extends DebridError { } /** - * What an error proves about a release, or null when it proves nothing. A timeout or a rate - * limit describes the moment, not the release, so it leaves it unknown and re-checkable. + * What an error proves about a release, or null when it proves nothing. A timeout or a rate limit + * describes the moment, not the release, so it leaves it unknown and re-checkable. * @param {any} error * @returns {string | null} */ @@ -125,11 +135,10 @@ const MAX_CLEANUP_ATTEMPTS = 3 /** * Base class for debrid services: rate limited requests, typed errors, availability bookkeeping. - * Implementations only talk HTTP, state is per-instance so services stay swappable. + * Implementations only talk HTTP; state is per-instance so services stay swappable. * * Adding a service means subclassing this, setting the statics below, and implementing the - * abstract methods. Nothing outside the new file changes apart from one registry entry in - * `debrid.js`. + * abstract methods. Nothing outside the new file changes apart from one entry in `services.js`. * @abstract */ export default class DebridService { @@ -177,9 +186,9 @@ export default class DebridService { static maxBatch = 100 /** - * Whether asking about a release puts a magnet on the account rather than reading a cache - * index. Two things follow: only one such check may be in flight, and a hash the answer leaves - * out is unasked rather than "not cached". + * Whether asking about a release puts a magnet on the account rather than reading a cache index. + * Two things follow: only one such check may be in flight, and a hash the answer leaves out is + * unasked rather than "not cached". * @returns {boolean} */ static get checkAddsMagnets () { @@ -256,8 +265,8 @@ export default class DebridService { /** * Retries removals that failed earlier. Only ever replays a removal `release()` was already - * asked to make, so it can no more reach a torrent the user wanted than the original call - * could. Never persisted: a stale id would eventually name something else. + * asked to make, so it can no more reach a torrent the user wanted than the original call could. + * Never persisted: a stale id would eventually name something else. */ async retryCleanup () { const pending = [...this.#orphans.values()] @@ -274,8 +283,8 @@ export default class DebridService { /** * The account's own torrent listing, read at most once per `listingTTL` and shared by every * caller. Both the badge refresh and every resolve want it, and reading it per play put a full - * listing on the play path. An entry can be a minute stale, so callers confirm it before - * acting on its id. + * listing on the play path. An entry can be a minute stale, so callers confirm it before acting + * on its id. * @param {{ fresh?: boolean }} [opts] - `fresh` forces a read, for polling a change just made. * @returns {Promise} */ @@ -369,7 +378,7 @@ export default class DebridService { if (!this.apiKey) throw new DebridAuthError('No debrid API key configured') const authorized = this.authorize(url, { auth, authParam }) const encoded = body ? DebridService.encodeBody(body, encoding) : null - debug(`${method} ${url}`) // logged before authorization so query-parameter keys never reach the log + debug(`${method} ${url}`) // the caller's url, never the authorized one, so a key in a query parameter stays out of the log const sent = Date.now() const res = await fetch(authorized.url, { method, @@ -378,8 +387,8 @@ export default class DebridService { signal: AbortSignal.timeout(timeout) }) this.observeLatency(Date.now() - sent) // only round trips that came back, so a timeout cannot inflate it - // the app short-circuits external requests while it considers itself offline, - // handing back a plain object instead of a Response + // the app short-circuits external requests while it considers itself offline, handing back a + // plain object instead of a Response if (typeof res?.json !== 'function') throw new DebridNetworkError(res?.message?.replace(/^failed to fetch: /i, '') || 'Network request failed') if (!res?.ok) { let json = null @@ -402,8 +411,8 @@ export default class DebridService { /** * A poll budget stretched to fit the connection in use, up to `MAX_STRETCH`. The defaults are - * written for a healthy link; on a slow one the same budget buys a single request, so every - * poll loop times out and reports no answer. + * written for a healthy link; on a slow one the same budget buys a single request, so every poll + * loop times out and reports no answer. * @param {string} kind - A key of the service's `timeouts`. * @returns {number} */ @@ -563,8 +572,8 @@ export default class DebridService { onAnswer?.(hash, state) } - // one at a time where asking adds magnets: services rate limit adding far harder than - // reading, so overlapping checks do not answer faster, they get refused + // one at a time where asking adds magnets: services rate limit adding far harder than reading, + // so overlapping checks do not answer faster, they get refused if (this.config.checkAddsMagnets) { if (this.sweeping) return answers this.sweeping = true diff --git a/common/modules/debrid/services.js b/common/modules/debrid/services.js new file mode 100644 index 00000000..3a9fed77 --- /dev/null +++ b/common/modules/debrid/services.js @@ -0,0 +1,20 @@ +// The service registry. Adding a debrid service means writing its file and listing it here; +// nothing else in the app names a service. No UI imports, so tests can read it under plain Node. +import AllDebrid from './alldebrid.js' +import Premiumize from './premiumize.js' +import RealDebrid from './realdebrid.js' +import TorBox from './torbox.js' + +/** In the order the settings menu offers them. Unfinished services stay hidden. */ +export const debridServices = Object.fromEntries([AllDebrid, Premiumize, RealDebrid, TorBox] + .filter(Service => Service.available) + .map(Service => [Service.id, Service])) + +/** + * The service class for an id, or null. + * @param {string} [id] + * @returns {typeof import('./service.js').default | null} + */ +export function debridService (id) { + return debridServices[id] || null +} diff --git a/common/modules/debrid/torbox.js b/common/modules/debrid/torbox.js index cbbf7f72..c7de0062 100644 --- a/common/modules/debrid/torbox.js +++ b/common/modules/debrid/torbox.js @@ -29,10 +29,9 @@ const deadStates = /(stalled|error|failed|missing)/i /** * TorBox implementation, see https://api-docs.torbox.app/ * - * Three differences from Real-Debrid shape this client: `/torrents/checkcached` answers many - * hashes in one request, every response is wrapped in `{ success, data }` with failures arriving - * inside a 200, and `/torrents/requestdl` authenticates with a `token` query parameter while - * everything else uses a bearer header. + * Three things shape this client: `/torrents/checkcached` answers many hashes in one request, + * every response is wrapped in `{ success, data }` with failures arriving inside a 200, and + * `/torrents/requestdl` authenticates with a `token` query parameter rather than a bearer header. */ export default class TorBox extends DebridService { static id = 'torbox' @@ -104,7 +103,7 @@ export default class TorBox extends DebridService { const query = hashes.map(hash => `hash=${hash}`).join('&') const data = await this.request(`${API}/torrents/checkcached?${query}&format=list`) // the endpoint has answered in both shapes over its life: a list of entries, or an object - // keyed by hash. Both carry the same thing, which is simply "TorBox holds this one". + // keyed by hash. Either way it only ever says "TorBox holds this one" const cached = Array.isArray(data) ? data.map(entry => entry?.hash) : Object.keys(data || {}) const answers = new Map(hashes.map(hash => [hash, Availability.AVAILABLE])) for (const hash of cached) { @@ -199,12 +198,11 @@ export default class TorBox extends DebridService { * than added twice. Read back by id because the listing can be a minute stale, so one deleted * elsewhere must read as absent rather than fail the resolve. * @param {string} hash - * @param {{ listed?: boolean }} [opts] - `listed` false skips the listing, for a hash known to be absent from it. * @returns {Promise} */ - async #existingTorrent (hash, { listed = true } = {}) { + async #existingTorrent (hash) { if (!hash) return null - const known = listed ? (await this.listing()).find(torrent => String(torrent?.hash || '').toLowerCase() === hash) : null + const known = (await this.listing()).find(torrent => String(torrent?.hash || '').toLowerCase() === hash) if (!known) return null // a failed read reads as "gone": the caller then checks the cache and adds the magnet, which // fails loudly enough if the API is really unreachable diff --git a/common/modules/torrent.js b/common/modules/torrent.js index b8e59649..187b4368 100644 --- a/common/modules/torrent.js +++ b/common/modules/torrent.js @@ -80,10 +80,9 @@ TORRENT.portRequest(_settings).then(() => { TORRENT.onFiles(_files => { debug(`Got files request:`, _files?.length) - // the client announces the files of every torrent it loads, including the one restored - // at startup, whose metadata can arrive long after debrid playback began. Letting that - // through would swap out what is playing for a torrent the user never picked. Playing - // a torrent hands the player back first, so this never blocks a real request. + // the client announces the files of every torrent it loads, including the one restored at + // startup, which would swap out what debrid is playing. Playing a torrent hands the player + // back first, so this never blocks a real request if (debridPlayback.value) return debug('Ignoring torrent files, debrid owns playback') files.set(_files) }) diff --git a/common/modules/util.js b/common/modules/util.js index 377647b1..fc49c098 100644 --- a/common/modules/util.js +++ b/common/modules/util.js @@ -835,10 +835,9 @@ export const fontRx = new RegExp(`.(${fontExtensions.join('|')})$`, 'i') export const matroskaRx = /\.(mkv|webm)$/i /** - * Picks the external subtitle files belonging to one video out of a release's file list. - * Season packs ship a subtitle per episode, so subtitles are matched against the playing - * file's name unless the release holds a single video, in which case they all belong to it. - * Shared by the torrent client and debrid playback so both lanes stay in step. + * The subtitle files belonging to one video. Season packs ship a subtitle per episode, so they + * are matched against the playing file's name unless the release holds a single video, in which + * case they all belong to it. Shared by the torrent client and debrid playback. * @param {{ name: string }[]} files - Every file in the release. * @param {string} videoName - Name of the video being played, with extension. * @param {number} [videoCount] - Videos in the release, counted from `files` when omitted. @@ -850,3 +849,19 @@ export function matchSubtitleFiles (files, videoName, videoCount) { const stem = videoName.substring(0, videoName.lastIndexOf('.')) || videoName return files.filter(file => subRx.test(file.name) && (videos <= 1 || file.name.includes(stem))) } + +/** + * The font files a release ships alongside its subtitles, deduplicated by name. Some releases + * carry the same font once per language, and there is no way to tell whether they differ in + * coverage, so on really bad releases a few glyphs may still fail. + * Shared by the torrent client and debrid playback. + * @param {{ name: string }[]} files - Every file in the release. + * @returns {any[]} + */ +export function matchFontFiles (files) { + const fonts = new Map() + for (const file of files || []) { + if (fontRx.test(file.name)) fonts.set(file.name, file) + } + return [...fonts.values()] +} diff --git a/common/routes/settings/tabs/DebridTab.svelte b/common/routes/settings/tabs/DebridTab.svelte index b7c8c670..b72773df 100644 --- a/common/routes/settings/tabs/DebridTab.svelte +++ b/common/routes/settings/tabs/DebridTab.svelte @@ -3,7 +3,7 @@ import { toast } from 'svelte-sonner' import { Eye, EyeOff } from 'lucide-svelte' import SettingCard from '@/routes/settings/components/SettingCard.svelte' - import { debridOptions, testDebrid } from '@/modules/debrid/debrid.js' + import { debridOptions, debridTransport, testDebrid } from '@/modules/debrid/debrid.js' import { debridKey } from '@/modules/debrid/route.js' export let settings @@ -22,6 +22,12 @@ showKey = false } + // worth spelling out the cost only for services that have to add a magnet to answer + $: cacheCheckDescription = 'Asks the service which releases it already holds, so the torrent list can badge them and offer a cached only filter. ' + + ($debridTransport?.checksAddMagnets + ? `${$debridTransport.title} has no cache lookup, so each check briefly adds and removes a magnet on your account. Turn this off to leave badges to what the account already holds.` + : 'Costs one request per search and nothing on your account.') + /** @param {string} key */ function setApiKey (key) { settings.debridApiKeys = { ...settings.debridApiKeys, [settings.debridService]: key } @@ -73,7 +79,10 @@ - + +
+ + +
+ {/if}