@vyla-entertainment/sdk 1.12.0 → 1.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyla-entertainment/sdk",
-  "version": "1.12.0",
+  "version": "1.14.0",
   "scripts": {
     "test": "node test/index.js"
   },

package/src/config.js

@@ -6,18 +6,6 @@
 // Fshare/Fsonic Tested: 155 ( they don't have Michael )
 
 export const SOURCES = [
-    {
-        key: '4khdhub',
-        label: '4KHDHub',
-        sourceFile: '4khdhub',
-        proxyParam: 'khd',
-        timeout: 35000,
-        jitter: 500,
-        retries: 1,
-        multiUrl: true,
-        skipProxy: true,
-    },
-
     {
         key: '123anime',
         label: '123Anime',
@@ -119,72 +107,20 @@ export const SOURCES = [
     },
 
     {
-        key: 'cinejoy',
-        label: 'Cinejoy',
-        sourceFile: 'cinejoy',
-        proxyParam: 'cj',
-        timeout: 30000,
-        jitter: 500,
-        retries: 1,
-        multiUrl: true,
-        skipProxy: true,
-    },
-
-    {
-        key: 'cinesrc',
-        label: 'CineSrc',
-        sourceFile: 'cinesrc',
-        proxyParam: 'csr',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-        skipVerify: true,
-        cdnHeaders: [{
-            pattern: /glendale-plumbing\.com|1embed\.cc|bright\d+\.online/i,
-            headers: {
-                Referer: 'https://cinesrc.st/',
-                Origin: 'https://cinesrc.st',
-            },
-        }],
-    },
-
-    {
-        key: 'cinesu',
-        label: 'CineSu',
-        sourceFile: 'cinesu',
-        proxyParam: 'cs',
+        key: 'dulo',
+        label: 'Dulo',
+        sourceFile: 'dulo',
+        proxyParam: 'dl',
         timeout: 25000,
         jitter: 500,
         retries: 2,
         multiUrl: true,
         skipProxy: true,
-        skipVerify: true,
         cdnHeaders: [{
-            pattern: /glendale-plumbing\.com/i,
+            pattern: /dulo\.mov/i,
             headers: {
-                Referer: 'https://cine.su/',
-                Origin: 'https://cine.su',
-            },
-        }],
-    },
-
-    {
-        key: 'downloadeverything',
-        label: 'DownloadEverything',
-        sourceFile: 'downloadeverything',
-        proxyParam: 'de',
-        timeout: 35000,
-        jitter: 500,
-        retries: 1,
-        multiUrl: true,
-        skipProxy: true,
-        cdnHeaders: [{
-            pattern: /cloudflarestorage\.com|pixeldrain\.com|hakunaymatata\.com/i,
-            headers: {
-                Referer: 'https://downloadeverythingfromeverywhere.com/',
-                Origin: 'https://downloadeverythingfromeverywhere.com',
+                Referer: 'https://dulo.mov/',
+                Origin: 'https://dulo.mov',
             },
         }],
     },
@@ -208,45 +144,6 @@ export const SOURCES = [
         },],
     },
 
