@vyla-entertainment/sdk 1.0.0

package/src/sources/meowtv.js

@@ -0,0 +1,111 @@
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const API_BASE = 'https://api.meowtv.ru';
+const REFERER = 'https://meowtv.ru/';
+const ENC_DEC_API = 'https://enc-dec.app/api/dec-meowtv';
+
+const HEADERS = {
+    'User-Agent': USER_AGENT,
+    'Accept': 'application/json',
+    'Referer': REFERER,
+    'Origin': 'https://meowtv.ru',
+    'Accept-Language': 'en-US,en;q=0.9'
+};
+
+const SERVERS = [
+    'pseudo',
+    'lynx',
+    'tik',
+    'ipcloud',
+    'v4:English',
+    'turkce',
+    'v5:Hindi',
+    'v4:Hindi',
+    'v6:Hindi'
+];
+
+const TIMEOUT_MS = 15000;
+
+export const VERIFY_HEADERS = { 'User-Agent': USER_AGENT, 'Referer': REFERER, 'Origin': 'https://meowtv.ru' };
+
+async function decryptPayload(payload) {
+    try {
+        const response = await fetchJson(ENC_DEC_API, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ data: payload })
+        });
+
+        if (response?.status !== 200 || !response?.result) {
+            return null;
+        }
+
+        return typeof response.result === 'string' ? JSON.parse(response.result) : response.result;
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, server }) {
+    try {
+        const isTv = !!s;
+        let targets = SERVERS;
+        if (server && server !== 'all') {
+            const cleanName = server.replace('MeowTV - ', '');
+            targets = SERVERS.includes(cleanName) ? [cleanName] : [targets[0]];
+        }
+
+        const results = await Promise.all(targets.map(async srv => {
+            try {
+                return await Promise.race([
+                    (async () => {
+                        const path = isTv
+                            ? `/streams/tv/${id}/${s}/${e}?s=${encodeURIComponent(srv)}`
+                            : `/streams/movie/${id}?s=${encodeURIComponent(srv)}`;
+
+                        const payload = await fetchJson(`${API_BASE}${path}`, {
+                            headers: HEADERS
+                        });
+
+                        if (!payload) return null;
+
+                        const data = await decryptPayload(payload);
+                        if (!data) return null;
+
+                        const urls = [];
+                        if (data?.url?.startsWith('http')) {
+                            urls.push({
+                                url: data.url,
+                                server: `MeowTV - ${srv}`,
+                            });
+                        }
+
+                        if (Array.isArray(data?.streams)) {
+                            for (const stream of data.streams) {
+                                if (stream?.url?.startsWith('http')) {
+                                    urls.push({
+                                        url: stream.url,
+                                        server: `MeowTV - ${srv} (${stream.language || 'Unknown'})`,
+                                    });
+                                }
+                            }
+                        }
+                        return urls;
+                    })(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout exceeded')), TIMEOUT_MS))
+                ]);
+            } catch (err) {
+                return null;
+            }
+        }));
+
+        const allUrls = results.filter(Boolean).flat();
+        return allUrls.length ? { allUrls } : null;
+    } catch (e) {
+        return null;
+    }
+}
+
+export async function getSources() {
+    return SERVERS.map(s => `MeowTV - ${s}`);
+}

package/src/sources/nebula.js

@@ -0,0 +1,62 @@
+import { fetchJson } from '../utils/helpers.js';
+
+const BASE_URL = 'https://nebula.work.gd/private/7f6b9d179ba7ecd77a39520e';
+
+async function getImdbId(tmdbApiKey, tmdbId, s, e) {
+    const key = tmdbApiKey;
+    if (!key) return null;
+    try {
+        const type = s != null && e != null ? 'tv' : 'movie';
+        const url = `https://api.themoviedb.org/3/${type}/${tmdbId}/external_ids?api_key=${key}`;
+        const res = await fetchJson(url);
+        return res?.imdb_id || null;
+    } catch(err) {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, tmdbApiKey }) {
+    try {
+        const imdbId = await getImdbId(tmdbApiKey, id, s, e);
+        if (!imdbId) return null;
+
+        const path = s != null && e != null
+            ? `/stream/series/${imdbId}:${s}:${e}.json`
+            : `/stream/movie/${imdbId}.json`;
+
+        const response = await fetch(`${BASE_URL}${path}`, {
+            headers: {
+                'Accept': 'application/json'
+            },
+            signal: AbortSignal.timeout(15000)
+        });
+
+        if (!response.ok) return null;
+
+        const data = await response.json();
+        if (!data?.streams?.length) return null;
+
+        const allUrls = data.streams
+            .filter(stream => stream.url && stream.url.trim() !== '' && !stream.url.includes('hubcloud'))
+            .map(stream => {
+                const headers = stream.behaviorHints?.proxyHeaders?.request || {};
+
+                let serverName = stream.name || 'Unknown';
+                if (serverName.includes('\n')) serverName = serverName.split('\n')[0];
+
+                const filename = stream.filename || stream.behaviorHints?.filename;
+                if (filename) serverName += ` - ${filename}`;
+
+                return {
+                    url: stream.url,
+                    server: `Nebula - ${serverName}`,
+                    type: stream.url.includes('.m3u8') ? 'hls' : 'mp4',
+                    headers: Object.keys(headers).length > 0 ? headers : undefined,
+                    skipProxy: stream.behaviorHints?.notWebReady === false
+                };
+            }).filter(Boolean);
+        return allUrls.length ? { allUrls } : null;
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/nekowatch.js

@@ -0,0 +1,57 @@
+import { fetchJson, fetchText, getTmdbInfo, tmdbToAnilist } from '../utils/helpers.js';
+
+const BASE_URL = "https://nekowatch.xyz";
+const ANIME_JS_URL = `${BASE_URL}/js/anime.js?v=v263_fast_player_start`;
+const FALLBACK_ORDER = ['kiwi', 'ally', 'bee', 'arc', 'anikoto', 'jet', 'bonk', 'moo', 'hop', 'pulsar', 'pahe'];
+
+let providerOrderCache = null, providerOrderTs = 0;
+
+async function getProviderOrder() {
+    const now = Date.now();
+    if (providerOrderCache && now - providerOrderTs < 1800000) return providerOrderCache;
+    try {
+        const js = await fetchText(ANIME_JS_URL, { signal: AbortSignal.timeout(6000) });
+        const match = js.match(/PROVIDER_ORDER\s*=\s*\[([\s\S]*?)\]/);
+        if (match) {
+            const order = [...match[1].matchAll(/['"]([a-z0-9_]+)['"]/gi)].map(m => m[1]);
+            if (order.length) { providerOrderCache = order; providerOrderTs = now; return order; }
+        }
+    } catch { }
+    return providerOrderCache || FALLBACK_ORDER;
+}
+
+export async function getStream({ id, s, e, audio }) {
+    try {
+        const info = await getTmdbInfo(id, s ? 'tv' : 'movie', s);
+        if (!info || !info.isAnime) return null;
+        const anilistId = await tmdbToAnilist(id, s ? 'tv' : 'movie', s, info.titles, info.year);
+        if (!anilistId) return null;
+        const ep = e || 1;
+        const audiosToTry = audio === "all" ? ["sub", "dub"] : (audio === "dub" ? ["dub", "sub"] : ["sub", "dub"]);
+        const providerOrder = await getProviderOrder();
+        for (const aud of audiosToTry) {
+            const results = await Promise.allSettled(providerOrder.map(p => fetchJson(`${BASE_URL}/api/anime/watch/${p}/${anilistId}/${aud}/${p}-${ep}`, { signal: AbortSignal.timeout(8000) })));
+            const allUrls = [], seenActual = new Set();
+            for (const r of results) {
+                if (r.status !== 'fulfilled' || !r.value) continue;
+                const data = r.value;
+                let streams = [], actual = data.attempted?.actualProvider || data.provider;
+                if (Array.isArray(data.streams)) streams = data.streams;
+                else {
+                    for (const key of Object.keys(data)) if (data[key] && Array.isArray(data[key].streams)) { streams.push(...data[key].streams); if (!actual) actual = data[key].provider || key; }
+                }
+                if (!streams.length) continue;
+                if (actual) { if (seenActual.has(actual)) continue; seenActual.add(actual); }
+                const valid = streams.filter(st => st.type === "hls" && st.url).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+                for (const st of valid) allUrls.push({ url: st.url, type: "hls", audio: aud, server: st.server ? `NekoWatch-${st.server}` : "NekoWatch", headers: st.referer ? { Referer: st.referer } : undefined, skipProxy: /\.workers\.dev(\/|$)/i.test(st.url) });
+            }
+            if (allUrls.length) return { allUrls };
+        }
+        return null;
+    } catch { return null; }
+}
+
+export async function getSources(args) {
+    const stream = await getStream(args);
+    return stream?.allUrls ? [...new Set(stream.allUrls.map(u => u.server))] : [];
+}

package/src/sources/opstream.js

@@ -0,0 +1,123 @@
+import { getTmdbInfo, USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = 'https://opstream.fun';
+const API_BASE = `${BASE_URL}/api/resolve`;
+
+const API_HEADERS = {
+    'User-Agent': USER_AGENT,
+    'Accept': 'application/x-ndjson; charset=utf-8',
+    'Referer': `${BASE_URL}/`,
+    'Origin': BASE_URL,
+};
+
+const STREAM_HEADERS = {
+    'User-Agent': USER_AGENT,
+    'Referer': `${BASE_URL}/`,
+    'Origin': BASE_URL,
+};
+
+export async function getStream({ id, s, e }) {
+    try {
+        const isTv = s != null && e != null;
+        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+        
+        if (!info?.titles?.length || !info.imdbId) return null;
+
+        const params = new URLSearchParams({
+            type: isTv ? 'tv' : 'movie',
+            tmdbId: id,
+            title: info.titles[0],
+            year: info.year || '',
+            imdbId: info.imdbId,
+            progress: '1'
+        });
+
+        if (isTv) {
+            params.append('season', s);
+            params.append('episode', e);
+        }
+
+        const res = await fetch(`${API_BASE}?${params}`, { 
+            headers: API_HEADERS, 
+            signal: AbortSignal.timeout(15000) 
+        });
+        
+        if (!res.ok) return null;
+
+        const text = await res.text();
+        const lines = text.split('\n');
+        
+        let streamData = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            try {
+                const json = JSON.parse(trimmed);
+                if (json.t === 'done' && json.data) {
+                    streamData = json.data;
+                    break;
+                }
+            } catch { continue; }
+        }
+
+        if (!streamData) return null;
+
+        const subtitles = (streamData.captions || []).map(c => ({
+            url: c.url.startsWith('http') ? c.url : `${BASE_URL}${c.url}`,
+            lang: c.label || 'Unknown'
+        }));
+
+        const allUrls = [];
+
+        if (streamData.qualities && streamData.qualities.length > 0) {
+            for (const q of streamData.qualities) {
+                let finalUrl = q.url;
+                if (!finalUrl.startsWith('http')) {
+                    finalUrl = `${BASE_URL}${finalUrl}`;
+                }
+
+                const isDash = finalUrl.includes('.mpd');
+                const isHls = finalUrl.includes('.m3u8');
+
+                allUrls.push({
+                    url: finalUrl,
+                    server: `OpStream - ${q.label}`,
+                    type: isDash ? 'dash' : (isHls ? 'hls' : 'mp4'),
+                    headers: STREAM_HEADERS,
+                    subtitles,
+                    skipProxy: true
+                });
+            }
+        } else if (streamData.url) {
+            let finalUrl = streamData.url;
+            if (finalUrl.includes('?u=')) {
+                try {
+                    const uParam = new URL(finalUrl, BASE_URL).searchParams.get('u');
+                    if (uParam) finalUrl = Buffer.from(uParam, 'base64').toString('utf8');
+                } catch {}
+            } else if (!finalUrl.startsWith('http')) {
+                finalUrl = `${BASE_URL}${finalUrl}`;
+            }
+
+            const isDash = streamData.kind === 'dash' || finalUrl.includes('.mpd');
+            const isHls = streamData.kind === 'hls' || finalUrl.includes('.m3u8');
+
+            allUrls.push({
+                url: finalUrl,
+                server: 'OpStream',
+                type: isDash ? 'dash' : (isHls ? 'hls' : 'mp4'),
+                headers: STREAM_HEADERS,
+                subtitles,
+                skipProxy: true
+            });
+        }
+
+        if (allUrls.length === 0) return null;
+
+        return { allUrls };
+    } catch { return null; }
+}
+
+export async function getSources() {
+    return ['OpStream'];
+}

package/src/sources/peachify.js

@@ -0,0 +1,78 @@
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const DEC_API = "https://enc-dec.app/api/dec-peachify";
+const ORIGIN = "https://peachify.top";
+const HEADERS = { "User-Agent": USER_AGENT, "Origin": ORIGIN, "Referer": `${ORIGIN}/` };
+
+const SERVERS = [
+    { label: "Wolf", path: "air", api: "https://usa.eat-peach.sbs" },
+    { label: "Spider", path: "holly", api: "https://usa.eat-peach.sbs" },
+    { label: "Iron", path: "moviebox", api: "https://uwu.eat-peach.sbs" },
+    { label: "Multi", path: "multi", api: "https://usa.eat-peach.sbs" },
+    { label: "Dark", path: "net", api: "https://uwu.eat-peach.sbs" },
+];
+
+export async function getStream({ id, s, e, server }) {
+    try {
+        const isTv = s != null && e != null;
+        const segment = isTv ? `tv/${id}/${s}/${e}` : `movie/${id}`;
+
+        let targets = SERVERS;
+        if (server && server !== 'all') {
+            const cleanName = server.replace('Peachify - ', '');
+            targets = SERVERS.filter(srv => srv.label === cleanName);
+            if (!targets.length) targets = SERVERS;
+        }
+
+        const settled = await Promise.allSettled(targets.map(async srv => {
+            const url = `${srv.api}/${srv.path}/${segment}`;
+            const rawData = await fetchJson(url, { headers: HEADERS, signal: AbortSignal.timeout(10000) });
+
+            if (!rawData?.data) throw new Error();
+
+            const decJson = await fetchJson(DEC_API, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ text: rawData.data }),
+                signal: AbortSignal.timeout(10000)
+            });
+
+            if (decJson.status !== 200 || !decJson.result) throw new Error();
+            const res = decJson.result;
+
+            const sources = Array.isArray(res) ? res : (res.sources || [res]);
+            const subs = res.subtitles || [];
+
+            return sources.map(source => {
+                const streamUrl = source.url || source.file || source.link;
+                if (!streamUrl) return null;
+
+                return {
+                    url: streamUrl,
+                    server: `Peachify - ${srv.label}`,
+                    quality: source.quality || "Auto",
+                    type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                    headers: { ...HEADERS, "Origin": ORIGIN },
+                    subtitles: subs.map(sub => ({
+                        url: sub.url || sub.file,
+                        lang: sub.language || sub.lang || sub.label || 'Unknown'
+                    })),
+                    skipProxy: false,
+                    skipVerify: true,
+                    skipHlsCheck: true
+                };
+            }).filter(Boolean);
+        }));
+
+        const allUrls = [];
+        for (const r of settled) {
+            if (r.status === 'fulfilled' && r.value) allUrls.push(...r.value);
+        }
+
+        return allUrls.length ? { allUrls } : null;
+    } catch { return null; }
+}
+
+export async function getSources() {
+    return SERVERS.map(s => `Peachify - ${s.label}`);
+}

package/src/sources/pengu.js

@@ -0,0 +1,45 @@
+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}`;
+
+async function getImdbId(tmdbApiKey, tmdbId, s, e) {
+    const key = tmdbApiKey;
+    if (!key) return null;
+    try {
+        const url = s != null && e != null
+            ? `https://api.themoviedb.org/3/tv/${tmdbId}/external_ids?api_key=${key}`
+            : `https://api.themoviedb.org/3/movie/${tmdbId}?api_key=${key}`;
+        const res = await fetchJson(url);
+        return res?.imdb_id || null;
+    } catch { return null; }
+}
+
+export async function getStream({ id, s, e, tmdbApiKey }) {
+    try {
+        const imdbId = await getImdbId(tmdbApiKey, id, s, e);
+        if (!imdbId) return null;
+
+        const path = s != null && e != null
+            ? `/stream/series/${imdbId}:${s}:${e}.json`
+            : `/stream/movie/${imdbId}.json`;
+
+        const res = await fetchJson(`${BASE_URL}${path}`);
+        if (!res?.streams?.length) return null;
+
+        const allUrls = res.streams.map(stream => {
+            if (!stream.url) return null;
+            const headers = stream.behaviorHints?.proxyHeaders?.request || {};
+            return {
+                url: stream.url,
+                server: `Pengu - ${stream.name || 'Server'}`,
+                headers: Object.keys(headers).length > 0 ? headers : undefined,
+                skipProxy: stream.behaviorHints?.notWebReady === false
+            };
+        }).filter(Boolean);
+
+        return allUrls.length ? { allUrls } : null;
+    } catch {
+        return null;
+    }
+}

