@serifpersia/dango 3.0.3

package/server/dist/routes/tv.routes.js

@@ -0,0 +1,843 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTvRouter = createTvRouter;
+const express_1 = require("express");
+const tmdb_1 = require("../lib/tmdb");
+const url_1 = require("url");
+const security_utils_1 = require("../utils/security.utils");
+const MOVY_API = 'https://api.wecollege.net';
+const MOVY_SERVERS = [
+    'miami',
+    'phoenix',
+    'dallas',
+    'seattle',
+    'denver',
+    'cancun',
+    'atlanta',
+    'houston',
+    'portland',
+    'austin',
+    'munich',
+    'berlin',
+    'paris',
+    'delhi',
+];
+const MOVY_K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+];
+const MOVY_MAGIC = [109, 118, 109, 49];
+const movyIsEven = (e) => ((e * (e + 1)) & 1) === 0;
+function movyMix(e) {
+    e >>>= 0;
+    e ^= e >>> 16;
+    e = Math.imul(e, 0x85ebca6b) >>> 0;
+    e ^= e >>> 13;
+    e = Math.imul(e, 0xc2b2ae35) >>> 0;
+    e ^= e >>> 16;
+    return e >>> 0;
+}
+function movyShift(e, t) {
+    return ((e >>>= 0), 0 === (t &= 31) ? e >>> 0 : ((e << t) | (e >>> (32 - t))) >>> 0);
+}
+function decodeMovyPayload(e, t, a) {
+    const r = (function (e) {
+        const t = e
+            .replace(/-/g, '+')
+            .replace(/_/g, '/')
+            .padEnd(4 * Math.ceil(e.length / 4), '=');
+        return new Uint8Array(Buffer.from(t, 'base64'));
+    })(e);
+    const n = (function (e, t, a) {
+        const s = (function (e, t) {
+            const s = Array(61);
+            let r = movyMix((function (e) {
+                let t = 0x811c9dc5;
+                for (let a = 0; a < e.length; a++)
+                    t = Math.imul(t ^ e.charCodeAt(a), 0x1000193) >>> 0;
+                return movyMix(t);
+            })(e) ^ movyMix((t >>> 0) ^ 0x9e3779b9)) >>> 0;
+            for (let e = 0; e < 8; e++) {
+                if (movyIsEven(e)) {
+                    const t = r % 61;
+                    r = movyShift((r + 0x9e3779b9) >>> 0, 7 + (7 & e));
+                    s[t] = (r ^ movyMix(r)) >>> 0;
+                    r = movyMix((r + t) >>> 0);
+                }
+                else {
+                    s[e] = MOVY_K[15 & e];
+                }
+            }
+            return { S: s, acc: movyMix(0xa5a5a5a5 ^ r) >>> 0 };
+        })(e, t);
+        const r = new Uint8Array(a);
+        let n = 0;
+        for (let e = 0; e < a;) {
+            const t = (function (e, t) {
+                const r = e.S;
+                let n = e.acc;
+                const i = n % 61;
+                const o = 0 - Number(i in r);
+                const l = r[i] >>> 0;
+                const c = Math.imul(0x9e3779b9, t + 1) >>> 0;
+                const h = ((((n ^ ((l ^ c) >>> 0)) >>> 0) | (n & ((l ^ c) >>> 0) & o)) >>> 0) >>> 0;
+                n = movyMix(((movyShift((h + n) >>> 0, 31 & i) ^ movyShift(n, 31 & Math.imul(i, 7))) + 0x9e3779b9) >>>
+                    0);
+                r[i] = n >>> 0;
+                e.acc = n;
+                return n >>> 0;
+            })(s, n++);
+            r[e++] = 255 & t;
+            if (e < a)
+                r[e++] = (t >>> 8) & 255;
+            if (e < a)
+                r[e++] = (t >>> 16) & 255;
+            if (e < a)
+                r[e++] = (t >>> 24) & 255;
+        }
+        return r;
+    })(String(t), a, r.length);
+    for (let e = 0; e < r.length; e++)
+        r[e] ^= n[e];
+    for (let e = 0; e < MOVY_MAGIC.length; e++) {
+        if (r[e] !== MOVY_MAGIC[e])
+            throw new Error('decrypt failed: bad seed or payload');
+    }
+    return Buffer.from(r.subarray(MOVY_MAGIC.length)).toString('utf8');
+}
+const movySeedCache = new Map();
+const inflightSeedRequests = new Map();
+async function movyGetSeed(mediaId, forceRefresh = false) {
+    const key = String(mediaId);
+    const now = Date.now();
+    if (!forceRefresh) {
+        const cached = movySeedCache.get(key);
+        if (cached && cached.expiresAt - 4000 > now)
+            return cached.seed;
+    }
+    if (inflightSeedRequests.has(key))
+        return await inflightSeedRequests.get(key);
+    const promise = (async () => {
+        try {
+            const r = await fetch(`${MOVY_API}/seed?mediaId=${mediaId}`, {
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                    Accept: 'application/json, text/plain, */*',
+                    Referer: 'https://www.movy.bz/',
+                    Origin: 'https://www.movy.bz',
+                },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (r.ok) {
+                const data = await r.json();
+                const ttl = data.ttlMs || 30000;
+                movySeedCache.set(key, { seed: data.seed, expiresAt: Date.now() + ttl });
+                return data.seed;
+            }
+            if (r.status === 429) {
+                const cached = movySeedCache.get(key);
+                if (cached)
+                    return cached.seed;
+            }
+        }
+        catch {
+            const cached = movySeedCache.get(key);
+            if (cached)
+                return cached.seed;
+        }
+        finally {
+            inflightSeedRequests.delete(key);
+        }
+        return movySeedCache.get(key)?.seed || null;
+    })();
+    inflightSeedRequests.set(key, promise);
+    return await promise;
+}
+async function tryMovyCity(city, baseParams, seed, numericTmdbId, headers) {
+    try {
+        const params = new URLSearchParams({ ...baseParams, seed });
+        const r = await fetch(`${MOVY_API}/${city}/sources?${params.toString()}`, {
+            headers,
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!r.ok)
+            return null;
+        const encrypted = await r.text();
+        let decrypted;
+        try {
+            decrypted = decodeMovyPayload(encrypted, seed, numericTmdbId);
+        }
+        catch {
+            const retrySeed = await movyGetSeed(numericTmdbId, true);
+            if (!retrySeed)
+                return null;
+            const retryParams = new URLSearchParams({ ...baseParams, seed: retrySeed });
+            const retryResp = await fetch(`${MOVY_API}/${city}/sources?${retryParams.toString()}`, {
+                headers,
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!retryResp.ok)
+                return null;
+            decrypted = decodeMovyPayload(await retryResp.text(), retrySeed, numericTmdbId);
+        }
+        const data = JSON.parse(decrypted);
+        if (!Array.isArray(data.sources) || data.sources.length === 0)
+            return null;
+        const validSources = data.sources.filter((s) => !(s.url || '').includes('.mpd'));
+        if (validSources.length === 0)
+            return null;
+        const sources = [];
+        const collectedAudioTracks = [];
+        for (const s of validSources) {
+            const isHls = s.url.includes('.m3u8');
+            const isMp4 = s.url.includes('.mp4');
+            if (isHls) {
+                try {
+                    const plRes = await fetch(s.url, {
+                        headers: {
+                            'User-Agent': headers['User-Agent'],
+                            Referer: 'https://www.movy.bz/',
+                            Origin: 'https://www.movy.bz',
+                        },
+                        signal: AbortSignal.timeout(6000),
+                    });
+                    if (!plRes.ok)
+                        continue;
+                    const playlist = await plRes.text();
+                    if (!playlist.includes('#EXTM3U'))
+                        continue;
+                    for (const line of playlist.split('\n')) {
+                        if (line.startsWith('#EXT-X-MEDIA:TYPE=AUDIO')) {
+                            const language = line.match(/LANGUAGE="([^"]+)"/)?.[1] ?? 'unknown';
+                            const label = line.match(/NAME="([^"]+)"/)?.[1] ?? 'Audio';
+                            if (!collectedAudioTracks.find((t) => t.language === language && t.label === label)) {
+                                collectedAudioTracks.push({ language, label });
+                            }
+                        }
+                    }
+                    const variantRegex = /#EXT-X-STREAM-INF:[^\n]*BANDWIDTH=(\d+)[^\n]*RESOLUTION=(\d+x\d+)[^\n]*(?:FRAME-RATE=([\d.]+))?[^\n]*\n([^\n]+)/g;
+                    let match;
+                    const variants = [];
+                    while ((match = variantRegex.exec(playlist)) !== null) {
+                        const resParts = match[2].split('x');
+                        variants.push({
+                            bandwidth: parseInt(match[1], 10),
+                            width: parseInt(resParts[0], 10),
+                            height: parseInt(resParts[1], 10),
+                            frameRate: match[3] ? parseFloat(match[3]) : null,
+                            uri: match[4],
+                        });
+                    }
+                    if (variants.length > 0) {
+                        let hasValidVariant = false;
+                        for (const v of variants) {
+                            const fullUrl = v.uri.startsWith('http') ? v.uri : new url_1.URL(v.uri, s.url).href;
+                            try {
+                                const headRes = await fetch(fullUrl, {
+                                    method: 'HEAD',
+                                    headers: {
+                                        'User-Agent': headers['User-Agent'],
+                                        Referer: 'https://www.movy.bz/',
+                                        Origin: 'https://www.movy.bz',
+                                    },
+                                    signal: AbortSignal.timeout(5000),
+                                });
+                                if (headRes.ok) {
+                                    hasValidVariant = true;
+                                    break;
+                                }
+                            }
+                            catch {
+                                // ignore
+                            }
+                        }
+                        if (hasValidVariant || variants.length > 0) {
+                            sources.push({ url: s.url, quality: s.quality || 'Auto', type: 'hls' });
+                        }
+                        else {
+                            continue;
+                        }
+                    }
+                    else if (playlist.includes('#EXTINF')) {
+                        sources.push({ url: s.url, quality: s.quality || 'Auto', type: 'hls' });
+                    }
+                    else {
+                        continue;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            else {
+                try {
+                    const headRes = await fetch(s.url, {
+                        method: 'HEAD',
+                        headers: {
+                            'User-Agent': headers['User-Agent'],
+                            Referer: 'https://www.movy.bz/',
+                            Origin: 'https://www.movy.bz',
+                        },
+                        signal: AbortSignal.timeout(5000),
+                    });
+                    if (!headRes.ok)
+                        continue;
+                    sources.push({ url: s.url, quality: s.quality || 'Auto', type: isMp4 ? 'mp4' : 'hls' });
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+        if (sources.length === 0)
+            return null;
+        return { sources, audioTracks: collectedAudioTracks };
+    }
+    catch {
+        return null;
+    }
+}
+function createTvRouter(apiCache) {
+    const router = (0, express_1.Router)();
+    router.get('/tv/search', async (req, res) => {
+        const query = req.query.q || '';
+        if (!query)
+            return res.json([]);
+        const page = parseInt(req.query.page) || 1;
+        const cacheKey = `tv-search-${query.toLowerCase()}-${page}`;
+        const cached = apiCache.get(cacheKey);
+        if (cached)
+            return res.json(cached);
+        const key = await (0, tmdb_1.getTmdbKey)();
+        if (!key)
+            return res.status(500).json({ error: 'No TMDB API key available' });
+        try {
+            const r = await fetch(`${tmdb_1.TMDB_BASE}/search/multi?api_key=${key}&query=${encodeURIComponent(query)}&page=${page}&include_adult=true`, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            if (!r.ok)
+                return res.status(500).json({ error: 'TMDB search failed' });
+            const d = await r.json();
+            const results = (d.results || [])
+                .filter((item) => item.media_type !== 'person')
+                .map((item) => ({
+                id: item.id,
+                title: item.title || item.name,
+                year: (item.release_date || item.first_air_date || '').split('-')[0],
+                type: item.media_type,
+                image: item.poster_path ? `${tmdb_1.TMDB_IMAGE}/w500${item.poster_path}` : '',
+                vote_average: item.vote_average,
+                adult: item.adult === true,
+            }));
+            apiCache.set(cacheKey, results, 3600);
+            res.json(results);
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    router.get('/tv/details/:type/:id', async (req, res) => {
+        const { type, id } = req.params;
+        const key = await (0, tmdb_1.getTmdbKey)();
+        if (!key)
+            return res.status(500).json({ error: 'No TMDB API key available' });
+        try {
+            const r = await fetch(`${tmdb_1.TMDB_BASE}/${type}/${id}?api_key=${key}&append_to_response=external_ids`, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            if (!r.ok)
+                return res.status(500).json({ error: 'TMDB details failed' });
+            const d = await r.json();
+            const result = {
+                id: d.id,
+                imdb_id: d.external_ids?.imdb_id || d.imdb_id || null,
+                title: d.title || d.name,
+                overview: d.overview,
+                vote_average: d.vote_average,
+                year: (d.release_date || d.first_air_date || '').split('-')[0],
+                poster: d.poster_path ? `${tmdb_1.TMDB_IMAGE}/w500${d.poster_path}` : '',
+                backdrop: d.backdrop_path ? `${tmdb_1.TMDB_IMAGE}/original${d.backdrop_path}` : '',
+                adult: d.adult === true,
+            };
+            if (type === 'tv') {
+                result.seasons = (d.seasons || [])
+                    .filter((s) => s.season_number > 0)
+                    .map((s) => ({
+                    season_number: s.season_number,
+                    episode_count: s.episode_count,
+                }));
+                result.number_of_seasons = d.number_of_seasons;
+            }
+            res.json(result);
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    router.get('/tv/episodes/:id/:season', async (req, res) => {
+        const { id, season } = req.params;
+        const key = await (0, tmdb_1.getTmdbKey)();
+        if (!key)
+            return res.status(500).json({ error: 'No TMDB API key available' });
+        try {
+            const r = await fetch(`${tmdb_1.TMDB_BASE}/tv/${id}/season/${season}?api_key=${key}`, {
+                headers: { 'User-Agent': 'Mozilla/5.0' },
+            });
+            if (!r.ok)
+                return res.status(500).json({ error: 'TMDB episodes failed' });
+            const d = await r.json();
+            const episodes = (d.episodes || []).map((ep) => ({
+                episode_number: ep.episode_number,
+                name: ep.name,
+                vote_average: ep.vote_average,
+                overview: ep.overview,
+                still_path: ep.still_path,
+            }));
+            res.json({ episodes });
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    router.get('/tv/lookup/imdb-to-tmdb/:imdbId', async (req, res) => {
+        const key = await (0, tmdb_1.getTmdbKey)();
+        if (!key)
+            return res.json({ tmdbId: null, error: 'No TMDB API key available' });
+        try {
+            const r = await fetch(`${tmdb_1.TMDB_BASE}/find/${req.params.imdbId}?api_key=${key}&external_source=imdb_id`, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            if (!r.ok)
+                return res.json({ tmdbId: null, error: `TMDB error ${r.status}` });
+            const d = await r.json();
+            const movie = d.movie_results?.[0];
+            const tv = d.tv_results?.[0];
+            const result = movie || tv;
+            res.json({
+                tmdbId: result?.id || null,
+                type: movie ? 'movie' : tv ? 'tv' : null,
+                title: result?.title || result?.name || null,
+                year: (result?.release_date || result?.first_air_date || '').substring(0, 4) || null,
+            });
+        }
+        catch (e) {
+            res.json({ tmdbId: null, error: e.message });
+        }
+    });
+    router.get('/tv/search/imdb', async (req, res) => {
+        const query = req.query.q || '';
+        if (!query)
+            return res.json([]);
+        const cacheKey = `tv-imdb-search-${query.toLowerCase()}`;
+        const cached = apiCache.get(cacheKey);
+        if (cached)
+            return res.json(cached);
+        try {
+            const response = await fetch(`https://v3.sg.media-imdb.com/suggestion/x/${encodeURIComponent(query)}.json`, { headers: { 'User-Agent': 'Mozilla/5.0' } });
+            if (!response.ok)
+                return res.status(500).json({ error: 'IMDB search failed' });
+            const data = await response.json();
+            const TV_TYPES = new Set(['tvSeries', 'tvMiniSeries', 'movie']);
+            const matches = (data.d || [])
+                .filter((entry) => Boolean(entry.id && entry.l) && TV_TYPES.has(entry.qid || ''))
+                .slice(0, 10)
+                .map((entry) => ({
+                id: entry.id,
+                title: entry.l,
+                year: entry.y,
+                type: entry.qid,
+                image: entry.i?.imageUrl || '',
+            }));
+            apiCache.set(cacheKey, matches, 3600);
+            res.json(matches);
+        }
+        catch (e) {
+            res.status(500).json({ error: e.message });
+        }
+    });
+    router.get('/tv/subtitles/:type/:tmdbId', async (req, res) => {
+        const { type, tmdbId } = req.params;
+        const numericTmdbId = parseInt(tmdbId, 10);
+        if (!numericTmdbId)
+            return res.json({ subtitles: [] });
+        const mediaType = type === 'movie' ? 'movie' : 'tv';
+        const season = String(req.query.season || '1');
+        const episode = String(req.query.episode || '1');
+        const cacheKey = mediaType === 'tv'
+            ? `tv-subs-${numericTmdbId}-${season}-${episode}`
+            : `tv-subs-${numericTmdbId}-movie`;
+        const cached = apiCache.get(cacheKey);
+        if (cached)
+            return res.json(cached);
+        try {
+            const searchUrl = mediaType === 'tv'
+                ? `https://subtitles.vidy.st/search?id=${numericTmdbId}&season=${encodeURIComponent(season)}&episode=${encodeURIComponent(episode)}`
+                : `https://subtitles.vidy.st/search?id=${numericTmdbId}`;
+            const r = await fetch(searchUrl, {
+                headers: { 'User-Agent': 'Mozilla/5.0' },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!r.ok)
+                return res.json({ subtitles: [] });
+            const items = (await r.json());
+            const subtitles = (Array.isArray(items) ? items : [])
+                .filter((s) => typeof s.url === 'string' && s.url.startsWith('https://'))
+                .map((s) => ({
+                language: String(s.language || 'en'),
+                label: String(s.display || s.language || 'Unknown'),
+                url: String(s.url),
+                trusted: s.isTrusted === true,
+                hi: s.isHearingImpaired === true,
+                downloads: Number(s.downloadCount) || 0,
+                media: String(s.media || s.release || ''),
+            }))
+                .sort((a, b) => {
+                const aEn = a.language.toLowerCase().startsWith('en') ? 0 : 1;
+                const bEn = b.language.toLowerCase().startsWith('en') ? 0 : 1;
+                if (aEn !== bEn)
+                    return aEn - bEn;
+                if (a.trusted !== b.trusted)
+                    return a.trusted ? -1 : 1;
+                return b.downloads - a.downloads;
+            })
+                .slice(0, 50);
+            const payload = { subtitles };
+            apiCache.set(cacheKey, payload, 3600);
+            res.json(payload);
+        }
+        catch {
+            res.json({ subtitles: [] });
+        }
+    });
+    router.get('/tv/movybz/:type/:tmdbId', async (req, res) => {
+        const { type, tmdbId } = req.params;
+        const mediaType = type === 'movie' ? 'movie' : 'tv';
+        const season = String(req.query.season || '1');
+        const episode = String(req.query.episode || '1');
+        const numericTmdbId = parseInt(tmdbId, 10);
+        let title = String(req.query.title || '');
+        let year = String(req.query.year || '');
+        let imdbId = String(req.query.imdbId || '');
+        let totalSeasons = String(req.query.totalSeasons || '1');
+        if (!title || !imdbId || !year) {
+            try {
+                const tmdbKey = await (0, tmdb_1.getTmdbKey)();
+                if (tmdbKey) {
+                    const tmdbRes = await fetch(`${tmdb_1.TMDB_BASE}/${mediaType}/${numericTmdbId}?api_key=${tmdbKey}&append_to_response=external_ids`, { headers: { 'User-Agent': 'Mozilla/5.0' }, signal: AbortSignal.timeout(4000) });
+                    if (tmdbRes.ok) {
+                        const d = await tmdbRes.json();
+                        if (!title)
+                            title = d.title || d.name || '';
+                        if (!year)
+                            year = (d.release_date || d.first_air_date || '').split('-')[0] || '';
+                        if (!imdbId)
+                            imdbId = d.external_ids?.imdb_id || d.imdb_id || '';
+                        if (mediaType === 'tv' && d.number_of_seasons)
+                            totalSeasons = String(d.number_of_seasons);
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        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',
+            Accept: 'application/json, text/plain, */*',
+            Referer: 'https://www.movy.bz/',
+            Origin: 'https://www.movy.bz',
+        };
+        const seed = await movyGetSeed(numericTmdbId);
+        if (!seed) {
+            return res.status(500).json({ error: 'Seed unavailable', tmdbId: numericTmdbId });
+        }
+        const validSeed = seed;
+        const baseParams = {
+            title,
+            mediaType,
+            year,
+            tmdbId: String(numericTmdbId),
+            imdbId,
+            enc: '2',
+            seed: validSeed,
+        };
+        if (mediaType === 'tv') {
+            baseParams.totalSeasons = totalSeasons;
+            baseParams.seasonId = season;
+            baseParams.episodeId = episode;
+        }
+        for (const city of MOVY_SERVERS) {
+            const result = await tryMovyCity(city, baseParams, validSeed, numericTmdbId, headers);
+            if (result) {
+                return res.json({ server: city, sources: result.sources, audioTracks: result.audioTracks });
+            }
+        }
+        res.json({ sources: [], audioTracks: [], error: 'No sources found from Movy servers' });
+    });
+    router.get('/tv/movybz/:type/:tmdbId/probe/:city', async (req, res) => {
+        const { type, tmdbId, city } = req.params;
+        if (!MOVY_SERVERS.includes(city)) {
+            return res.status(400).json({ error: 'Invalid city', valid: false });
+        }
+        const mediaType = type === 'movie' ? 'movie' : 'tv';
+        const season = String(req.query.season || '1');
+        const episode = String(req.query.episode || '1');
+        const numericTmdbId = parseInt(tmdbId, 10);
+        let title = String(req.query.title || '');
+        let year = String(req.query.year || '');
+        let imdbId = String(req.query.imdbId || '');
+        let totalSeasons = String(req.query.totalSeasons || '1');
+        if (!title || !imdbId || !year) {
+            try {
+                const tmdbKey = await (0, tmdb_1.getTmdbKey)();
+                if (tmdbKey) {
+                    const tmdbRes = await fetch(`${tmdb_1.TMDB_BASE}/${mediaType}/${numericTmdbId}?api_key=${tmdbKey}&append_to_response=external_ids`, { headers: { 'User-Agent': 'Mozilla/5.0' }, signal: AbortSignal.timeout(4000) });
+                    if (tmdbRes.ok) {
+                        const d = await tmdbRes.json();
+                        if (!title)
+                            title = d.title || d.name || '';
+                        if (!year)
+                            year = (d.release_date || d.first_air_date || '').split('-')[0] || '';
+                        if (!imdbId)
+                            imdbId = d.external_ids?.imdb_id || d.imdb_id || '';
+                        if (mediaType === 'tv' && d.number_of_seasons)
+                            totalSeasons = String(d.number_of_seasons);
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        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',
+            Accept: 'application/json, text/plain, */*',
+            Referer: 'https://www.movy.bz/',
+            Origin: 'https://www.movy.bz',
+        };
+        const seed = await movyGetSeed(numericTmdbId);
+        if (!seed)
+            return res.json({
+                server: city,
+                sources: [],
+                audioTracks: [],
+                valid: false,
+                error: 'Seed unavailable',
+            });
+        const baseParams = {
+            title,
+            mediaType,
+            year,
+            tmdbId: String(numericTmdbId),
+            imdbId,
+            enc: '2',
+            seed,
+        };
+        if (mediaType === 'tv') {
+            baseParams.totalSeasons = totalSeasons;
+            baseParams.seasonId = season;
+            baseParams.episodeId = episode;
+        }
+        const result = await tryMovyCity(city, baseParams, seed, numericTmdbId, headers);
+        if (result)
+            return res.json({
+                server: city,
+                sources: result.sources,
+                audioTracks: result.audioTracks,
+                valid: true,
+            });
+        return res.json({
+            server: city,
+            sources: [],
+            audioTracks: [],
+            valid: false,
+            error: 'No valid sources for this city',
+        });
+    });
+    router.get('/tv/vixsrc/:type/:tmdbId', async (req, res) => {
+        const { type, tmdbId } = req.params;
+        const season = req.query.season;
+        const episode = req.query.episode;
+        const mediaType = type === 'movie' ? 'movie' : 'tv';
+        const BASE_URL = 'https://vixsrc.to';
+        const HEADERS = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/150 Safari/537.36',
+            Accept: 'application/json, text/javascript, */*; q=0.01',
+            Referer: BASE_URL,
+            Origin: BASE_URL,
+        };
+        try {
+            const pageUrl = mediaType === 'movie'
+                ? `${BASE_URL}/api/movie/${tmdbId}`
+                : `${BASE_URL}/api/tv/${tmdbId}/${season}/${episode}`;
+            const apiRes = await fetch(pageUrl, { headers: HEADERS });
+            if (!apiRes.ok) {
+                return res.status(500).json({ error: 'VixSrc API failed', status: apiRes.status });
+            }
+            const apiData = await apiRes.json();
+            if (!apiData?.src) {
+                return res.json({ sources: [] });
+            }
+            const htmlUrl = BASE_URL + apiData.src;
+            const htmlRes = await fetch(htmlUrl, {
+                headers: { ...HEADERS, Accept: 'text/html,application/xhtml+xml,*/*' },
+            });
+            if (!htmlRes.ok) {
+                return res.status(500).json({ error: 'VixSrc embed failed' });
+            }
+            const html = await htmlRes.text();
+            const token = html.match(/token["']\s*:\s*["']([^"']+)/)?.[1];
+            const expires = html.match(/expires["']\s*:\s*["']([^"']+)/)?.[1];
+            const playlist = html.match(/url\s*:\s*["']([^"']+)/)?.[1];
+            if (!token || !expires || !playlist) {
+                return res.json({ sources: [] });
+            }
+            const sep = playlist.includes('?') ? '&' : '?';
+            const masterUrl = `${playlist}${sep}token=${token}&expires=${expires}&h=1`;
+            const plRes = await fetch(masterUrl, { headers: { ...HEADERS, Referer: pageUrl } });
+            if (!plRes.ok) {
+                return res.status(500).json({ error: 'VixSrc playlist failed' });
+            }
+            const playlistContent = await plRes.text();
+            const regex = /#EXT-X-STREAM-INF:[^\n]*RESOLUTION=\d+x(\d+)[^\n]*\n([^\n]+)/g;
+            let match;
+            let bestResolution = 0;
+            while ((match = regex.exec(playlistContent)) !== null) {
+                const resVal = parseInt(match[1], 10);
+                if (resVal > bestResolution)
+                    bestResolution = resVal;
+            }
+            const sources = bestResolution > 0 ? [{ url: masterUrl, quality: `${bestResolution}p`, type: 'hls' }] : [];
+            const audioTracks = [];
+            const subtitles = [];
+            for (const line of playlistContent.split('\n')) {
+                if (line.startsWith('#EXT-X-MEDIA:TYPE=AUDIO')) {
+                    const language = line.match(/LANGUAGE="([^"]+)"/)?.[1] ?? 'unknown';
+                    const label = line.match(/NAME="([^"]+)"/)?.[1] ?? 'Audio';
+                    audioTracks.push({ language, label });
+                }
+                else if (line.startsWith('#EXT-X-MEDIA:TYPE=SUBTITLES')) {
+                    const language = line.match(/LANGUAGE="([^"]+)"/)?.[1] ?? 'unknown';
+                    const label = line.match(/NAME="([^"]+)"/)?.[1] ?? 'Subs';
+                    const uri = line.match(/URI="([^"]+)"/)?.[1];
+                    if (uri) {
+                        subtitles.push({ language, label, url: new url_1.URL(uri, masterUrl).href });
+                    }
+                }
+            }
+            res.json({ sources, audioTracks, subtitles, masterUrl, referer: pageUrl });
+        }
+        catch (e) {
+            res.status(500).json({ error: 'VixSrc fetch failed', message: e.message });
+        }
+    });
+    router.get('/tv/stream-proxy', async (req, res) => {
+        const { url, referer } = req.query;
+        const urlStr = url;
+        const refererStr = referer || '';
+        if (!urlStr)
+            return res.status(400).send('URL required');
+        const safeCheck = (0, security_utils_1.isSafeExternalUrl)(urlStr);
+        if (!safeCheck.safe) {
+            return res.status(400).send(safeCheck.error || 'Invalid URL');
+        }
+        const abortController = new AbortController();
+        const timeout = setTimeout(() => abortController.abort(), 30000);
+        res.on('close', () => {
+            clearTimeout(timeout);
+            abortController.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 fetch(urlStr, {
+                headers,
+                signal: abortController.signal,
+                redirect: 'follow',
+            });
+            const status = fetchResp.status;
+            if (status !== 200 && status !== 206) {
+                return res.status(status ?? 502).send('Upstream error');
+            }
+            const contentType = fetchResp.headers.get('content-type') || 'application/octet-stream';
+            const contentLength = fetchResp.headers.get('content-length');
+            const contentRange = fetchResp.headers.get('content-range');
+            const acceptRanges = fetchResp.headers.get('accept-ranges');
+            res.status(status);
+            res.set('Content-Type', contentType);
+            if (contentLength)
+                res.set('Content-Length', contentLength);
+            if (contentRange)
+                res.set('Content-Range', contentRange);
+            if (acceptRanges)
+                res.set('Accept-Ranges', acceptRanges);
+            res.set('Access-Control-Allow-Origin', '*');
+            res.set('Connection', 'keep-alive');
+            if (urlStr.includes('.m3u8')) {
+                const body = await fetchResp.text();
+                const baseUrl = new url_1.URL(fetchResp.url || urlStr);
+                const proxiedMediaUrl = (targetUrl) => `/api/tv/stream-proxy?url=${encodeURIComponent(targetUrl)}&referer=${encodeURIComponent(refererStr)}`;
+                const rewritten = 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_1.URL(uri, baseUrl).href;
+                            return `URI="${proxiedMediaUrl(absolute)}"`;
+                        });
+                    }
+                    const absolute = new url_1.URL(trimmed, baseUrl).href;
+                    return proxiedMediaUrl(absolute);
+                })
+                    .join('\n');
+                const bodyBuffer = Buffer.from(rewritten, 'utf8');
+                res.set('Content-Type', 'application/vnd.apple.mpegurl');
+                res.set('Content-Length', String(bodyBuffer.length));
+                if (!res.headersSent) {
+                    res.send(bodyBuffer);
+                }
+            }
+            else {
+                const chunks = [];
+                const reader = fetchResp.body?.getReader();
+                if (!reader) {
+                    return res.status(500).send('No response body');
+                }
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        chunks.push(Buffer.from(value));
+                    }
+                    const body = Buffer.concat(chunks);
+                    res.set('Content-Type', contentType);
+                    if (contentLength)
+                        res.set('Content-Length', contentLength);
+                    if (contentRange)
+                        res.set('Content-Range', contentRange);
+                    if (acceptRanges)
+                        res.set('Accept-Ranges', acceptRanges);
+                    res.set('Access-Control-Allow-Origin', '*');
+                    res.set('Connection', 'keep-alive');
+                    if (!res.headersSent) {
+                        res.send(body);
+                    }
+                }
+                catch (e) {
+                    if (!res.headersSent) {
+                        res.status(500).send('Proxy error');
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (abortController.signal.aborted)
+                return;
+            if (!res.headersSent) {
+                res.status(500).send('Proxy error');
+            }
+        }
+    });
+    return router;
+}