-    {
-        key: 'frame',
-        label: 'Frame',
-        sourceFile: 'frame',
-        proxyParam: 'fr',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-    },
-
-    {
-        key: 'fsharetv',
-        label: 'FShareTV',
-        sourceFile: 'fsharetv',
-        proxyParam: 'fs',
-        timeout: 25000,
-        jitter: 600,
-        retries: 2,
-        multiUrl: false,
-        verifyHeaders: {
-            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.9',
-            Referer: 'https://fsharetv.cc',
-        },
-    },
-
-    {
-        key: 'fsonic',
-        label: 'Fsonic',
-        sourceFile: 'fsonic',
-        proxyParam: 'fn',
-        timeout: 35000,
-        jitter: 600,
-        retries: 1,
-        multiUrl: true,
-    },
-
     {
         key: 'fsonline',
         label: 'FSOnline',
@@ -259,16 +156,6 @@ export const SOURCES = [
         skipProxy: true,
     },
 
-    {
-        key: 'hexa',
-        label: 'Hexa',
-        sourceFile: 'hexa',
-        proxyParam: 'hx',
-        timeout: 20000,
-        jitter: 500,
-        retries: 2,
-    },
-
     {
         key: 'kisskh',
         label: 'KissKH',
@@ -304,44 +191,6 @@ export const SOURCES = [
         },
     },
 
-    {
-        key: 'luna-sub',
-        label: 'Luna (Sub)',
-        sourceFile: 'luna',
-        proxyParam: 'lusub',
-        subtype: 'sub',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-    },
-
-    {
-        key: 'luna-dub',
-        label: 'Luna (Dub)',
-        sourceFile: 'luna',
-        proxyParam: 'ludub',
-        subtype: 'dub',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-    },
-
-    {
-        key: 'meowtv',
-        label: 'MeowTV',
-        sourceFile: 'meowtv',
-        proxyParam: 'mt',
-        timeout: 20000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true
-    },
-
     {
         key: 'movienight',
         label: 'MovieNight',
@@ -380,18 +229,6 @@ export const SOURCES = [
         }],
     },
 
-    {
-        key: 'peestream',
-        label: 'PeeStream',
-        sourceFile: 'peestream',
-        proxyParam: 'pee',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-    },
-
     {
         key: 'pengu',
         label: 'Pengu',
@@ -456,26 +293,6 @@ export const SOURCES = [
             },
         }],
     },
