@vyla-entertainment/sdk 1.20.0 → 1.22.0

package/src/sources/vidora.js

@@ -1,55 +1,87 @@
-import { fetchText } from '../utils/helpers.js';
+const BASE_URL = 'https://vidoraplayer.duckdns.org';
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36';
 
-export async function getStream({ id, s, e }) {
-    const isTv = s != null && e != null;
-    const url = isTv
-        ? `https://vidora-3l2w.onrender.com/api/sources?type=tv&id=${id}&season=${s}&episode=${e}`
-        : `https://vidora-3l2w.onrender.com/api/sources?type=movie&id=${id}`;
-
-    const headers = {
-        'Accept': 'text/event-stream',
-        'Referer': 'https://vidora-3l2w.onrender.com/',
-        'Origin': 'https://vidora-3l2w.onrender.com',
-        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36'
-    };
-
-    const raw = await fetchText(url, { headers }).catch(() => null);
-    if (!raw) return null;
-
-    const lines = raw.split('\n');
-    let doneSources = null;
-    const streamItems = [];
-
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) continue;
+const HEADERS = {
+    'User-Agent': UA,
+    Referer: `${BASE_URL}/`,
+    Origin: BASE_URL,
+    Accept: 'application/x-ndjson, text/plain, */*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
 
+function parseNdjson(text) {
+    if (!text) return [];
+    const normalized = text.replace(/\}\s*\{/g, '}\n{');
+    const lines = normalized.split('\n');
+    const items = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line) continue;
         try {
-            const parsed = JSON.parse(trimmed);
-            if (parsed.event === 'source' && parsed.source?.url) {
-                streamItems.push(parsed.source);
-            } else if (parsed.event === 'done' && Array.isArray(parsed.sources)) {
-                doneSources = parsed.sources;
-            }
+            items.push(JSON.parse(line));
         } catch { }
     }
+    return items;
+}
 
-    const targetList = (doneSources && doneSources.length > 0) ? doneSources : streamItems;
-    if (!targetList.length) return null;
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    const isTv = s != null && e != null;
+
+    const query = isTv
+        ? `type=tv&id=${id}&season=${s}&episode=${e}`
+        : `type=movie&id=${id}`;
+
+    const urls = [
+        `${BASE_URL}/api/sources?${query}`,
+        `${BASE_URL}/api/sources?${query}&gen=2`,
+    ];
+
+    const responses = await Promise.all(
+        urls.map(url =>
+            fetch(url, { headers: HEADERS })
+                .then(r => (r.ok ? r.text() : ''))
+                .catch(() => '')
+        )
+    );
 
     const allUrls = [];
