@serifpersia/dango 3.6.7 → 3.6.9

package/server/dist/hono/tv.js

@@ -1,200 +0,0 @@
-import logger from '../logger.js';
-import { fetchWithRetry, linkAbort, setProxyHeaders } from '../utils/http.utils.js';
-import { URL } from 'url';
-import { isSafeExternalUrl } from '../utils/security.utils.js';
-function proxiedMediaUrl(targetUrl, refererStr, providerStr) {
-    const provider = providerStr ? `&provider=${encodeURIComponent(providerStr)}` : '';
-    return `/api/tv/stream-proxy?url=${encodeURIComponent(targetUrl)}&referer=${encodeURIComponent(refererStr)}${provider}`;
-}
-function rewriteTvPlaylist(body, baseUrl, refererStr, providerStr) {
-    return body
-        .split('\n')
-        .map((line) => {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return line;
-        if (trimmed.startsWith('#')) {
-            return trimmed.replace(/URI="([^"]+)"/g, (_, uri) => {
-                const absolute = new URL(uri, baseUrl).href;
-                return `URI="${proxiedMediaUrl(absolute, refererStr, providerStr)}"`;
-            });
-        }
-        const absolute = new URL(trimmed, baseUrl).href;
-        return proxiedMediaUrl(absolute, refererStr, providerStr);
-    })
-        .join('\n');
-}
-function pinTvVariant(body, idx) {
-    const lines = body.split('\n');
-    let streamIdx = -1;
-    let skipUri = false;
-    const out = [];
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('#EXT-X-STREAM-INF')) {
-            streamIdx++;
-            skipUri = streamIdx !== idx;
-            if (!skipUri)
-                out.push(line);
-            continue;
-        }
-        if (skipUri && trimmed && !trimmed.startsWith('#')) {
-            skipUri = false;
-            continue;
-        }
-        out.push(line);
-    }
-    return streamIdx >= 0 && idx <= streamIdx ? out.join('\n') : body;
-}
-function isPlaylistBody(body) {
-    return (body.length >= 7 &&
-        body
-            .subarray(0, 32)
-            .toString('utf8')
-            .replace(/^\uFEFF/, '')
-            .trimStart()
-            .startsWith('#EXTM3U'));
-}
-export function registerTv(app, getTvProvider) {
-    app.get('/api/tv/embed/:provider/:type/:tmdbId', async (c) => {
-        const provider = c.req.param('provider');
-        const type = c.req.param('type');
-        const tmdbId = c.req.param('tmdbId');
-        const mediaType = type === 'movie' ? 'movie' : 'tv';
-        const numericTmdbId = parseInt(tmdbId, 10);
-        if (!numericTmdbId)
-            return c.json({ url: null, error: 'Bad tmdb id' });
-        const mod = getTvProvider(String(provider).toLowerCase());
-        if (!mod || typeof mod.getEmbedUrl !== 'function') {
-            return c.json({ url: null, error: `Unknown TV provider ${provider}` });
-        }
-        const media = {
-            tmdbId: numericTmdbId,
-            type: mediaType,
-            season: parseInt(String(c.req.query('season') || '1'), 10) || 1,
-            episode: parseInt(String(c.req.query('episode') || '1'), 10) || 1,
-            title: '',
-            year: '',
-            imdbId: '',
-            totalSeasons: 1,
-        };
-        try {
-            const url = await mod.getEmbedUrl(media);
-            if (!url)
-                return c.json({ url: null, error: 'No embed url' });
-            return c.json({ url });
-        }
-        catch (e) {
-            return c.json({ url: null, error: e.message });
-        }
-    });
-    app.get('/api/tv/stream-proxy', async (c) => {
-        const requestedUrl = c.req.query('url') ?? '';
-        const variantMatch = requestedUrl.match(/#v=(\d+)$/);
-        const variantIdx = variantMatch ? parseInt(variantMatch[1], 10) : NaN;
-        const urlStr = requestedUrl.replace(/#.*$/, '');
-        const refererStr = c.req.query('referer') || '';
-        const providerStr = (c.req.query('provider') || '').toLowerCase();
-        if (!urlStr)
-            return c.text('URL required', 400);
-        const providerMod = providerStr ? getTvProvider(providerStr) : undefined;
-        const rewrite = (body, baseUrl) => {
-            const providerBody = providerMod?.rewritePlaylist?.(body, baseUrl.href) ?? body;
-            const pinned = Number.isInteger(variantIdx)
-                ? pinTvVariant(providerBody, variantIdx)
-                : providerBody;
-            return rewriteTvPlaylist(pinned, baseUrl, refererStr, providerStr);
-        };
-        const safeCheck = isSafeExternalUrl(urlStr);
-        if (!safeCheck.safe) {
-            return c.text(safeCheck.error || 'Invalid URL', 400);
-        }
-        const abort = new AbortController();
-        const timeout = setTimeout(() => abort.abort(), 30000);
-        linkAbort(c.req.raw.signal, abort);
-        try {
-            const headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            };
-            if (refererStr)
-                headers['Referer'] = refererStr;
-            const fetchResp = await fetchWithRetry(urlStr, {
-                headers,
-                redirect: 'follow',
-            }, { retries: 3, baseDelayMs: 750, signal: abort.signal });
-            const status = fetchResp.status;
-            if (status !== 200 && status !== 206) {
-                return c.text('Upstream error', (status || 502));
-            }
-            const contentType = fetchResp.headers.get('content-type') || 'application/octet-stream';
-            const outHeaders = new Headers();
-            outHeaders.set('Content-Type', contentType);
-            setProxyHeaders(outHeaders, (name) => fetchResp.headers.get(name));
-            outHeaders.set('Connection', 'keep-alive');
-            if (urlStr.includes('.m3u8') || /mpegurl|m3u8/i.test(contentType)) {
-                const body = await fetchResp.text();
-                const baseUrl = new URL(fetchResp.url || urlStr);
-                const rewritten = rewrite(body, baseUrl);
-                const bodyBuffer = Buffer.from(rewritten, 'utf8');
-                outHeaders.set('Content-Type', 'application/vnd.apple.mpegurl');
-                outHeaders.set('Content-Length', String(bodyBuffer.length));
-                return new Response(bodyBuffer, { status, headers: outHeaders });
-            }
-            const reader = fetchResp.body?.getReader();
-            if (!reader) {
-                logger.warn({ host: safeCheck.url?.hostname }, 'tv stream-proxy: upstream sent no body');
-                return c.text('Upstream sent no body', 502);
-            }
-            try {
-                const first = await reader.read();
-                const head = first.done ? Buffer.alloc(0) : Buffer.from(first.value);
-                if (isPlaylistBody(head)) {
-                    const chunks = [head];
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        chunks.push(Buffer.from(value));
-                    }
-                    const body = Buffer.concat(chunks);
-                    const baseUrl = new URL(fetchResp.url || urlStr);
-                    const rewritten = rewrite(body.toString('utf8'), baseUrl);
-                    const bodyBuffer = Buffer.from(rewritten, 'utf8');
-                    outHeaders.set('Content-Type', 'application/vnd.apple.mpegurl');
-                    outHeaders.set('Content-Length', String(bodyBuffer.length));
-                    return new Response(bodyBuffer, { status, headers: outHeaders });
-                }
-                const stream = new ReadableStream({
-                    start(controller) {
-                        if (head.length)
-                            controller.enqueue(head);
-                    },
-                    async pull(controller) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            controller.close();
-                        else
-                            controller.enqueue(value);
-                    },
-                    cancel(reason) {
-                        return reader.cancel(reason);
-                    },
-                });
-                return new Response(stream, { status, headers: outHeaders });
-            }
-            catch (err) {
-                logger.warn({ err, host: safeCheck.url?.hostname }, 'tv stream-proxy: upstream body stream failed');
-                return c.text('Upstream stream failed', 502);
-            }
-        }
-        catch (err) {
-            if (abort.signal.aborted)
-                return new Response(null, { status: 499 });
-            logger.warn({ err, host: safeCheck.url?.hostname }, 'tv stream-proxy: upstream fetch failed');
-            return c.text('Upstream fetch failed', 502);
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    });
-}