-
-    {
-        key: 'vadapav',
-        label: 'Vadapav',
-        sourceFile: 'vadapav',
-        proxyParam: 'vp',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-        cdnHeaders: [{
-            pattern: /vadapav\.mov/i,
-            headers: {
-                Referer: 'https://stremio.vadapav.mov/',
-                Origin: 'https://stremio.vadapav.mov',
-            },
-        }],
-    },
-
     {
         key: 'vidapi',
         label: 'VidAPI',
@@ -489,23 +306,23 @@ export const SOURCES = [
 
     {
         key: 'vidcore',
+        label: 'VidCore',
         sourceFile: 'vidcore',
-        label: 'Vidcore',
         proxyParam: 'vc',
-        timeout: 30000,
+        timeout: 35000,
         jitter: 500,
-        retries: 2,
-        sourcesTimeout: 10000,
+        retries: 1,
+        multiUrl: true,
     },
-
     {
         key: 'vidfast',
-        label: 'Vidfast',
+        label: 'VidFast',
         sourceFile: 'vidfast',
         proxyParam: 'vf',
         timeout: 35000,
         jitter: 500,
         retries: 1,
+        multiUrl: true,
     },
 
     {
@@ -644,25 +461,6 @@ export const SOURCES = [
         },
     },
 
-    {
-        key: 'vuflix',
-        label: 'Vuflix',
-        sourceFile: 'vuflix',
-        proxyParam: 'vfx',
-        timeout: 25000,
-        jitter: 500,
-        retries: 2,
-        multiUrl: true,
-        skipProxy: true,
-        cdnHeaders: [{
-            pattern: /vuflix\.co/i,
-            headers: {
-                Referer: 'https://vuflix.co/',
-                Origin: 'https://vuflix.co',
-            },
-        }],
-    },
-
     {
         key: 'xdownloader',
         label: 'XDownloader',

package/src/sources/dulo.js

@@ -0,0 +1,150 @@
+import { getUA } from '../utils/helpers.js';
+
+const BASE_URL = 'https://dulo.mov';
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function resolveDetails(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();
+        const title = isTv ? data.name : data.title;
+        const releaseDate = isTv ? data.first_air_date : data.release_date;
+        const year = releaseDate ? releaseDate.split('-')[0] : '';
+        const runtime = isTv ? (data.episode_run_time?.[0] || 24) : (data.runtime || 90);
+        return { title, year, runtime };
+    } catch {
+        return null;
+    }
+}
+
+async function fetchSource(url, headers) {
+    try {
+        const res = await fetch(url, {
+            headers,
+            signal: AbortSignal.timeout(8000),
+        });
+        if (!res.ok) return null;
+        return await res.json();
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, sdk }) {
+    const isTv = Boolean(s && e);
+    const mediaType = isTv ? 'tv' : 'movie';
+    const ua = getUA();
+
+    const details = await resolveDetails(sdk, id, isTv);
+    const title = details?.title || '';
+    const year = details?.year || '';
+    const runtime = details?.runtime || '';
+
+    const referer = isTv
+        ? `${BASE_URL}/watch/tv/${id}/${s}/${e}`
+        : `${BASE_URL}/watch/movie/${id}`;
+
+    const defaultHeaders = {
+        'User-Agent': ua,
+        Referer: referer,
+        Origin: BASE_URL,
+        Accept: '*/*',
+        'Sec-Fetch-Dest': 'empty',
+        'Sec-Fetch-Mode': 'cors',
+        'Sec-Fetch-Site': 'same-origin',
+    };
+
+    const baseParams = new URLSearchParams({
+        tmdbId: String(id),
+        type: mediaType,
+    });
+
+    const additionalParams = new URLSearchParams({
+        tmdbId: String(id),
+        type: mediaType,
+        progressive: 'true',
+    });
+
+    if (title) additionalParams.set('title', title);
+    if (year) additionalParams.set('year', String(year));
+    if (runtime) additionalParams.set('runtime', String(runtime));
+
+    if (isTv) {
+        baseParams.set('season', String(s));
+        baseParams.set('episode', String(e));
+        additionalParams.set('season', String(s));
+        additionalParams.set('episode', String(e));
+    }
+
+    const endpoints = [
+        `${BASE_URL}/api/sources?${baseParams.toString()}`,
+        `${BASE_URL}/api/sources/willow?${baseParams.toString()}`,
+        `${BASE_URL}/api/sources/additional?${additionalParams.toString()}`,
+    ];
+
+    const seenUrls = new Set();
+    const allUrls = [];
+
+    let pendingUrls = [...endpoints];
+    const maxPollTime = Date.now() + 16000;
+
+    while (pendingUrls.length > 0 && Date.now() < maxPollTime) {
+        const results = await Promise.all(
+            pendingUrls.map((url) => fetchSource(url, defaultHeaders))
+        );
+
+        const nextPending = [];
+
+        results.forEach((data, index) => {
+            if (!data) return;
+
+            if (Array.isArray(data.sources) && data.sources.length > 0) {
+                for (const src of data.sources) {
+                    let streamUrl = String(src?.url || '').trim();
+                    if (!streamUrl) continue;
+
+                    if (streamUrl.startsWith('/')) {
+                        streamUrl = `${BASE_URL}${streamUrl}`;
+                    }
+
+                    if (!streamUrl.startsWith('http') || seenUrls.has(streamUrl)) continue;
+                    seenUrls.add(streamUrl);
+
+                    allUrls.push({
+                        url: streamUrl,
+                        label: src.label || 'Dulo',
+                        headers: {
+                            'User-Agent': ua,
+                            Referer: referer,
+                        },
+                        captions: Array.isArray(src.captions) ? src.captions : [],
+                    });
+                }
+            }
+
+            if (data.pending) {
+                nextPending.push(pendingUrls[index]);
+            }
+        });
+
+        pendingUrls = nextPending;
+        if (pendingUrls.length > 0) {
+            await sleep(1500);
+        }
+    }
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}

package/src/sources/streamaggregator.js

@@ -49,9 +49,9 @@ export async function getStream({ id, s, e, sdk }) {
             'User-Agent': ua,
             Referer: `${BASE_URL}/`,
             Origin: BASE_URL,
-            Accept: 'application/x-ndjson, text/plain, */*',
+            Accept: 'text/event-stream, application/x-ndjson, text/plain, */*',
         },
-        signal: AbortSignal.timeout(18000),
+        signal: AbortSignal.timeout(90000),
     });
 
     if (!res.ok) return null;