+    const seen = new Set();
+
+    for (const text of responses) {
+        const events = parseNdjson(text);
+        for (const item of events) {
+            const list = [];
+            if (item?.event === 'source' && item?.source) {
+                list.push(item.source);
+            } else if (item?.event === 'done' && Array.isArray(item?.sources)) {
+                list.push(...item.sources);
+            } else if (item?.url) {
+                list.push(item);
+            }
 
-    for (const src of targetList) {
-        if (!src.url || !src.url.startsWith('http')) continue;
+            for (const src of list) {
+                if (!src?.url) continue;
+                const fullUrl = src.url.startsWith('http')
+                    ? src.url
+                    : `${BASE_URL}${src.url.startsWith('/') ? '' : '/'}${src.url}`;
 
-        allUrls.push({
-            url: src.url,
-            server: `Vidora - ${src.label || src.server || src.providerGroup || 'Server'} (${src.quality || 'Auto'})`,
-            headers: src.headers || {
-                Referer: 'https://vidora-3l2w.onrender.com/',
-                Origin: 'https://vidora-3l2w.onrender.com'
+                if (!seen.has(fullUrl)) {
+                    seen.add(fullUrl);
+                    allUrls.push({
+                        url: fullUrl,
+                        server: `Vidora - ${src.label || src.server || src.providerGroup || 'Default'}`,
+                        quality: src.quality || 'Auto',
+                        type: src.type || (fullUrl.includes('.m3u8') ? 'hls' : 'mp4'),
+                        headers: {
+                            Referer: `${BASE_URL}/`,
+                            Origin: BASE_URL,
+                            'User-Agent': UA,
+                        },
+                    });
+                }
             }
-        });
+        }
     }
 
     if (!allUrls.length) return null;
@@ -57,6 +89,6 @@ export async function getStream({ id, s, e }) {
     return {
         url: allUrls[0].url,
         headers: allUrls[0].headers,
-        allUrls
+        allUrls,
     };
 }

package/src/sources/vidup.js

@@ -1,123 +1,15 @@
-import { getUA } from '../utils/helpers.js';
-
-const BASE_URL = 'https://vidup.to';
-const API = 'https://enc-dec.app/api';
-
-export async function getStream({ id, s, e }) {
-    const isTv = Boolean(s && e);
-    const targetUrl = isTv
-        ? `${BASE_URL}/tv/${id}/${s}/${e}/`
-        : `${BASE_URL}/movie/${id}`;
-
-    const ua = getUA();
-    const baseHeaders = {
-        'User-Agent': ua,
-        'Referer': `${BASE_URL}/`,
-        'X-Requested-With': 'XMLHttpRequest',
-    };
-
-    try {
-        const pageRes = await fetch(targetUrl, {
-            headers: { 'User-Agent': ua },
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!pageRes.ok) return null;
-        const html = await pageRes.text();
-
-        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/);
-        if (!match || !match[1]) return null;
-        const enToken = match[1];
-
-        const s1Res = await fetch(`${API}/enc-vidup?text=${encodeURIComponent(enToken)}&stage=1`, {
-            signal: AbortSignal.timeout(8000),
-        });
-        const s1Data = await s1Res.json();
-        if (s1Data?.status !== 200 || !s1Data?.result?.stage1) return null;
-
-        const token1 = s1Data.result.token;
-        const stage1Url = s1Data.result.stage1;
-
-        const post1Res = await fetch(stage1Url, {
-            method: 'POST',
-            headers: { ...baseHeaders, 'X-CSRF-Token': token1 },
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!post1Res.ok) return null;
-        const stage1Text = await post1Res.text();
-
-        const s2Res = await fetch(`${API}/enc-vidup?text=${encodeURIComponent(stage1Text)}&stage=2`, {
-            signal: AbortSignal.timeout(8000),
-        });
-        const s2Data = await s2Res.json();
-        if (s2Data?.status !== 200 || !s2Data?.result?.servers) return null;
-
-        const { servers: serversUrl, stream: streamBaseUrl, token: token2 } = s2Data.result;
-        const currentHeaders = { ...baseHeaders, 'X-CSRF-Token': token2 };
-
-        const serversRes = await fetch(serversUrl, {
-            method: 'POST',
-            headers: currentHeaders,
-            signal: AbortSignal.timeout(10000),
-        });
-        if (!serversRes.ok) return null;
-        const serversEncrypted = await serversRes.text();
-
-        const decServersRes = await fetch(`${API}/dec-vidup`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ text: serversEncrypted }),
-            signal: AbortSignal.timeout(8000),
-        });
-        const decServersData = await decServersRes.json();
-        if (decServersData?.status !== 200 || !Array.isArray(decServersData.result)) return null;
-
-        const allUrls = [];
-
-        for (const server of decServersData.result) {
-            if (!server?.data) continue;
-            try {
-                const streamUrl = `${streamBaseUrl}/${server.data}`;
-                const streamEncRes = await fetch(streamUrl, {
-                    method: 'POST',
-                    headers: currentHeaders,
-                    signal: AbortSignal.timeout(8000),
-                });
-                if (!streamEncRes.ok) continue;
-                const streamEncText = await streamEncRes.text();
-
-                const decStreamRes = await fetch(`${API}/dec-vidup`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ text: streamEncText }),
-                    signal: AbortSignal.timeout(8000),
-                });
-                const decStreamData = await decStreamRes.json();
-                if (decStreamData?.status !== 200 || !decStreamData.result) continue;
-
-                const streamResult = decStreamData.result;
-                const resultUrl = typeof streamResult === 'string' ? streamResult : streamResult?.url || streamResult?.file;
-
-                if (typeof resultUrl === 'string' && resultUrl.startsWith('http')) {
-                    allUrls.push({
-                        url: resultUrl,
-                        label: server.name || server.title || 'VidUp',
-                        headers: {
-                            'User-Agent': ua,
-                            'Referer': `${BASE_URL}/`,
-                        },
-                    });
-                }
-            } catch { }
-        }
-
-        if (allUrls.length === 0) return null;
-
-        return {
-            url: allUrls[0].url,
-            allUrls,
-            headers: allUrls[0].headers,
-        };
-    } catch {
-        return null;
-    }
+import { scrapeVidcoreFamily } from '../utils/helpers.js';
+
+const BASE_URL = 'https://vidup.to';
+
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    return await scrapeVidcoreFamily({
+        id,
+        s,
+        e,
+        baseUrl: BASE_URL,
+        apiName: 'vidup',
+        serverLabel: 'VidUp',
+    });
 }

