@vyla-entertainment/sdk 1.9.0 → 1.11.0

package/src/sources/pstream.js

@@ -0,0 +1,68 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+async function safeImport(moduleName) {
+    try {
+        return await import(`./${moduleName}.js`);
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, clientIP, sdk } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+    const allUrls = [];
+
+    const providers = [
+        { name: 'CineSu', key: 'cinesu', fnName: 'fetchCineSuStreams' },
+        { name: 'ZxcStream', key: 'zxcstream', fnName: 'fetchZxcStreams' },
+        { name: 'VidFast', key: 'vidfast', fnName: 'fetchVidFastStreams' },
+        { name: '1Embed', key: '1embed', fnName: 'fetchOneEmbedStreams' },
+    ];
+
+    await Promise.all(
+        providers.map(async ({ name, key, fnName }) => {
+            try {
+                let streamResult = null;
+
+                if (sdk) {
+                    try {
+                        streamResult = await sdk.getStream(key, id, s, e, clientIP);
+                    } catch { }
+                }
+
+                if (!streamResult) {
+                    const mod = await safeImport(key);
+                    if (mod) {
+                        if (typeof mod.getStream === 'function') {
+                            streamResult = await mod.getStream(args);
+                        } else if (typeof mod[fnName] === 'function') {
+                            const raw = await mod[fnName]({ type, id, season: s, episode: e });
+                            if (Array.isArray(raw)) {
+                                streamResult = { allUrls: raw };
+                            }
+                        }
+                    }
+                }
+
+                if (!streamResult) return;
+
+                const streams = streamResult.allUrls || (streamResult.url ? [streamResult] : []);
+                for (const item of streams) {
+                    allUrls.push({
+                        url: item.url,
+                        server: `FlyStream (${item.source || item.server || name})`,
+                        quality: item.quality || 'Auto',
+                        type: item.type || item.format || (item.url?.includes('.m3u8') ? 'hls' : 'mp4'),
+                        headers: item.headers || {
+                            'User-Agent': USER_AGENT,
+                        },
+                    });
+                }
+            } catch { }
+        })
+    );
+
+    return allUrls.length ? { allUrls } : null;
+}

package/src/sources/rivestream.js

