@vyla-entertainment/sdk 1.0.0

package/src/sources/vidsync.js

@@ -0,0 +1,38 @@
+import { fetchJson, fetchText, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
+
+const API_BASE = "https://enc-dec.app/api";
+const DOMAIN = "https://vidsync.xyz";
+const HEADERS = { "Accept": "*/*", "Origin": DOMAIN, "Referer": `${DOMAIN}/`, "User-Agent": USER_AGENT, "X-Requested-With": "XMLHttpRequest" };
+const SERVERS = ["cinevault", "cinedub", "cinebox", "cineflix", "cinevip", "cinecloud", "cine4k"];
+
+export async function getStream({ id, s, e, server }) {
+    try {
+        const isTv = s != null && e != null;
+        const type = isTv ? 'tv' : 'movie';
+        const info = await getTmdbInfo(id, type);
+        if (!info?.titles?.length) return null;
+        const turnstileJson = await fetchJson(`${API_BASE}/enc-vidsync`, { signal: AbortSignal.timeout(5000) });
+        if (turnstileJson.status !== 200 || !turnstileJson.result?.token) return null;
+        const turnstileToken = turnstileJson.result.token;
+        let targets = SERVERS;
+        if (server && server !== 'all') {
+            const clean = server.replace('VidSync - ', '');
+            targets = SERVERS.includes(clean) ? [clean] : SERVERS;
+        }
+        const encTitle = encodeURIComponent(info.titles[0]).replace(/%20/g, '+');
+        const results = await Promise.allSettled(targets.map(async srv => {
+            let url = `${DOMAIN}/api/stream/fetch?title=${encTitle}&type=${type}&releaseYear=${info.year}&mediaId=${id}&serverName=${srv}`;
+            if (isTv) url += `&season=${s}&episode=${e}`;
+            const encryptedText = await fetchText(url, { headers: { ...HEADERS, "X-Cf-Turnstile": turnstileToken }, signal: AbortSignal.timeout(10000) });
+            const decJson = await fetchJson(`${API_BASE}/dec-vidsync`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: encryptedText, id: String(id) }), signal: AbortSignal.timeout(10000) });
+            if (decJson.status !== 200 || !decJson.result) throw new Error();
+            const streams = Array.isArray(decJson.result) ? decJson.result : [decJson.result];
+            return streams.map(st => ({ url: st.url || st.file, server: `VidSync - ${srv}`, quality: st.quality || "Auto", type: (st.url || st.file || "").includes(".m3u8") ? "hls" : "mp4", headers: { ...HEADERS, "Origin": DOMAIN }, skipProxy: false, skipVerify: true, skipHlsCheck: true }));
+        }));
+        const allUrls = [];
+        for (const r of results) if (r.status === 'fulfilled') allUrls.push(...r.value);
+        return allUrls.length ? { allUrls } : null;
+    } catch { return null; }
+}
+
+export async function getSources() { return SERVERS.map(s => `VidSync - ${s}`); }

package/src/sources/vidup.js