package/server/dist/hono/watchlist.js

@@ -1,341 +0,0 @@
-import logger from '../logger.js';
-import { WatchlistRepository } from '../repositories/watchlist.repository.js';
-import { WatchedEpisodesRepository } from '../repositories/watched-episodes.repository.js';
-import { ShowsMetaRepository } from '../repositories/shows-meta.repository.js';
-import { NotificationsRepository } from '../repositories/notifications.repository.js';
-import { dbAll } from '../utils/db-utils.js';
-import { AppCache } from '../utils/cache.utils.js';
-import { getAiredEpisodesForShows, isAnilistRateLimited, batchGetShowStatuses, } from '../lib/anilist.js';
-import { parseJsonBody } from '../utils/http.utils.js';
-import { pickBestMatch } from '../providers/title-matching.js';
-const BACKGROUND_DISCOVERY_INTERVAL_MS = 5 * 60 * 1000;
-const NUDGE_THROTTLE_MS = 120 * 1000;
-const SLOW_MAX_RUN_MS = 5 * 60 * 1000;
-let discoveryIntervalId = null;
-let lastExternalDiscoveryAt = 0;
-let discoveryBusy = false;
-let lastDiscoveryRunAt = 0;
-let discoveryState = 'idle';
-let discoveryTotal = 0;
-let discoveryDone = 0;
-let discoveryStopped = false;
-let triggerImpl = null;
-export function triggerWatchlistDiscovery() {
-    return triggerImpl?.() ?? false;
-}
-export function stopWatchlistDiscovery() {
-    discoveryStopped = true;
-    if (discoveryIntervalId !== null) {
-        clearInterval(discoveryIntervalId);
-        discoveryIntervalId = null;
-    }
-}
-export function getWatchlistDiscoveryStatus() {
-    return {
-        running: discoveryBusy,
-        state: discoveryState,
-        total: discoveryTotal,
-        done: Math.min(discoveryDone, discoveryTotal),
-        lastRunAt: lastDiscoveryRunAt,
-    };
-}
-export function startWatchlistDiscovery(getDb) {
-    const anilistIdCache = new Map();
-    const getAnilistId = async (showId) => {
-        if (anilistIdCache.has(showId)) {
-            return anilistIdCache.get(showId) || null;
-        }
-        const db = getDb();
-        const meta = (await ShowsMetaRepository.getById(db, showId));
-        if (meta?.anilistId) {
-            anilistIdCache.set(showId, meta.anilistId);
-            return meta.anilistId;
-        }
-        if (/^\d+$/.test(showId)) {
-            const numericId = parseInt(showId);
-            anilistIdCache.set(showId, numericId);
-            return numericId;
-        }
-        anilistIdCache.set(showId, null);
-        return null;
-    };
-    const runDiscovery = async (fast = false) => {
-        if (discoveryBusy || discoveryStopped)
-            return;
-        discoveryBusy = true;
-        discoveryState = 'running';
-        discoveryTotal = 0;
-        discoveryDone = 0;
-        const db = getDb();
-        if (!db || db.isClosedCheck()) {
-            discoveryBusy = false;
-            return;
-        }
-        const startedAt = Date.now();
-        const MAX_RUN_MS = fast ? 90000 : SLOW_MAX_RUN_MS;
-        try {
-            const watchingShows = await WatchlistRepository.getWatchingShows(db);
-            discoveryTotal = watchingShows.length;
-            if (watchingShows.length === 0) {
-                discoveryBusy = false;
-                return;
-            }
-            const showIdMap = new Map();
-            const MAP_CONCURRENCY = fast ? 4 : 2;
-            const anilistResults = [];
-            let nextIndex = 0;
-            const worker = async () => {
-                while (nextIndex < watchingShows.length) {
-                    if (Date.now() - startedAt > MAX_RUN_MS)
-                        return;
-                    const show = watchingShows[nextIndex];
-                    nextIndex += 1;
-                    const id = await getAnilistId(show.id);
-                    discoveryDone += 1;
-                    anilistResults.push({ show, id });
-                }
-            };
-            await Promise.all(Array.from({ length: Math.min(MAP_CONCURRENCY, watchingShows.length) }, () => worker()));
-            for (const { show, id } of anilistResults) {
-                if (id) {
-                    showIdMap.set(show.id, id);
-                }
-            }
-            if (Date.now() - startedAt > MAX_RUN_MS || showIdMap.size === 0) {
-                discoveryBusy = false;
-                return;
-            }
-            const now = new Date();
-            const weekStart = new Date(now);
-            weekStart.setDate(now.getDate() - 7);
-            weekStart.setHours(0, 0, 0, 0);
-            const weekEnd = new Date(now);
-            weekEnd.setHours(23, 59, 59, 999);
-            const schedules = await getAiredEpisodesForShows(Array.from(showIdMap.values()), weekStart, weekEnd);
-            const nowUnix = Math.floor(Date.now() / 1000);
-            const reverseMap = new Map();
-            for (const [watchlistId, anilistId] of showIdMap.entries()) {
-                reverseMap.set(anilistId, watchlistId);
-            }
-            const finishedShowIds = new Set();
-            const unresolvedStatus = [];
-            for (const [watchlistId, anilistId] of showIdMap.entries()) {
-                const localMeta = (await ShowsMetaRepository.getById(db, watchlistId));
-                if (localMeta?.status === 'FINISHED') {
-                    finishedShowIds.add(anilistId);
-                }
-                else if (!localMeta?.status) {
-                    unresolvedStatus.push({ watchlistId, anilistId });
-                }
-            }
-            if (unresolvedStatus.length > 0 && !isAnilistRateLimited()) {
-                const statuses = await batchGetShowStatuses(unresolvedStatus.map((s) => s.anilistId));
-                let persisted = 0;
-                for (const { watchlistId, anilistId } of unresolvedStatus) {
-                    const status = statuses.get(anilistId);
-                    if (status === 'FINISHED') {
-                        finishedShowIds.add(anilistId);
-                        await ShowsMetaRepository.upsert(db, { id: watchlistId, status: 'FINISHED' });
-                        persisted++;
-                    }
-                    else if (status) {
-                        await ShowsMetaRepository.upsert(db, { id: watchlistId, status });
-                        persisted++;
-                    }
-                }
-            }
-            if (finishedShowIds.size > 0) {
-                const monthStart = new Date(now);
-                monthStart.setDate(now.getDate() - 30);
-                monthStart.setHours(0, 0, 0, 0);
-                const monthEnd = new Date(now);
-                monthEnd.setHours(23, 59, 59, 999);
-                const finishedSchedules = await getAiredEpisodesForShows(Array.from(finishedShowIds), monthStart, monthEnd);
-                const finishedEpisodesByShow = new Map();
-                const seenFinishedKeys = new Set();
-                for (const entry of finishedSchedules) {
-                    if (entry.airingAt > nowUnix)
-                        continue;
-                    const watchlistId = reverseMap.get(entry.mediaId);
-                    if (!watchlistId)
-                        continue;
-                    const episodeKey = String(Math.round(entry.episode));
-                    const dedupeKey = `${watchlistId}:${episodeKey}`;
-                    if (seenFinishedKeys.has(dedupeKey))
-                        continue;
-                    seenFinishedKeys.add(dedupeKey);
-                    const list = finishedEpisodesByShow.get(watchlistId);
-                    if (list)
-                        list.push({ episodeKey, airingAt: entry.airingAt });
-                    else
-                        finishedEpisodesByShow.set(watchlistId, [{ episodeKey, airingAt: entry.airingAt }]);
-                }
-                for (const [watchlistId, episodes] of finishedEpisodesByShow) {
-                    const [watchedEps, dismissedEps] = await Promise.all([
-                        WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, watchlistId),
-                        NotificationsRepository.getDismissedByShow(db, watchlistId),
-                    ]);
-                    const watchedSet = new Set(watchedEps.map((e) => e.toString()));
-                    const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
-                    for (const { episodeKey, airingAt } of episodes) {
-                        if (nowUnix - airingAt > 30 * 24 * 60 * 60)
-                            continue;
-                        if (!watchedSet.has(episodeKey) && !dismissedSet.has(episodeKey)) {
-                            await NotificationsRepository.addDiscovered(db, watchlistId, episodeKey);
-                        }
-                    }
-                }
-            }
-            const episodesByShow = new Map();
-            const seenEpisodeKeys = new Set();
-            for (const entry of schedules) {
-                if (entry.airingAt > nowUnix)
-                    continue;
-                const watchlistId = reverseMap.get(entry.mediaId);
-                if (!watchlistId)
-                    continue;
-                const episodeKey = String(Math.round(entry.episode));
-                const dedupeKey = `${watchlistId}:${episodeKey}`;
-                if (seenEpisodeKeys.has(dedupeKey))
-                    continue;
-                seenEpisodeKeys.add(dedupeKey);
-                const list = episodesByShow.get(watchlistId);
-                if (list)
-                    list.push({ episodeKey, airingAt: entry.airingAt });
-                else
-                    episodesByShow.set(watchlistId, [{ episodeKey, airingAt: entry.airingAt }]);
-            }
-            for (const [watchlistId, episodes] of episodesByShow) {
-                const [watchedEps, dismissedEps] = await Promise.all([
-                    WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, watchlistId),
-                    NotificationsRepository.getDismissedByShow(db, watchlistId),
-                ]);
-                const watchedSet = new Set(watchedEps.map((e) => e.toString()));
-                const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
-                for (const { episodeKey } of episodes) {
-                    if (!watchedSet.has(episodeKey) && !dismissedSet.has(episodeKey)) {
-                        await NotificationsRepository.addDiscovered(db, watchlistId, episodeKey);
-                    }
-                }
-            }
-            await NotificationsRepository.cleanupWatchedNotifications(db);
-        }
-        catch (e) {
-            discoveryState = 'error';
-            if (e?.message === 'Database is closed') {
-                logger.info('Notification discovery stopped: database is closed');
-            }
-            else {
-                logger.error({ err: e }, 'AniList notification discovery failed');
-            }
-        }
-        finally {
-            discoveryBusy = false;
-            lastDiscoveryRunAt = Date.now();
-            if (discoveryState === 'running') {
-                discoveryState = discoveryTotal === 0 ? 'empty' : 'complete';
-            }
-        }
-    };
-    triggerImpl = () => {
-        if (discoveryStopped || discoveryBusy)
-            return false;
-        if (Date.now() - lastExternalDiscoveryAt < NUDGE_THROTTLE_MS)
-            return false;
-        lastExternalDiscoveryAt = Date.now();
-        runDiscovery(true);
-        return true;
-    };
-    discoveryIntervalId = setInterval(() => {
-        if (!discoveryStopped)
-            runDiscovery(false);
-    }, BACKGROUND_DISCOVERY_INTERVAL_MS);
-}
-export async function getAdultNonWatchlistShowIds(db) {
-    const rows = await dbAll(db, `SELECT DISTINCT we.showId as showId
-     FROM watched_episodes we
-     JOIN shows_meta sm ON sm.id = we.showId AND sm.isAdult = 1
-     LEFT JOIN watchlist w ON w.id = we.showId
-     WHERE w.id IS NULL`);
-    return rows.map((r) => r.showId);
-}
-const dlsitePosterCache = new AppCache({ ttlSeconds: 3600, maxKeys: 2000 });
-const mangadexCoverCache = new AppCache({ ttlSeconds: 3600, maxKeys: 2000 });
-export async function getMangadexCover(title) {
-    const key = title.trim().toLowerCase();
-    if (!key)
-        return null;
-    const cached = mangadexCoverCache.get(key);
-    if (cached !== undefined)
-        return cached;
-    try {
-        const params = new URLSearchParams({
-            title: title.trim(),
-            limit: '5',
-            'includes[]': 'cover_art',
-            'order[relevance]': 'desc',
-        });
-        for (const r of ['safe', 'suggestive', 'erotica', 'pornographic']) {
-            params.append('contentRating[]', r);
-        }
-        const res = await fetch(`https://api.mangadex.org/manga?${params.toString()}`, {
-            headers: { 'User-Agent': 'Dango/3.0', Accept: 'application/json' },
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!res.ok)
-            return null;
-        const data = (await parseJsonBody(res));
-        const candidates = [];
-        for (const m of data.data || []) {
-            const fileName = m.relationships?.find((r) => r.type === 'cover_art')?.attributes?.fileName;
-            if (!fileName)
-                continue;
-            const cover = `https://uploads.mangadex.org/covers/${m.id}/${fileName}.256.jpg`;
-            const main = m.attributes?.title;
-            const mainTitle = main?.en || main?.['ja-ro'] || Object.values(main || {})[0];
-            if (mainTitle)
-                candidates.push({ title: mainTitle, cover });
-            for (const alt of m.attributes?.altTitles || []) {
-                const t = Object.values(alt)[0];
-                if (t)
-                    candidates.push({ title: t, cover });
-            }
-        }
-        const match = pickBestMatch(candidates, [title]);
-        const url = match ? match.item.cover : null;
-        mangadexCoverCache.set(key, url);
-        return url;
-    }
-    catch {
-        return null;
-    }
-}
-export async function getDlsitePoster(rjCode) {
-    const key = String(rjCode).trim().toUpperCase();
-    if (!/^RJ\d{5,}$/.test(key))
-        return null;
-    const cached = dlsitePosterCache.get(key);
-    if (cached !== undefined)
-        return cached;
-    try {
-        const res = await fetch(`https://www.dlsite.com/maniax/product/info/ajax?product_id=${key}`, {
-            headers: { 'User-Agent': 'Mozilla/5.0', Accept: 'application/json' },
-            signal: AbortSignal.timeout(5000),
-        });
-        if (!res.ok)
-            return null;
-        const raw = (await parseJsonBody(res));
-        const data = raw;
-        const entryRaw = (data[key] ?? data);
-        const entry = entryRaw;
-        const img = typeof entry?.work_image === 'string' ? entry.work_image : undefined;
-        if (!img)
-            return null;
-        const url = img.startsWith('//') ? `https:${img}` : img;
-        dlsitePosterCache.set(key, url);
-        return url;
-    }
-    catch {
-        return null;
-    }
-}