package/src/sources/vidvault.js

@@ -1,188 +1,134 @@
-import { USER_AGENT } from '../utils/helpers.js';
-
-const BASE_URL = 'https://vidvault.to';
-const API_BASE = `${BASE_URL}/api`;
-const DL_PROXY_BASE = 'https://dl.gemlelispe.workers.dev';
-const SUB_PROXY_BASE = 'https://sub.k5s7sjozpn.workers.dev';
-
-const HEADERS = {
-    'Referer': `${BASE_URL}/`,
-    'Origin': BASE_URL,
-    'User-Agent': USER_AGENT,
-    'Accept': 'application/json, text/plain, */*',
-    'Accept-Language': 'en-US,en;q=0.9',
-};
-
-function formatBytes(bytes, decimals = 2) {
-    if (!bytes || bytes <= 0) return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
-    return `${(bytes / Math.pow(k, i)).toFixed(decimals)} ${sizes[i]}`;
-}
-
-async function getToken() {
-    const res = await fetch(`${API_BASE}/get-token`, {
-        method: 'GET',
-        headers: HEADERS,
-        signal: AbortSignal.timeout(10000),
-    });
-    if (!res.ok) throw new Error(`Token fetch failed: ${res.status}`);
-    const data = await res.json();
-    return data?.t;
-}
-
-function getCaptionType(url) {
-    return String(url).toLowerCase().includes('.vtt') ? 'vtt' : 'srt';
-}
-
-export async function getStream(args) {
-    const { id, s, e } = args;
-    const isTv = s != null && e != null;
-    const type = isTv ? 'tv' : 'movie';
-
-    try {
-        const token = await getToken();
-        if (!token) return null;
-
-        const payload = {
-            type,
-            tmdbId: String(id),
-        };
-
-        if (isTv) {
-            payload.season = Number(s);
-            payload.episode = Number(e);
-        }
-
-        const res = await fetch(`${API_BASE}/download-proxy`, {
-            method: 'POST',
-            headers: {
-                ...HEADERS,
-                'Content-Type': 'application/json',
-                'x-request-token': token,
-            },
-            body: JSON.stringify(payload),
-            signal: AbortSignal.timeout(15000),
-        });
-
-        if (!res.ok) return null;
-        const data = await res.json();
-
-        const allUrls = [];
-        const subtitles = [];
-        const titleTag = encodeURIComponent(isTv ? `Show_${id}_S${s}E${e}` : `Movie_${id}`);
-
-        const mp4 = data?.mp4Data;
-        const downloadData = mp4?.downloadInfo?.data || mp4?.data?.data || mp4?.data || mp4;
-
-        if (downloadData) {
-            const streams = downloadData.streams || downloadData.downloads || [];
-            for (const item of streams) {
-                if (!item?.url) continue;
-
-                const res = item.resolutions || item.resolution || 'Auto';
-                const sizeStr = item.size ? ` (${typeof item.size === 'number' ? formatBytes(item.size) : item.size})` : '';
-                const proxiedUrl = `${DL_PROXY_BASE}/${encodeURIComponent(item.url)}?n=${titleTag}`;
-
-                allUrls.push({
-                    url: proxiedUrl,
-                    server: `VidVault - MP4 ${res}p${sizeStr}`.trim(),
-                    quality: typeof res === 'number' ? `${res}p` : res,
-                    type: 'mp4',
-                    headers: HEADERS,
-                });
-            }
-
-            const captions = downloadData.captions || [];
-            for (const cap of captions) {
-                if (!cap?.url) continue;
-                const subUrl = `${SUB_PROXY_BASE}/?url=${encodeURIComponent(cap.url)}&title=${titleTag}`;
-                subtitles.push({
-                    label: cap.lanName || cap.lan || 'Unknown',
-                    type: getCaptionType(cap.url),
-                    language: cap.lan || '',
-                    url: subUrl,
-                });
-            }
-        }
-
-        const mkvFiles = data?.mkvData?.files || [];
-        for (const file of mkvFiles) {
-            if (!file?.url) continue;
-            const sizeStr = file.size ? ` (${typeof file.size === 'number' ? formatBytes(file.size) : file.size})` : '';
-            allUrls.push({
-                url: file.url,
-                server: `VidVault - MKV 480p${sizeStr}`.trim(),
-                quality: '480p',
-                type: 'mp4',
-                headers: HEADERS,
-            });
-        }
-
-        const mkvV2 = data?.mkvV2Data;
-        const mkvV2List = Array.isArray(mkvV2)
-            ? mkvV2
-            : Array.isArray(mkvV2?.files)
-                ? mkvV2.files
-                : (mkvV2?.url ? [mkvV2] : []);
-
-        for (const file of mkvV2List) {
-            if (!file?.url) continue;
-            const quality = file.quality ? String(file.quality).replace(/p$/i, '') : 'Auto';
-            const sizeStr = file.size ? ` (${typeof file.size === 'number' ? formatBytes(file.size) : file.size})` : '';
-            const meta = [file.country, file.language].filter(Boolean).join(' • ');
-            const metaStr = meta ? ` [${meta}]` : '';
-
-            allUrls.push({
-                url: file.url,
-                server: `VidVault - MKV v2 ${quality}p${sizeStr}${metaStr}`.trim(),
-                quality: `${quality}p`,
-                type: 'mp4',
-                headers: HEADERS,
-            });
-        }
-
-        const mkvV3 = data?.mkvV3Data;
-        if (mkvV3?.downloads && Array.isArray(mkvV3.downloads)) {
-            const country = mkvV3.country || '';
-            const language = mkvV3.language || '';
-
-            for (const down of mkvV3.downloads) {
-                if (Array.isArray(down?.qualities)) {
-                    for (const qObj of down.qualities) {
-                        for (const ep of qObj?.episodes || []) {
-                            if (!ep?.url) continue;
-                            const quality = qObj.quality ? String(qObj.quality).replace(/p$/i, '') : 'Auto';
-                            const sizeStr = ep.size ? ` (${typeof ep.size === 'number' ? formatBytes(ep.size) : ep.size})` : '';
-                            const meta = [ep.country || country, ep.language || language].filter(Boolean).join(' • ');
-                            const metaStr = meta ? ` [${meta}]` : '';
-
-                            allUrls.push({
-                                url: ep.url,
-                                server: `VidVault - MKV v3 ${quality}p${sizeStr}${metaStr}`.trim(),
-                                quality: `${quality}p`,
-                                type: 'mp4',
-                                headers: HEADERS,
-                            });
-                        }
-                    }
-                } else if (down?.url) {
-                    const quality = down.quality ? String(down.quality).replace(/p$/i, '') : 'Auto';
-                    const sizeStr = down.size ? ` (${typeof down.size === 'number' ? formatBytes(down.size) : down.size})` : '';
-                    allUrls.push({
-                        url: down.url,
-                        server: `VidVault - MKV v3 ${quality}p${sizeStr}`.trim(),
-                        quality: `${quality}p`,
-                        type: 'mp4',
-                        headers: HEADERS,
-                    });
-                }
-            }
-        }
-
-        return allUrls.length ? { allUrls, subtitles: subtitles.length ? subtitles : undefined } : null;
-    } catch (err) {
-        return null;
-    }
+import { formatBytes, USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = 'https://vidvault.to';
+const API_BASE = `${BASE_URL}/api`;
+const DL_PROXY_BASE = 'https://dl.gemlelispe.workers.dev';
+const SUB_PROXY_BASE = 'https://sub.k5s7sjozpn.workers.dev';
+
+const HEADERS = {
+    Referer: `${BASE_URL}/`,
+    Origin: BASE_URL,
+    'User-Agent': USER_AGENT,
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+
+async function getToken() {
+    const res = await fetch(`${API_BASE}/get-token`, {
+        method: 'GET',
+        headers: HEADERS,
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) throw new Error(`Token fetch failed: ${res.status}`);
+    const data = await res.json();
+    return data?.t;
+}
+
+function getCaptionType(url) {
+    return String(url).toLowerCase().includes('.vtt') ? 'vtt' : 'srt';
+}
+
+async function fetchJson(url, options = {}) {
+    try {
+        const res = await fetch(url, options);
+        if (!res.ok) return null;
+        return await res.json();
+    } catch {
+        return null;
+    }
+}
+
+async function resolveDirect(directPath, headers) {
+    const fullUrl = directPath.startsWith('http') ? directPath : `${BASE_URL}${directPath}`;
+    try {
+        const res = await fetch(fullUrl, {
+            method: 'HEAD',
+            redirect: 'manual',
+            headers,
+        });
+        const loc = res.headers.get('location');
+        if (loc) return loc;
+    } catch { }
+    return fullUrl;
+}
+
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    const isTv = s != null && e != null;
+
+    const mediaPath = isTv
+        ? `${BASE_URL}/media/tv/${id}/${s}/${e}`
+        : `${BASE_URL}/media/movie/${id}`;
+
+    const [mediaData, tokenData] = await Promise.all([
+        fetchJson(mediaPath, { headers: HEADERS }).catch(() => null),
+        fetchJson(`${BASE_URL}/api/get-token`, { headers: HEADERS }).catch(() => null),
+    ]);
+
+    const allUrls = [];
+    const seen = new Set();
+
+    if (Array.isArray(mediaData?.direct)) {
+        await Promise.all(
+            mediaData.direct.map(async (item) => {
+                if (!item?.path) return;
+                const streamUrl = await resolveDirect(item.path, HEADERS);
+                if (streamUrl && !seen.has(streamUrl)) {
+                    seen.add(streamUrl);
+                    const format = item.format || (streamUrl.includes('.mkv') ? 'mkv' : 'mp4');
+                    allUrls.push({
+                        url: streamUrl,
+                        server: `VidVault - Direct ${format.toUpperCase()} (${item.quality || item.size || 'Auto'})`,
+                        quality: item.quality || 'Auto',
+                        type: format,
+                        headers: HEADERS,
+                    });
+                }
+            })
+        );
+    }
+
+    const token = tokenData?.t;
+    if (token) {
+        const payload = isTv
+            ? { type: 'tv', tmdbId: String(id), season: String(s), episode: String(e) }
+            : { type: 'movie', tmdbId: String(id) };
+
+        const proxyData = await fetchJson(`${BASE_URL}/api/download-proxy`, {
+            method: 'POST',
+            headers: {
+                ...HEADERS,
+                'Content-Type': 'application/json',
+                'x-request-token': token,
+            },
+            body: JSON.stringify(payload),
+        }).catch(() => null);
+
+        const candidates = [
+            { data: proxyData?.mp4Data, type: 'mp4', label: 'MP4' },
+            { data: proxyData?.mkvData, type: 'mkv', label: 'MKV' },
+            { data: proxyData?.mkvV2Data, type: 'mkv', label: 'MKV V2' },
+        ];
+
+        for (const { data, type, label } of candidates) {
+            if (data?.url && !seen.has(data.url)) {
+                seen.add(data.url);
+                allUrls.push({
+                    url: data.url,
+                    server: `VidVault - ${label} (${data.quality || data.size || 'Auto'})`,
+                    quality: data.quality || 'Auto',
+                    type,
+                    headers: HEADERS,
+                });
+            }
+        }
+    }
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls,
+    };
 }