@@ -0,0 +1,79 @@
+import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const API_BASE = 'https://enc-dec.app/api';
+const DOMAIN = 'https://vidup.to';
+const HEADERS = { 'User-Agent': USER_AGENT, 'Referer': `${DOMAIN}/`, 'X-Requested-With': 'XMLHttpRequest' };
+
+async function getVidupMeta(id, s, e) {
+    try {
+        const embedUrl = s != null && e != null ? `${DOMAIN}/tv/${id}/${s}/${e}/` : `${DOMAIN}/movie/${id}/`;
+        const html = await fetchText(embedUrl, { headers: { 'User-Agent': USER_AGENT } });
+
+        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/) || html.match(/"(?:en|token)":"(.*?)"/);
+        if (!match?.[1]) return null;
+
+        const encData = await fetchJson(`${API_BASE}/enc-vidup?text=${encodeURIComponent(match[1])}`);
+        if (encData.status !== 200 || !encData.result) return null;
+
+        const { servers: serversUrl, stream: streamUrl, token } = encData.result;
+        const reqHeaders = { ...HEADERS, 'X-CSRF-Token': token };
+
+        const serversEncrypted = await fetchText(serversUrl, { method: 'POST', headers: reqHeaders });
+        const decServersData = await fetchJson(`${API_BASE}/dec-vidup`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ text: serversEncrypted })
+        });
+
+        if (decServersData.status !== 200 || !decServersData.result) return null;
+        return { servers: decServersData.result, streamUrl, reqHeaders };
+    } catch { return null; }
+}
+
+export async function getStream({ id, s, e, server }) {
+    const meta = await getVidupMeta(id, s, e);
+    if (!meta?.servers?.length) return null;
+
+    const { servers, streamUrl, reqHeaders } = meta;
+    let targets = servers;
+
+    if (server && server !== 'all') {
+        const cleanName = server.replace('VidUp - ', '');
+        targets = servers.filter(srv => srv.name === cleanName);
+        if (!targets.length) targets = servers;
+    }
+
+    const results = await Promise.allSettled(targets.map(async srv => {
+        const streamEncrypted = await fetchText(`${streamUrl}/${srv.data}`, { method: 'POST', headers: reqHeaders });
+        const decStreamData = await fetchJson(`${API_BASE}/dec-vidup`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ text: streamEncrypted })
+        });
+
+        if (decStreamData.status !== 200 || !decStreamData.result?.url) throw new Error();
+
+        return {
+            url: decStreamData.result.url,
+            server: `VidUp - ${srv.name || 'Server'}`,
+            type: decStreamData.result.url.includes('.m3u8') ? 'hls' : 'mp4',
+            subtitles: (decStreamData.result.captions || []).map(c => ({
+                url: c.file,
+                lang: c.label || 'Unknown'
+            })),
+            headers: { ...HEADERS, 'Origin': DOMAIN }
+        };
+    }));
+
+    const allUrls = [];
+    for (const r of results) {
+        if (r.status === 'fulfilled') allUrls.push(r.value);
+    }
+
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources(args) {
+    const meta = await getVidupMeta(args.id, args.s, args.e);
+    return meta?.servers ? meta.servers.map(srv => `VidUp - ${srv.name}`) : [];
+}

package/src/sources/vidzee.js

