@vyla-entertainment/sdk 1.8.0 → 1.10.0

package/src/sources/peestream.js

@@ -0,0 +1,122 @@
+import { USER_AGENT, fetchJson, getTmdbInfo } from '../utils/helpers.js';
+
+const BASE_URL = 'https://providers.peestream.in';
+
+export async function getStream(args) {
+    const { id, s, e, server, tmdbApiKey } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+
+    let title = args.title || '';
+    let releaseYear = args.year || '';
+    let imdbId = args.imdbId || '';
+
+    if (!title) {
+        try {
+            const info = await getTmdbInfo(id, type, s, tmdbApiKey);
+            if (info) {
+                title = info.title || '';
+                if (info.year) releaseYear = info.year;
+                if (info.imdbId) imdbId = info.imdbId;
+            }
+        } catch { }
+    }
+
+    const queryParams = new URLSearchParams({
+        type,
+        tmdbId: String(id),
+        title: title || String(id)
+    });
+    if (releaseYear) queryParams.set('releaseYear', String(releaseYear));
+    if (imdbId) queryParams.set('imdbId', String(imdbId));
+    if (isTv) {
+        queryParams.set('season', String(s));
+        queryParams.set('episode', String(e));
+    }
+
+    const allUrls = [];
+
+    try {
+        const scrapeUrl = `${BASE_URL}/scrape?${queryParams.toString()}`;
+        const res = await fetch(scrapeUrl, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Accept': 'text/event-stream',
+                'Referer': `${BASE_URL}/`
+            },
+            signal: AbortSignal.timeout(15000)
+        });
+
+        if (res.ok) {
+            const text = await res.text();
+            const events = text.split('\n\n');
+            for (const ev of events) {
+                if (ev.includes('event: completed')) {
+                    const dataMatch = ev.match(/data:\s*(.+)/);
+                    if (dataMatch) {
+                        try {
+                            const parsed = JSON.parse(dataMatch[1].trim());
+                            const stream = parsed.stream;
+                            const streamUrl = stream?.playlist || stream?.url || stream?.file;
+                            if (streamUrl) {
+                                allUrls.push({
+                                    url: streamUrl,
+                                    server: `PeeStream - ${parsed.sourceId || 'Poseidon'}`,
+                                    quality: 'Auto',
+                                    type: stream.type === 'hls' || streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                                    headers: stream.headers || {
+                                        'User-Agent': USER_AGENT
+                                    }
+                                });
+                            }
+                        } catch { }
+                    }
+                }
+            }
+        }
+    } catch { }
+
+    if (!allUrls.length) {
+        try {
+            const searchUrl = `${BASE_URL}/api/search?q=${encodeURIComponent(title || id)}&type=${type}&tmdbId=${id}${isTv ? `&season=${s}&episode=${e}` : ''}`;
+            const data = await fetchJson(searchUrl, {
+                headers: {
+                    'User-Agent': USER_AGENT,
+                    'Accept': 'application/json',
+                    'Referer': `${BASE_URL}/`
+                },
+                signal: AbortSignal.timeout(10000)
+            });
+
+            if (data && Array.isArray(data.results)) {
+                for (const result of data.results) {
+                    const pName = result.providerName || result.provider || 'PeeStream';
+                    for (const stream of result.streams || []) {
+                        if (!stream || !stream.url) continue;
+                        allUrls.push({
+                            url: stream.url,
+                            server: `PeeStream - ${stream.name || pName}`,
+                            quality: stream.quality || 'Auto',
+                            type: stream.type === 'm3u8' || stream.url.includes('.m3u8') ? 'hls' : 'mp4',
+                            headers: stream.headers || {
+                                'User-Agent': USER_AGENT
+                            }
+                        });
+                    }
+                }
+            }
+        } catch { }
+    }
+
+    if (server && server !== 'all') {
+        const clean = server.toLowerCase().replace('peestream - ', '');
+        const filtered = allUrls.filter(u => u.server.toLowerCase().includes(clean));
+        if (filtered.length) return { allUrls: filtered };
+    }
+
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources() {
+    return ['PeeStream - vaplayer'];
+}

package/src/sources/pengu.js

@@ -1,7 +1,7 @@
 import { fetchJson } from '../utils/helpers.js';
 
-const PENGU_CONFIG = '%7B%22source_4khdhub%22%3A%22on%22%2C%22source_moviebox%22%3A%22on%22%2C%22source_moviesdrives%22%3A%22on%22%2C%22source_vaplayer%22%3A%22on%22%2C%22source_hdghartv%22%3A%22on%22%2C%22res_2160%22%3A%22on%22%2C%22res_1080%22%3A%22on%22%2C%22res_720%22%3A%22on%22%2C%22disable_direct%22%3A%22on%22%7D';
-const BASE_URL = `https://pengu.uk/${PENGU_CONFIG}`;
+// const PENGU_CONFIG = '%7B%22source_4khdhub%22%3A%22on%22%2C%22source_moviebox%22%3A%22on%22%2C%22source_moviesdrives%22%3A%22on%22%2C%22source_vaplayer%22%3A%22on%22%2C%22source_hdghartv%22%3A%22on%22%2C%22res_2160%22%3A%22on%22%2C%22res_1080%22%3A%22on%22%2C%22res_720%22%3A%22on%22%2C%22disable_direct%22%3A%22on%22%7D';
+// const BASE_URL = `https://pengu.uk/${PENGU_CONFIG}`;
 
 async function getImdbId(tmdbApiKey, tmdbId, s, e) {
     const key = tmdbApiKey;
@@ -15,7 +15,12 @@ async function getImdbId(tmdbApiKey, tmdbId, s, e) {
     } catch { return null; }
 }
 
-export async function getStream({ id, s, e, tmdbApiKey }) {
+export async function getStream({ id, s, e, sdk }) {
+    const tmdbApiKey = sdk?.tmdbApiKey || null;
+    const manifest = sdk?.penguManifest || null;
+    if (!tmdbApiKey || !manifest || (manifest && !manifest.endsWith('manifest.json'))) return null;
+    const BASE_URL = manifest ? manifest.split('/manifest.json')[0] : null;
+    if (!BASE_URL) return null;
     try {
         const imdbId = await getImdbId(tmdbApiKey, id, s, e);
         if (!imdbId) return 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;