package/src/sources/purstream.js

@@ -0,0 +1,104 @@
+import { fetchJson, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
+
+const DOMAIN = 'https://purstream.club';
+const API_BASE = 'https://api.purstream.club/api/v1';
+
+const HEADERS = {
+    'User-Agent': USER_AGENT,
+    'Accept': 'application/json, text/plain, */*',
+    'Referer': `${DOMAIN}/`,
+    'Origin': DOMAIN,
+    'X-Requested-With': 'XMLHttpRequest',
+    'Sec-Fetch-Dest': 'empty',
+    'Sec-Fetch-Mode': 'cors',
+    'Sec-Fetch-Site': 'same-site'
+};
+
+export async function getStream({ id, s, e }) {
+    try {
+        const isTv = s != null;
+
+        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+
+
+        if (!info?.titles?.length) {
+            return null;
+        }
+
+        const title = info.titles[0];
+
+        const searchUrl = `${API_BASE}/search-bar/search/${encodeURIComponent(title)}`;
+
+        const searchData = await fetchJson(searchUrl, {
+            headers: HEADERS,
+            signal: AbortSignal.timeout(10000)
+        });
+
+        const items = searchData?.data?.items?.movies?.items || [];
+
+        const type = isTv ? 'tv' : 'movie';
+        const lowerTitle = title.toLowerCase();
+
+        let match = items.find(item =>
+            item.type === type &&
+            item.title?.toLowerCase() === lowerTitle &&
+            (!info.year || item.release_date?.startsWith(String(info.year)))
+        );
+
+        if (!match) {
+            match = items.find(item => item.type === type);
+        }
+
+        if (!match?.id) {
+            return null;
+        }
+
+        const streamUrl = isTv
+            ? `${API_BASE}/stream/${match.id}/episode?season=${s}&episode=${e}`
+            : `${API_BASE}/stream/${match.id}`;
+
+        const json = await fetchJson(streamUrl, {
+            headers: HEADERS,
+            signal: AbortSignal.timeout(10000)
+        });
+
+        const sources = json?.data?.items?.sources;
+
+        if (json?.type !== 'success' || !Array.isArray(sources) || !sources.length) {
+            return null;
+        }
+
+        const chosen = sources.find(src => src.stream_url);
+
+        if (!chosen?.stream_url) {
+            return null;
+        }
+
+        const result = {
+            url: chosen.stream_url,
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Referer': `${DOMAIN}/`
+            },
+            server: 'purstream',
+            quality: chosen.source_name || 'Auto',
+            type: chosen.format || 'hls',
+            skipProxy: true
+        };
+
+        return result;
+
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getSources(args) {
+    const stream = await getStream(args);
+
+    return stream ? [stream] : [];
+}
+
+export const VERIFY_HEADERS = {
+    ...HEADERS
+};