@@ -0,0 +1,120 @@
+import { webcrypto } from 'node:crypto';
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const PLAYER_URL = 'https://player.vidzee.wtf';
+const CORE_URL = 'https://core.vidzee.wtf';
+
+let cachedKey = null, cachedKeyTs = 0;
+
+async function getDecKey(headers) {
+    const now = Date.now();
+    if (cachedKey && now - cachedKeyTs < 300000) return cachedKey;
+
+    const res = await fetch(`${CORE_URL}/api-key`, {
+        headers,
+        signal: AbortSignal.timeout(7000)
+    });
+    if (!res.ok) throw new Error(`API key fetch failed: ${res.status}`);
+
+    const e = await res.text();
+    const t = Buffer.from(e.replace(/\s+/g, ''), 'base64');
+
+    const s = new Uint8Array(t.length - 28 + 16);
+    s.set(t.subarray(28), 0);
+    s.set(t.subarray(12, 28), t.length - 28);
+
+    const keyMat = await webcrypto.subtle.digest('SHA-256', new TextEncoder().encode('c4a8f1d7e2b9a6c3d0f5e8a1b7c4d9e2'));
+    const key = await webcrypto.subtle.importKey('raw', keyMat, { name: 'AES-GCM' }, false, ['decrypt']);
+
+    try {
+        const decrypted = await webcrypto.subtle.decrypt({
+            name: 'AES-GCM',
+            iv: t.subarray(0, 12),
+            tagLength: 128
+        }, key, s);
+
+        cachedKey = new TextDecoder().decode(decrypted);
+        cachedKeyTs = now;
+        return cachedKey;
+    } catch (err) {
+        throw new Error('Failed to decrypt Vidzee master key');
+    }
+}
+
+function decrypt(enc, key) {
+    try {
+        const dec = Buffer.from(enc, 'base64').toString('utf8');
+        const sep = dec.indexOf(':');
+        if (sep === -1) return '';
+
+        const ivBase64 = dec.slice(0, sep);
+        const ciphertext = dec.slice(sep + 1);
+        const keyPadded = key.padEnd(32, '\0');
+
+        const decrypted = CryptoJS.AES.decrypt(
+            ciphertext,
+            CryptoJS.enc.Utf8.parse(keyPadded),
+            {
+                iv: CryptoJS.enc.Base64.parse(ivBase64),
+                mode: CryptoJS.mode.CBC,
+                padding: CryptoJS.pad.Pkcs7
+            }
+        );
+
+        return decrypted.toString(CryptoJS.enc.Utf8) || '';
+    } catch (err) {
+        return '';
+    }
+}
+
+export async function getStream({ id, s, e, clientIP }) {
+    const headers = {
+        'User-Agent': USER_AGENT,
+        'Accept': 'application/json',
+        'Referer': PLAYER_URL,
+        'Origin': PLAYER_URL,
+        ...(clientIP && { 'X-Forwarded-For': clientIP })
+    };
+
+    try {
+        const decKey = await getDecKey(headers);
+
+        const serversToTry = [3, 0, 1, 2, 4, 5, 6, 8];
+
+        for (const sr of serversToTry) {
+            try {
+                const url = `${PLAYER_URL}/api/server?id=${id}&sr=${sr}${s ? `&ss=${s}&ep=${e || 1}` : ''}`;
+                const data = await fetchJson(url, { headers, signal: AbortSignal.timeout(5000) });
+
+                if (data?.url?.length) {
+                    for (const entry of data.url) {
+                        if (!entry.link) continue;
+
+                        const decrypted = decrypt(entry.link, decKey);
+                        if (decrypted?.startsWith('http')) {
+
+                            return {
+                                allUrls: [
+                                    {
+                                        url: decrypted,
+                                        skipHlsCheck: true,
+                                        headers: {
+                                            'User-Agent': USER_AGENT,
+                                            'Referer': PLAYER_URL,
+                                            'Origin': PLAYER_URL
+                                        }
+                                    }
+                                ]
+                            };
+                        }
+                    }
+                }
+            } catch (err) {
+                continue;
+            }
+        }
+        return null;
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/vixsrc.js

@@ -0,0 +1,98 @@
+import { fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = 'https://vixsrc.to';
+
+const HEADERS = {
+    'User-Agent': USER_AGENT,
+    'Accept': 'application/json, text/javascript, */*; q=0.01',
+    'Accept-Language': 'en-US,en;q=0.9',
+    'Referer': `${BASE_URL}/`,
+    'Origin': BASE_URL
+};
+
+function extract(regex, text) {
+    const m = text?.match(regex);
+    if (!m) return null;
+    return m[1].replace(/\\/g, '');
+}
+
+export async function getStream({ id, s, e, absoluteBase }) {
+    try {
+        const apiUrl = s && e
+            ? `${BASE_URL}/api/tv/${id}/${s}/${e}`
+            : `${BASE_URL}/api/movie/${id}`;
+
+        const apiProxy = absoluteBase
+            ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(apiUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify(HEADERS))}`
+            : apiUrl;
+
+        const apiText = await fetchText(apiProxy).catch(() => null);
+        const apiData = JSON.parse(apiText || '{}');
+        if (!apiData.src) return null;
+
+        const embedUrl = apiData.src.startsWith('http') ? apiData.src : `${BASE_URL}${apiData.src}`;
+        const embedProxy = absoluteBase
+            ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(embedUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify(HEADERS))}`
+            : embedUrl;
+
+        const html = await fetchText(embedProxy).catch(() => null);
+        if (!html) return null;
+
+        const token = extract(/token["']\s*:\s*["']([^"']+)/, html);
+        const expires = extract(/expires["']\s*:\s*["']([^"']+)/, html);
+        let playlist = extract(/url["']\s*:\s*["']([^"']+)/, html);
+        if (!token || !expires || !playlist) return null;
+
+        playlist = playlist.replace(/\\/g, '');
+        const lang = extract(/lang(?:uage)?["']\s*:\s*["']([a-z]{2,5})/i, html) || 'en';
+        const rawMasterUrl = `${playlist}${playlist.includes('?') ? '&' : '?'}token=${token}&expires=${expires}&h=1&lang=${lang}`;
+
+        const masterProxy = absoluteBase
+            ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(rawMasterUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify(HEADERS))}`
+            : rawMasterUrl;
+
+        const playlistText = await fetchText(rawMasterUrl, { headers: HEADERS }).catch(() => null);
+        if (!playlistText?.includes('#EXTM3U')) return null;
+
+        let finalUrl = null;
+        let bestHeight = 0;
+        const lines = playlistText.split('\n');
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (!line.startsWith('#EXT-X-STREAM-INF')) continue;
+            const height = parseInt(line.match(/RESOLUTION=\d+x(\d+)/)?.[1] || '0', 10);
+            let next = lines[i + 1]?.trim();
+            if (!next || next.startsWith('#')) continue;
+
+            if (height > bestHeight) {
+                bestHeight = height;
+                finalUrl = next;
+            }
+        }
+
+        if (!finalUrl) finalUrl = rawMasterUrl;
+
+        if (!finalUrl.startsWith('http')) {
+            const base = rawMasterUrl.split('/playlist/')[0];
+            finalUrl = finalUrl.startsWith('/') ? `${base}${finalUrl}` : `${base}/${finalUrl}`;
+        }
+
+        const alreadyProxied = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/api\?url=/.test(finalUrl);
+
+        return {
+            allUrls: [
+                {
+                    url: finalUrl,
+                    skipProxy: alreadyProxied,
+                    headers: {
+                        ...HEADERS,
+                        'Referer': `${BASE_URL}/`
+                    }
+                }
+            ]
+        };
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/xpass.js

@@ -0,0 +1,40 @@
+import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+
+const BASE = "https://play.xpass.top";
+const HEADERS = { "accept": "*/*", "accept-language": "en-US,en;q=0.9", "cache-control": "no-cache", "pragma": "no-cache", "User-Agent": USER_AGENT, "Origin": BASE, "Referrer": `${BASE}/`, "Cookie": "auth_token=de21073d24bca9b50f189b402ac870734cf945f2085cb7e1a4fc453fcfe4f57e" };
+
+export async function getStream({ id, s, e, server }) {
+    const isTv = s && e && s !== 'null' && e !== 'null';
+    const hdrs = { ...HEADERS, referer: `${BASE}/e/${isTv ? 'tv' : 'movie'}/${id}?autostart=true` };
+    try {
+        let sources = [];
+        if (!isTv) {
+            const text = await fetchText(`${BASE}/e/movie/${id}?autostart=true`, { headers: hdrs, signal: AbortSignal.timeout(7000) });
+            const match = text.match(/var backups=(\[[\s\S]*?\])/);
+            if (match) sources = JSON.parse(match[1]);
+        } else {
+            sources = await fetchJson(`${BASE}/data/tv/${id}/${s}/${e}?autostart=true&force=true`, { headers: hdrs, signal: AbortSignal.timeout(7000) });
+        }
+        if (!sources?.length) return null;
+        if (server && server !== 'all') {
+            const exact = sources.find(src => src.name === server.replace('XPass - ', ''));
+            if (exact) sources = [exact]; else return null;
+        }
+        const allUrls = [];
+        for (const source of sources) {
+            if (!source.url) continue;
+            try {
+                const mdata = await fetchJson(`${BASE}${source.url}`, { headers: hdrs, signal: AbortSignal.timeout(5000) });
+                if (!mdata?.playlist?.[0]?.sources) continue;
+                const targetStream = mdata.playlist[0].sources.find(st => st.type === 'hls') || mdata.playlist[0].sources[0];
+                if (targetStream?.file) allUrls.push({ server: `XPass - ${source.name}`, type: targetStream.type === 'hls' ? 'hls' : 'mp4', url: targetStream.file, headers: { "Origin": HEADERS.Origin, "Referer": HEADERS.Referrer, "User-Agent": HEADERS["User-Agent"] } });
+            } catch { }
+        }
+        return allUrls.length ? { allUrls } : null;
+    } catch { return null; }
+}
+
+export async function getSources(args) {
+    const stream = await getStream(args);
+    return stream?.allUrls ? stream.allUrls.map(u => u.server) : [];
+}

package/src/subtitles.js

@@ -0,0 +1,127 @@
+import { getUA } from './utils/helpers.js';
+
+const SUBTITLE_BASES = [
+    'https://sub.vdrk.site/v1',
+    'https://sub.vdrk.site/v2',
+    'https://fed-subs.pstream.mov'
+];
+const VYLIAN_MESSAGES = [
+    "Thanks for using Vyla!"
+];
+
+function generateVylianVtt() {
+    let vttContent = 'WEBVTT\n\n';
+
+    let currentTime = 1;
+    while (currentTime <= 7200) {
+        const duration = Math.floor(Math.random() * 4) + 1;
+        const message = VYLIAN_MESSAGES[Math.floor(Math.random() * VYLIAN_MESSAGES.length)];
+
+        const startTime = formatVttTime(currentTime);
+        const endTime = formatVttTime(currentTime + duration);
+
+        vttContent += `${startTime} --> ${endTime}\n${message}\n\n`;
+
+        currentTime += duration + Math.floor(Math.random() * 60) + 30;
+    }
+
+    return vttContent;
+}
+
+function formatVttTime(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(secs).padStart(2, '0')}.000`;
+}
+
+export async function fetchSubtitles(paths = []) {
+    try {
+        const results = await Promise.all(
+            paths.map(async ({ base, path }) => {
+                try {
+                    const res = await fetch(`${base}${path}`, {
+                        headers: { 'User-Agent': getUA() },
+                        signal: AbortSignal.timeout(5000),
+                    });
+
+                    if (!res.ok) {
+                        res.body?.cancel();
+                        return [];
+                    }
+
+                    const data = await res.json();
+
+                    if (base.includes('/v2')) {
+                        return Array.isArray(data)
+                            ? data.map(x => ({
+                                label: x.label,
+                                file: x.file || x.url,
+                                type: 'vtt',
+                                source: 'v2'
+                            }))
+                            : [];
+                    }
+
+                    if (base.includes('fed-subs.pstream.mov')) {
+                        if (!data?.subtitles || typeof data.subtitles !== 'object') return [];
+
+                        return Object.entries(data.subtitles)
+                            .map(([language, sub]) => {
+                                if (!sub?.subtitle_link) return null;
+                                const ext = sub.subtitle_link.split('.').pop()?.toLowerCase();
+                                return {
+                                    label: sub.subtitle_name || language,
+                                    file: sub.subtitle_link,
+                                    type: ext === 'vtt' ? 'vtt' : 'srt',
+                                    source: 'febbox'
+                                };
+                            })
+                            .filter(Boolean);
+                    }
+
+                    const v1 = Array.isArray(data) ? data : [];
+                    return v1.map(x => ({
+                        label: x.label,
+                        file: x.file || x.url,
+                        type: 'vtt',
+                        source: 'v1'
+                    }));
+                } catch {
+                    return [];
+                }
+            })
+        );
+
+        const val = results.flat();
+
+        val.push({
+            label: 'Vylian',
+            file: 'data:text/vtt;base64,' + Buffer.from(generateVylianVtt()).toString('base64'),
+            type: 'vtt',
+            source: 'easter-egg'
+        });
+
+        return val;
+    } catch {
+        return [];
+    }
+}
+
+export async function getSubPathsMovie(id) {
+    return [
+        { base: SUBTITLE_BASES[0], path: `/movie/${id}` },
+        { base: SUBTITLE_BASES[1], path: `/movie/${id}` },
+        { base: SUBTITLE_BASES[2], path: `/movie/tt${id}` }
+    ];
+}
+
+export async function getSubPathsTv(id, season, episode) {
+    return [
+        { base: SUBTITLE_BASES[0], path: `/tv/${id}/${season}/${episode}` },
+        { base: SUBTITLE_BASES[1], path: `/tv/${id}/${season}/${episode}` },
+        { base: SUBTITLE_BASES[2], path: `/tv/tt${id}/${season}/${episode}` }
+    ];
+}
+
+export { SUBTITLE_BASES };