@@ -0,0 +1,179 @@
+// im being salty
+
+import { USER_AGENT, fetchJson } from '../utils/helpers.js';
+
+const C_ARRAY = [
+    '4Z7lUo', 'gwIVSMD', 'PLmz2elE2v', 'Z4OFV0', 'SZ6RZq6Zc', 'zhJEFYxrz8', 'FOm7b0', 'axHS3q4KDq', 'o9zuXQ', '4Aebt',
+    'wgjjWwKKx', 'rY4VIxqSN', 'kfjbnSo', '2DyrFA1M', 'YUixDM9B', 'JQvgEj0', 'mcuFx6JIek', 'eoTKe26gL', 'qaI9EVO1rB', '0xl33btZL',
+    '1fszuAU', 'a7jnHzst6P', 'wQuJkX', 'cBNhTJlEOf', 'KNcFWhDvgT', 'XipDGjST', 'PCZJlbHoyt', '2AYnMZkqd', 'HIpJh', 'KH0C3iztrG',
+    'W81hjts92', 'rJhAT', 'NON7LKoMQ', 'NMdY3nsKzI', 't4En5v', 'Qq5cOQ9H', 'Y9nwrp', 'VX5FYVfsf', 'cE5SJG', 'x1vj1',
+    'HegbLe', 'zJ3nmt4OA', 'gt7rxW57dq', 'clIE9b', 'jyJ9g', 'B5jXjMCSx', 'cOzZBZTV', 'FTXGy', 'Dfh1q1', 'ny9jqZ2POI',
+    'X2NnMn', 'MBtoyD', 'qz4Ilys7wB', '68lbOMye', '3YUJnmxp', '1fv5Imona', 'PlfvvXD7mA', 'ZarKfHCaPR', 'owORnX', 'dQP1YU',
+    'dVdkx', 'qgiK0E', 'cx9wQ', '5F9bGa', '7UjkKrp', 'Yvhrj', 'wYXez5Dg3', 'pG4GMU', 'MwMAu', 'rFRD5wlM'
+];
+
+const DEFAULT_SERVICES = [
+    'apex', 'pulse', 'solstice', 'quasar', 'horizon', 'primevids',
+    'flowcast', 'asiacloud', 'citadel', 'hindicast', 'guru'
+];
+
+function generateRiveSecretKey(e) {
+    if (e === undefined || e === null) return 'rive';
+    try {
+        let t, n;
+        const r = String(e);
+        if (isNaN(Number(e))) {
+            const sum = r.split('').reduce((acc, ch) => acc + ch.charCodeAt(0), 0);
+            t = C_ARRAY[sum % C_ARRAY.length] || Buffer.from(r).toString('base64');
+            n = Math.floor((sum % r.length) / 2);
+        } else {
+            const i = Number(e);
+            t = C_ARRAY[i % C_ARRAY.length] || Buffer.from(r).toString('base64');
+            n = Math.floor((i % r.length) / 2);
+        }
+        const i = r.slice(0, n) + t + r.slice(n);
+        const o = (function (str) {
+            const t = String(str);
+            let n = 3735928559 ^ t.length;
+            for (let e = 0; e < t.length; e++) {
+                const r = t.charCodeAt(e);
+                const rXor = (131 * e + 89 ^ (r << (e % 5))) & 255;
+                const r2 = r ^ rXor;
+                n = (((n << 7) | (n >>> 25)) >>> 0) ^ r2;
+                const idx = (65535 & n) * 60205;
+                const o2 = ((n >>> 16) * 60205) << 16;
+                n = (idx + o2) >>> 0;
+                n ^= n >>> 11;
+            }
+            n ^= n >>> 15;
+            n = ((65535 & n) * 49842 + (((n >>> 16) * 49842) << 16)) >>> 0;
+            n ^= n >>> 13;
+            n = ((65535 & n) * 40503 + (((n >>> 16) * 40503) << 16)) >>> 0;
+            n ^= n >>> 16;
+            n = ((65535 & n) * 10196 + (((n >>> 16) * 10196) << 16)) >>> 0;
+            return ((n ^= n >>> 15)).toString(16).padStart(8, '0');
+        })(
+            (function (str) {
+                const s = String(str);
+                let t = 0;
+                for (let n = 0; n < s.length; n++) {
+                    const r = s.charCodeAt(n);
+                    const i = (((t = (r + (t << 6) + (t << 16) - t) >>> 0) << (n % 5)) | (t >>> (32 - (n % 5)))) >>> 0;
+                    t ^= (i ^ ((r << (n % 7)) | (r >>> (8 - (n % 7))))) >>> 0;
+                    t = (t + ((t >>> 11) ^ (t << 3))) >>> 0;
+                }
+                t ^= t >>> 15;
+                t = ((65535 & t) * 49842 + ((((t >>> 16) * 49842) & 65535) << 16)) >>> 0;
+                t ^= t >>> 13;
+                t = ((65535 & t) * 40503 + ((((t >>> 16) * 40503) & 65535) << 16)) >>> 0;
+                return ((t ^= t >>> 16)).toString(16).padStart(8, '0');
+            })(i)
+        );
+        return Buffer.from(o, 'utf-8').toString('base64');
+    } catch {
+        return 'topSecret';
+    }
+}
+
+async function fetchRiveServices() {
+    try {
+        const secretKey = generateRiveSecretKey();
+        const url = `https://www.rivestream.app/api/backendfetch?requestID=VideoProviderServices&secretKey=${encodeURIComponent(secretKey)}`;
+        const res = await fetchJson(url, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Referer': 'https://www.rivestream.app/',
+                'Accept': 'application/json, text/plain, */*'
+            },
+            signal: AbortSignal.timeout(6000)
+        });
+        return Array.isArray(res?.data) && res.data.length ? res.data : DEFAULT_SERVICES;
+    } catch {
+        return DEFAULT_SERVICES;
+    }
+}
+
+async function fetchServiceStreams(service, isMovie, id, s, e, secretKey, referer) {
+    try {
+        const cb = (service === 'primevids' || service === 'citadel')
+            ? `&cb=${Math.floor(Date.now() / 3e6)}`
+            : '';
+
+        const reqID = isMovie ? 'movieVideoProvider' : 'tvVideoProvider';
+        const params = isMovie
+            ? `requestID=${reqID}&id=${encodeURIComponent(id)}&service=${service}${cb}&secretKey=${encodeURIComponent(secretKey)}`
+            : `requestID=${reqID}&id=${encodeURIComponent(id)}&season=${encodeURIComponent(s)}&episode=${encodeURIComponent(e)}&service=${service}${cb}&secretKey=${encodeURIComponent(secretKey)}`;
+
+        const url = `https://www.rivestream.app/api/backendfetch?${params}`;
+        const res = await fetchJson(url, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Referer': referer,
+                'Accept': 'application/json, text/plain, */*'
+            },
+            signal: AbortSignal.timeout(10000)
+        });
+
+        if (!res?.data?.sources || !Array.isArray(res.data.sources)) return [];
+
+        const streams = [];
+        for (const item of res.data.sources) {
+            if (!item || !item.url) continue;
+
+            const format = String(item.format || '').toLowerCase();
+            const urlStr = String(item.url || '').toLowerCase();
+            const isM3U8 = format === 'hls' || format === 'm3u8' || urlStr.includes('.m3u8') || urlStr.includes('.txt');
+
+            streams.push({
+                url: item.url,
+                server: `Rive (${item.source || service})`,
+                quality: String(item.quality || 'Auto'),
+                type: isM3U8 ? 'hls' : 'mp4',
+                headers: {
+                    'User-Agent': USER_AGENT,
+                    'Referer': referer
+                }
+            });
+        }
+        return streams;
+    } catch {
+        return [];
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, server } = args;
+    const isTv = s != null && e != null;
+    const isMovie = !isTv;
+
+    const secretKey = generateRiveSecretKey(id);
+    const referer = isMovie
+        ? `https://www.rivestream.app/watch?type=movie&id=${id}`
+        : `https://www.rivestream.app/watch?type=tv&id=${id}&season=${s}&episode=${e}`;
+
+    let services = await fetchRiveServices();
+
+    if (server && server !== 'all') {
+        const clean = server.toLowerCase().replace('rive (', '').replace(')', '').replace('rive', '').trim();
+        services = services.filter(srv => srv.toLowerCase().includes(clean));
+        if (!services.length) services = await fetchRiveServices();
+    }
+
+    const settled = await Promise.allSettled(
+        services.map(srv => fetchServiceStreams(srv, isMovie, id, s, e, secretKey, referer))
+    );
+
+    const allUrls = [];
+    for (const r of settled) {
+        if (r.status === 'fulfilled' && Array.isArray(r.value)) {
+            allUrls.push(...r.value);
+        }
+    }
+
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources() {
+    const services = await fetchRiveServices();
+    return services.map(s => `Rive (${s})`);
+}

