@vyla-entertainment/sdk 1.11.0 → 1.12.0

package/src/sources/vidvault.js

@@ -1,113 +1,187 @@
 import { USER_AGENT } from '../utils/helpers.js';
 
-const BASE_URL = "https://vidvault.ru";
+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,
+    '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(`${BASE_URL}/api/get-token`, {
-        method: "GET",
-        headers: HEADERS
+    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;
+    return data?.t;
 }
 
 function getCaptionType(url) {
-    return url.toLowerCase().includes(".vtt") ? "vtt" : "srt";
+    return String(url).toLowerCase().includes('.vtt') ? 'vtt' : 'srt';
 }
 
 export async function getStream(args) {
     const { id, s, e } = args;
-    const type = (s != null && e != null) ? "tv" : "movie";
+    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),
+        };
 
-        const payload = { type, tmdbId: String(id) };
-        if (type === "tv") {
-            payload.season = String(s);
-            payload.episode = String(e);
+        if (isTv) {
+            payload.season = Number(s);
+            payload.episode = Number(e);
         }
 
-        const res = await fetch(`${BASE_URL}/api/download-proxy`, {
-            method: "POST",
+        const res = await fetch(`${API_BASE}/download-proxy`, {
+            method: 'POST',
             headers: {
                 ...HEADERS,
-                "Content-Type": "application/json",
-                "x-request-token": token
+                'Content-Type': 'application/json',
+                'x-request-token': token,
             },
-            body: JSON.stringify(payload)
+            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;
-        if (mp4) {
-            const country = mp4.country || "";
-            const lanName = mp4.lanName || "";
-            const detailPath = mp4.detailPath || "";
-
-            const downloads = mp4.downloadInfo?.data?.downloads || [];
-            for (const d of downloads) {
-                if (!d?.url) continue;
+        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({
-                    quality: `${d.resolution}p ${detailPath} ${country} ${lanName}`.trim(),
-                    url: d.url,
-                    type: "mp4",
-                    headers: HEADERS
+                    url: proxiedUrl,
+                    server: `VidVault - MP4 ${res}p${sizeStr}`.trim(),
+                    quality: typeof res === 'number' ? `${res}p` : res,
+                    type: 'mp4',
+                    headers: HEADERS,
                 });
             }
 
-            const srtCaptions = mp4.downloadInfo?.data?.captions || [];
-            for (const c of srtCaptions) {
-                if (!c?.url) continue;
+            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: c.lanName || c.lan || "Unknown",
-                    type: getCaptionType(c.url),
-                    language: c.lan || "",
-                    url: c.url
+                    label: cap.lanName || cap.lan || 'Unknown',
+                    type: getCaptionType(cap.url),
+                    language: cap.lan || '',
+                    url: subUrl,
                 });
             }
         }
 
         const mkvFiles = data?.mkvData?.files || [];
-        for (const f of mkvFiles) {
-            if (!f?.url) continue;
+        for (const file of mkvFiles) {
+            if (!file?.url) continue;
+            const sizeStr = file.size ? ` (${typeof file.size === 'number' ? formatBytes(file.size) : file.size})` : '';
             allUrls.push({
-                quality: `MKV ${f.size || ""}`.trim(),
-                url: f.url,
-                type: "mp4",
-                headers: HEADERS
+                url: file.url,
+                server: `VidVault - MKV 480p${sizeStr}`.trim(),
+                quality: '480p',
+                type: 'mp4',
+                headers: HEADERS,
             });
         }
 
         const mkvV2 = data?.mkvV2Data;
-        if (mkvV2?.url) {
+        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({
-                quality: `${mkvV2.quality || ""} ${mkvV2.language || ""} ${mkvV2.country || ""} (${mkvV2.size || ""})`.trim(),
-                url: mkvV2.url,
-                type: "mp4",
-                headers: HEADERS
+                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?.url) {
-            allUrls.push({
-                quality: `${mkvV3.quality || ""} ${mkvV3.language || ""} ${mkvV3.country || ""} (${mkvV3.size || ""})`.trim(),
-                url: mkvV3.url,
-                type: "mp4",
-                headers: HEADERS
-            });
+        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 } : null;
+        return allUrls.length ? { allUrls, subtitles: subtitles.length ? subtitles : undefined } : null;
     } catch (err) {
         return null;
     }

package/src/sources/vuflix.js

@@ -0,0 +1,249 @@
+import { getUA } from '../utils/helpers.js';
+
+const API_BASE = 'https://vuflix.co';
+const REFERER = 'https://vuflix.co/';
+const ORIGIN = 'https://vuflix.co';
+
+let cachedProviders = null;
+let lastProvidersFetch = 0;
+
+const FALLBACK_PROVIDERS = [
+    { id: 'vsembed', name: 'Sigma' },
+    { id: 'moonflix', name: 'Source 40' },
+    { id: 'megasource', name: 'Source 39' },
+    { id: 'hdghar', name: 'Source 44' },
+    { id: 'moviebox', name: 'Pi' },
+    { id: 'cineplay', name: '4K' },
+    { id: 'huhu', name: 'Beta' },
+    { id: 'bingr', name: 'Upsilon' },
+    { id: 'onlyflix', name: 'Gamma' },
+    { id: 'vaplayer', name: 'Alpha' },
+    { id: 'flixhqz', name: 'Gamma' },
+    { id: 'castle', name: 'Source 40' },
+    { id: 'cinejoy', name: '4K2' },
+    { id: 'filesun', name: 'Tau' },
+    { id: 'yoru', name: 'Yoru' },
+];
+
+async function getProviders(ua) {
+    if (cachedProviders && Date.now() - lastProvidersFetch < 900000) {
+        return cachedProviders;
+    }
+
+    try {
+        const res = await fetch(`${API_BASE}/api/player/providers`, {
+            headers: {
+                'User-Agent': ua,
+                Referer: REFERER,
+                Origin: ORIGIN,
+                Accept: 'application/json, text/plain, */*',
+            },
+            signal: AbortSignal.timeout(6000),
+        });
+
+        if (res.ok) {
+            const data = await res.json();
+            if (data?.ok && Array.isArray(data.providers)) {
+                const list = data.providers
+                    .filter(p => p && typeof p.id === 'string' && p.id.trim().length > 0)
+                    .map(p => ({
+                        id: p.id.trim(),
+                        name: p.publicLabel || p.providerName || p.name || p.id,
+                    }));
+
+                if (list.length > 0) {
+                    cachedProviders = list;
+                    lastProvidersFetch = Date.now();
+                    return list;
+                }
+            }
+        }
+    } catch { }
+
+    return FALLBACK_PROVIDERS;
+}
+
+function unwrapUrl(rawUrl, ua) {
+    const defaultHeaders = {
+        'User-Agent': ua,
+        Referer: REFERER,
+        Origin: ORIGIN,
+    };
+
+    if (!rawUrl || typeof rawUrl !== 'string') {
+        return { url: '', headers: defaultHeaders };
+    }
+
+    if (!rawUrl.includes('v-relay?t=') && !rawUrl.includes('a-relay?t=')) {
+        return { url: rawUrl, headers: defaultHeaders };
+    }
+
+    try {
+        const parsedUrl = new URL(rawUrl);
+        const t = parsedUrl.searchParams.get('t');
+        if (!t) return { url: rawUrl, headers: defaultHeaders };
+
+        let b64 = t.replace(/-/g, '+').replace(/_/g, '/');
+        while (b64.length % 4 !== 0) {
+            b64 += '=';
+        }
+
+        const jsonStr = Buffer.from(b64, 'base64').toString('utf8');
+        const parsed = JSON.parse(jsonStr);
+
+        if (parsed && typeof parsed === 'object') {
+            const directUrl = (parsed.u || '').trim();
+            const headersMap = { ...defaultHeaders };
+
+            if (parsed.h && typeof parsed.h === 'object') {
+                for (const [key, value] of Object.entries(parsed.h)) {
+                    headersMap[key] = String(value);
+                }
+            }
+
+            if (directUrl) {
+                return { url: directUrl, headers: headersMap };
+            }
+        }
+    } catch { }
+
+    return { url: rawUrl, headers: defaultHeaders };
+}
+
+export async function getStream({ id, s, e }) {
+    const isTv = Boolean(s && e);
+    const mediaType = isTv ? 'tv' : 'movie';
+    const ua = getUA();
+
+    const baseParams = new URLSearchParams({
+        type: mediaType,
+        tmdbId: String(id),
+    });
+
+    if (isTv) {
+        baseParams.set('season', String(s));
+        baseParams.set('episode', String(e));
+    }
+
+    const providers = await getProviders(ua);
+    const seenUrls = new Set();
+    const allUrls = [];
+
+    const defaultHeaders = {
+        'User-Agent': ua,
+        Referer: REFERER,
+        Origin: ORIGIN,
+        Accept: 'application/json, text/plain, */*',
+    };
+
+    const tasks = providers.map(async (prov) => {
+        try {
+            const url = `${API_BASE}/api/player/sources?${baseParams.toString()}&provider=${encodeURIComponent(prov.id)}`;
+            const res = await fetch(url, {
+                headers: defaultHeaders,
+                signal: AbortSignal.timeout(8000),
+            });
+
+            if (!res.ok) return;
+            const data = await res.json();
+            if (!data?.ok || !Array.isArray(data.sources)) return;
+
+            for (const item of data.sources) {
+                if (!item || typeof item !== 'object') continue;
+
+                const providerName = item.providerName || item.publicLabel || prov.name;
+                const primaryRawUrl = (item.url || '').trim();
+                const itemType = (item.type || 'hls').toLowerCase();
+                const itemLabel = item.label || '';
+
+                if (Array.isArray(item.qualities) && item.qualities.length > 0) {
+                    for (const q of item.qualities) {
+                        if (!q || typeof q !== 'object') continue;
+                        const qRawUrl = (q.url || '').trim();
+                        if (!qRawUrl) continue;
+
+                        const unwrapped = unwrapUrl(qRawUrl, ua);
+                        if (!unwrapped.url || seenUrls.has(unwrapped.url)) continue;
+                        seenUrls.add(unwrapped.url);
+
+                        const qQuality = q.quality || 'Auto';
+                        allUrls.push({
+                            url: unwrapped.url,
+                            label: `${providerName} · ${qQuality}`,
+                            headers: unwrapped.headers,
+                        });
+                    }
+                }
+
+                if (Array.isArray(item.candidates) && item.candidates.length > 0) {
+                    let candIndex = 1;
+                    for (const c of item.candidates) {
+                        if (!c || typeof c !== 'object') continue;
+                        const cRawUrl = (c.url || '').trim();
+                        if (!cRawUrl) continue;
+
+                        const unwrapped = unwrapUrl(cRawUrl, ua);
+                        if (!unwrapped.url || seenUrls.has(unwrapped.url)) continue;
+                        seenUrls.add(unwrapped.url);
+
+                        const cQuality = c.quality || '1080p';
+                        allUrls.push({
+                            url: unwrapped.url,
+                            label: `${providerName} · Mirror ${candIndex} · ${cQuality}`,
+                            headers: unwrapped.headers,
+                        });
+                        candIndex++;
+                    }
+                }
+
+                if (Array.isArray(item.audioTracks) && item.audioTracks.length > 0) {
+                    for (const a of item.audioTracks) {
+                        if (!a || typeof a !== 'object') continue;
+                        const aRawUrl = (a.switchUrl || a.url || '').trim();
+                        if (!aRawUrl) continue;
+
+                        const unwrapped = unwrapUrl(aRawUrl, ua);
+                        if (!unwrapped.url || seenUrls.has(unwrapped.url)) continue;
+                        seenUrls.add(unwrapped.url);
+
+                        const rawLabel = (a.label || a.name || a.language || 'Audio').trim();
+                        const cleanLabel = rawLabel.replace(/\s*audio\s*$/i, '').trim() || 'Audio';
+
+                        allUrls.push({
+                            url: unwrapped.url,
+                            label: `${providerName} · ${cleanLabel} Audio`,
+                            headers: unwrapped.headers,
+                        });
+                    }
+                }
+
+                if (primaryRawUrl) {
+                    const unwrapped = unwrapUrl(primaryRawUrl, ua);
+                    if (unwrapped.url && !seenUrls.has(unwrapped.url)) {
+                        seenUrls.add(unwrapped.url);
+
+                        let displayQuality = item.quality || (itemType === 'mp4' ? 'MP4' : 'HD');
+                        let cleanLabel = itemLabel || providerName;
+                        let label = cleanLabel.startsWith('[') ? cleanLabel : `${providerName} · ${displayQuality}`;
+
+                        allUrls.push({
+                            url: unwrapped.url,
+                            label,
+                            headers: unwrapped.headers,
+                        });
+                    }
+                }
+            }
+        } catch { }
+    });
+
+    await Promise.all(tasks);
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}

package/src/sources/xdownloader.js

@@ -0,0 +1,129 @@
+const BASE_URL = 'https://www.films365.org';
+const HEADERS = {
+    Authorization: 'Bearer 79a02956be35835728a044b11e2ae793149d45fb2c89cb6d029ec01aac19bfdb',
+    'Content-Type': 'application/json',
+    'User-Agent': 'MovieDownloader/1.0',
+};
+
+async function resolveTitle(sdk, id, isTv) {
+    const apiKey = sdk?.tmdbApiKey || process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? 'tv' : 'movie';
+    try {
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`, {
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        return isTv ? data.name : data.title;
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, sdk }) {
+    const isTv = Boolean(s && e);
+    const targetType = isTv ? 'tv' : 'movie';
+
+    const title = await resolveTitle(sdk, id, isTv);
+    const query = title || String(id);
+
+    const searchRes = await fetch(`${BASE_URL}/api/mobile/search`, {
+        method: 'POST',
+        headers: HEADERS,
+        body: JSON.stringify({ query }),
+        signal: AbortSignal.timeout(8000),
+    });
+
+    if (!searchRes.ok) return null;
+    const searchJson = await searchRes.json();
+    const resultsObj = searchJson?.results;
+    if (!resultsObj) return null;
+
+    const items = resultsObj.all || (targetType === 'tv' ? resultsObj.tvs : resultsObj.movies) || [];
+    if (!Array.isArray(items) || items.length === 0) return null;
+
+    const cleanSearchTitle = query.toLowerCase().replace(/[^a-z0-9]/g, '');
+    let matchedItem = null;
+
+    for (const item of items) {
+        const itemType = String(item?.type || '').toLowerCase();
+        if (itemType && itemType !== targetType) continue;
+
+        const itemTitle = String(item?.title || '');
+        const cleanItemTitle = itemTitle.toLowerCase().replace(/[^a-z0-9]/g, '');
+
+        if (cleanItemTitle === cleanSearchTitle || cleanItemTitle.includes(cleanSearchTitle)) {
+            matchedItem = item;
+            break;
+        }
+    }
+
+    if (!matchedItem) {
+        matchedItem = items.find(i => String(i?.type || '').toLowerCase() === targetType) || items[0];
+    }
+
+    const itemId = matchedItem?.id || matchedItem?.tmdbId;
+    if (!itemId) return null;
+
+    const detailsRes = await fetch(`${BASE_URL}/api/mobile/details?id=${itemId}&type=${targetType}`, {
+        headers: HEADERS,
+        signal: AbortSignal.timeout(8000),
+    });
+
+    if (!detailsRes.ok) return null;
+    const detailsJson = await detailsRes.json();
+    const data = detailsJson?.data;
+    if (!data) return null;
+
+    const spoken = Array.isArray(data.spokenLanguages)
+        ? data.spokenLanguages.map(l => String(l).trim()).filter(Boolean)
+        : [];
+    const langSuffix = spoken.length > 0 ? ` · ${spoken.join(', ')}` : '';
+
+    const allUrls = [];
+
+    if (!isTv) {
+        const streamUrl = data.downloadUrl || data.videoUrl;
+        if (streamUrl && typeof streamUrl === 'string') {
+            allUrls.push({
+                url: streamUrl.trim(),
+                label: `X-Downloader${langSuffix}`,
+                headers: {
+                    'User-Agent': HEADERS['User-Agent'],
+                },
+            });
+        }
+    } else {
+        const seasonNum = Number(s);
+        const episodeNum = Number(e);
+        const seasons = Array.isArray(data.seasons) ? data.seasons : [];
+        const targetSeason = seasons.find(sn => Number(sn.seasonNumber) === seasonNum);
+
+        if (targetSeason) {
+            const episodes = Array.isArray(targetSeason.episodes) ? targetSeason.episodes : [];
+            const targetEp = episodes.find(ep => Number(ep.episodeNumber) === episodeNum);
+
+            if (targetEp) {
+                const streamUrl = targetEp.downloadUrl || targetEp.videoUrl;
+                if (streamUrl && typeof streamUrl === 'string') {
+                    allUrls.push({
+                        url: streamUrl.trim(),
+                        label: `X-Downloader (S${seasonNum}E${episodeNum})${langSuffix}`,
+                        headers: {
+                            'User-Agent': HEADERS['User-Agent'],
+                        },
+                    });
+                }
+            }
+        }
+    }
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}