@@ -89,7 +89,9 @@ export async function getStream({ id, s, e, sdk }) {
 
     for (const line of lines) {
         try {
-            const item = JSON.parse(line);
+            const raw = line.startsWith('data:') ? line.slice(5).trim() : line;
+            if (!raw || raw === '[DONE]') continue;
+            const item = JSON.parse(raw);
             const streamUrl = String(item?.url || '').trim();
             if (!streamUrl || !streamUrl.startsWith('http') || seenUrls.has(streamUrl)) continue;
 

package/src/sources/vidcore.js

@@ -1,43 +1,123 @@
-import { fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
+import { getUA } from '../utils/helpers.js';
 
-const API_BASE = 'https://enc-dec.app/api';
-const HEADERS = { 'User-Agent': USER_AGENT, 'Referer': 'https://vidcore.net/', 'X-Requested-With': 'XMLHttpRequest' };
+const BASE_URL = 'https://vidcore.io';
+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',
+    };
 
-async function getDynamicServers(id, s, e) {
     try {
-        const html = await fetchText(s != null && e != null ? `https://vidcore.net/tv/${id}/${s}/${e}/` : `https://vidcore.net/movie/${id}/`, { headers: HEADERS });
+        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)\\":\\"(.*?)\\"/) || html.match(/"(?:en|token)":"(.*?)"/);
-        if (!match?.[1]) return null;
+        const match = html.match(/\\"(?:en|token)\\":\\"(.*?)\\"/);
+        if (!match || !match[1]) return null;
+        const enToken = match[1];
 
-        const encData = await fetchJson(`${API_BASE}/enc-vidcore?text=${encodeURIComponent(match[1])}`);
-        if (!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 decData = await fetchJson(`${API_BASE}/dec-vidcore`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: serversEncrypted }) });
-        return decData?.result ? { servers: decData.result, streamUrl, reqHeaders } : null;
-    } catch { return null; }
-}
+        const s1Res = await fetch(`${API}/enc-vidcore?text=${encodeURIComponent(enToken)}&stage=1`, {
+            signal: AbortSignal.timeout(8000),
+        });
+        const s1Data = await s1Res.json();
+        if (s1Data?.status !== 200 || !s1Data?.result?.stage1) return null;
 
-export async function getStream({ id, s, e }) {
-    const data = await getDynamicServers(id, s, e);
-    if (!data?.servers?.length) return null;
-    for (const srv of data.servers) {
-        try {
-            const streamEncrypted = await fetchText(`${data.streamUrl}/${srv.data}`, { method: 'POST', headers: data.reqHeaders });
-            const decData = await fetchJson(`${API_BASE}/dec-vidcore`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ text: streamEncrypted }) });
-            const url = decData?.result?.url;
-            if (url) {
-                const r = await fetch(url, { headers: { ...HEADERS, 'Range': 'bytes=0-511' }, signal: AbortSignal.timeout(5000) });
-                if (r.ok || r.status === 206) return { url, subtitles: (decData.result.captions || []).map(c => ({ url: c.file, lang: c.label || 'Unknown' })), headers: { ...HEADERS, 'Origin': 'https://vidcore.net' }, server: srv.name };
-            }
-        } catch { }
-    }
-    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-vidcore?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();
 
-export async function getSources(args) {
-    const data = await getDynamicServers(args.id, args.s, args.e);
-    return data?.servers ? data.servers.map(s => s.name) : [];
+        const decServersRes = await fetch(`${API}/dec-vidcore`, {
+            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-vidcore`, {
+                    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 || 'VidCore',
+                        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;
+    }
 }