package/src/sources/videasy.js

@@ -12,7 +12,9 @@ const SERVERS = [
     { id: 'superflix', name: 'Raze' }
 ];
 
-export async function getStream({ id, s, e, server, tmdbApiKey }) {
+export async function getStream({ id, s, e, server, sdk }) {
+    const tmdbApiKey = sdk?.tmdbApiKey || null;
+    if (!tmdbApiKey) return null;
     try {
         const isTv = s != null && e != null;
         const info = await getTmdbInfo(tmdbApiKey, id, isTv ? 'tv' : 'movie');

package/src/sources/vidgod.js

@@ -0,0 +1,147 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const REDIS_URL = 'https://vidnest-redis-fell-prism-rest.cloud.layerbase.dev/';
+const REDIS_AUTH = 'Bearer ve8z9XSKatu74M7FjLU8eQ29';
+const ORIGIN = 'https://vidgod.space';
+
+const SERVERS = [
+    {
+        name: 'Pulsar',
+        key: 'pulsar',
+        base: 'https://vidnest-extractor.vividdubbing.workers.dev/api',
+        serverParam: 'prime'
+    },
+    {
+        name: 'Orion',
+        key: 'orion',
+        base: 'https://404-vidnest.lofiserver.workers.dev/api',
+        serverParam: 'gama'
+    },
+    {
+        name: 'Stellar',
+        key: 'stellar',
+        base: 'https://404-vidnest.lofiserver.workers.dev/api',
+        serverParam: 'sigma'
+    }
+];
+
+function buildCacheKey(serverKey, type, id, s, e) {
+    const parts = [serverKey, type, id];
+    if (type === 'tv') {
+        parts.push(s || '1', e || '1');
+    }
+    return parts.join(':');
+}
+
+async function getFromCache(key) {
+    try {
+        const res = await fetch(REDIS_URL, {
+            method: 'POST',
+            headers: {
+                'Authorization': REDIS_AUTH,
+                'Content-Type': 'application/json',
+                'Accept': '*/*',
+                'Origin': ORIGIN,
+                'Referer': `${ORIGIN}/`,
+                'User-Agent': USER_AGENT
+            },
+            body: JSON.stringify(['GET', key]),
+            signal: AbortSignal.timeout(6000)
+        });
+
+        if (!res.ok) return null;
+        const data = await res.json();
+        if (!data || !data.result) return null;
+
+        const parsed = typeof data.result === 'string' ? JSON.parse(data.result) : data.result;
+        return parsed?.streams?.length ? parsed : null;
+    } catch {
+        return null;
+    }
+}
+
+async function fetchFromWorker(srv, type, id, s, e) {
+    try {
+        const endpoint = type === 'movie'
+            ? `${srv.base}/movie/${id}?server=${srv.serverParam}`
+            : `${srv.base}/tv/${id}/${s || '1'}/${e || '1'}?server=${srv.serverParam}`;
+
+        const res = await fetch(endpoint, {
+            headers: {
+                'Accept': 'application/json',
+                'Origin': ORIGIN,
+                'Referer': `${ORIGIN}/`,
+                'User-Agent': USER_AGENT
+            },
+            signal: AbortSignal.timeout(8000)
+        });
+
+        if (!res.ok) return null;
+        const data = await res.json();
+        return data?.streams?.length ? data : null;
+    } catch {
+        return null;
+    }
+}
+
+async function resolveServer(srv, type, id, s, e) {
+    const cacheKey = buildCacheKey(srv.key, type, id, s, e);
+    const cached = await getFromCache(cacheKey);
+    if (cached) return { server: srv.name, data: cached };
+
+    const live = await fetchFromWorker(srv, type, id, s, e);
+    if (live) return { server: srv.name, data: live };
+
+    return null;
+}
+
+export async function getStream(args) {
+    const { id, s, e, server } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+
+    let targets = SERVERS;
+    if (server && server !== 'all') {
+        const clean = server.toLowerCase().trim();
+        targets = SERVERS.filter(srv => srv.name.toLowerCase() === clean || srv.key.toLowerCase() === clean);
+        if (!targets.length) targets = SERVERS;
+    }
+
+    const settled = await Promise.allSettled(
+        targets.map(srv => resolveServer(srv, type, id, s, e))
+    );
+
+    const allUrls = [];
+
+    for (const r of settled) {
+        if (r.status !== 'fulfilled' || !r.value) continue;
+        const { server: serverName, data } = r.value;
+
+        for (const item of data.streams || []) {
+            if (!item || !item.url) continue;
+
+            const typeStr = String(item.type || '').toLowerCase();
+            const urlStr = String(item.url || '').toLowerCase();
+            const isM3U8 =
+                typeStr === 'hls' ||
+                typeStr === 'application/vnd.apple.mpegurl' ||
+                typeStr === 'cloudflare' ||
+                typeStr === 'tiktok' ||
+                urlStr.includes('.m3u8') ||
+                urlStr.includes('.txt');
+
+            allUrls.push({
+                url: item.url,
+                server: serverName,
+                quality: item.quality || 'Auto',
+                type: isM3U8 ? 'hls' : 'mp4',
+                headers: item.headers || {
+                    'User-Agent': USER_AGENT,
+                    'Referer': `${ORIGIN}/`
+                }
+            });
+        }
+    }
+
+    return allUrls.length ? { allUrls } : null;
+}

package/src/sources/vidnest.js

@@ -39,7 +39,9 @@ async function tmdbToAnilist(tmdbId, season) {
 
 const SERVER_KEYS = ['hollymoviehd', 'allmovies', 'catflix', 'purstream', 'lamda', 'vidlink', 'klikxxi'];
 
-export async function getStream({ id, s, e, tmdbApiKey, audio }) {
+export async function getStream({ id, s, e, sdk, audio }) {
+    const tmdbApiKey = sdk?.tmdbApiKey || null;
+    if (!tmdbApiKey) return null;
     if (s) {
         const k = tmdbApiKey;
         const showData = k ? await fetchJson(`https://api.themoviedb.org/3/tv/${id}?api_key=${k}`, { signal: AbortSignal.timeout(5000) }).catch(() => null) : null;

package/src/sources/vidvault.js

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