@vyla-entertainment/sdk 1.17.0 → 1.19.0

package/src/sources/flaxmovies.js

@@ -1,118 +1,106 @@
-import { USER_AGENT, fetchJson } from '../utils/helpers.js';
+import { fetchJson } from '../utils/helpers.js';
 
-const BASE_URL = 'https://flaxmovies.xyz';
+export async function getStream({ id, s, e }) {
+    const isTv = s != null && e != null;
+    const allUrls = [];
 
-async function getWorkerUrls(embedUrl) {
-    const foundUrls = [];
-    try {
-        const res = await fetch(embedUrl, {
-            headers: {
-                'User-Agent': USER_AGENT,
-                'Referer': `${BASE_URL}/`,
-                'Origin': BASE_URL
-            },
-            signal: AbortSignal.timeout(8000)
-        });
-        if (res.ok) {
-            const html = await res.text();
-            const directMatch = html.match(/WORKER_URL\s*[:=]\s*["'](https?:\/\/[^"']+)["']/i);
-            if (directMatch && directMatch[1]) {
-                foundUrls.push(directMatch[1].replace(/\/+$/, ''));
+    const endpoints = [
+        async () => {
+            const url = isTv
+                ? `https://themoviebox.uk/api/resolve?type=tv&id=${id}&season=${s}&episode=${e}`
+                : `https://themoviebox.uk/api/resolve?type=movie&id=${id}`;
+            const res = await fetchJson(url);
+            if (res?.success && Array.isArray(res.sources)) {
+                for (const item of res.sources) {
+                    const streamUrl = item.url || item.original_url;
+                    if (streamUrl) {
+                        allUrls.push({
+                            url: streamUrl,
+                            server: `TheMovieBox - ${item.server || item.provider || 'Server'}`,
+                            headers: {
+                                Referer: 'https://themoviebox.uk/',
+                                Origin: 'https://themoviebox.uk'
+                            }
+                        });
+                    }
+                }
             }
+        },
 
-            const scriptMatches = [...html.matchAll(/<script[^>]+src=["']([^"']+)["']/gi)];
-            for (const sm of scriptMatches) {
-                let scriptUrl = sm[1];
-                if (scriptUrl.startsWith('//')) scriptUrl = `https:${scriptUrl}`;
-                else if (scriptUrl.startsWith('/')) scriptUrl = `${BASE_URL}${scriptUrl}`;
-                else if (!scriptUrl.startsWith('http')) scriptUrl = `${BASE_URL}/${scriptUrl}`;
-
-                if (scriptUrl.includes('jsdelivr') || scriptUrl.includes('google') || scriptUrl.includes('cloudflare')) continue;
-
-                try {
-                    const sRes = await fetch(scriptUrl, {
-                        headers: { 'User-Agent': USER_AGENT, 'Referer': embedUrl },
-                        signal: AbortSignal.timeout(6000)
-                    });
-                    if (sRes.ok) {
-                        const sCode = await sRes.text();
-                        const m = sCode.match(/WORKER_URL\s*[:=]\s*["'](https?:\/\/[^"']+)["']/i);
-                        if (m && m[1]) {
-                            const wUrl = m[1].replace(/\/+$/, '');
-                            if (!foundUrls.includes(wUrl)) foundUrls.push(wUrl);
-                        }
+        async () => {
+            const url = isTv
+                ? `https://pro2.nabilekson.workers.dev/tv/${id}/${s}/${e}`
+                : `https://pro2.nabilekson.workers.dev/movie/${id}`;
+            const res = await fetchJson(url);
+            if (res?.success && Array.isArray(res.primarySources)) {
+                for (const item of res.primarySources) {
+                    const streamUrl = item.url || item.originalUrl;
+                    if (streamUrl) {
+                        allUrls.push({
+                            url: streamUrl,
+                            server: `CineBros - ${item.name || item.quality || 'Server'}`,
+                            headers: item.headers || {
+                                Referer: 'https://pro2.nabilekson.workers.dev/',
+                                Origin: 'https://pro2.nabilekson.workers.dev'
+                            }
+                        });
                     }
-                } catch { }
+                }
             }
-        }
-    } catch { }
-
-    const defaults = ['https://freakyniki.elaxo.lol', 'https://vidlove.nabilekson.workers.dev'];
-    for (const d of defaults) {
-        if (!foundUrls.includes(d)) foundUrls.push(d);
-    }
-    return foundUrls;
-}
-
-export async function getStream(args) {
-    const { id, s, e, server } = args;
-    const isTv = s != null && e != null;
-    const embedUrl = isTv
-        ? `${BASE_URL}/embed/tv/${id}/${s}/${e}`
-        : `${BASE_URL}/embed/movie/${id}`;
-
-    const workerUrls = await getWorkerUrls(embedUrl);
-    const query = isTv
-        ? `tmdb_id=${id}&tmdbId=${id}&season=${s}&episode=${e}`
-        : `tmdb_id=${id}&tmdbId=${id}`;
-
-    for (const worker of workerUrls) {
-        try {
-            const url = `${worker}/?${query}`;
-            const data = await fetchJson(url, {
-                headers: {
-                    'User-Agent': USER_AGENT,
-                    'Referer': `${BASE_URL}/`,
-                    'Origin': BASE_URL,
-                    'Accept': 'application/json, text/plain, */*'
-                },
-                signal: AbortSignal.timeout(12000)
-            });
+        },
 
-            if (data && Array.isArray(data.streams) && data.streams.length > 0) {
-                let allUrls = data.streams
-                    .filter(st => st && typeof st.url === 'string')
-                    .map(st => {
-                        const isHls = (st.format || '').toLowerCase().includes('hls') || st.url.includes('.m3u8');
-                        return {
-                            url: st.url,
-                            server: `FlaxMovies - ${st.provider || 'Default'}`,
-                            quality: st.resolution || 'Auto',
-                            type: isHls ? 'hls' : 'mp4',
-                            headers: {
-                                'User-Agent': USER_AGENT,
-                                'Referer': `${BASE_URL}/`,
-                                'Origin': BASE_URL
+        async () => {
+            const url = isTv
+                ? `https://praxi.nabilekson.workers.dev/tv/${id}/${s}/${e}`
+                : `https://praxi.nabilekson.workers.dev/movie/${id}`;
+            const res = await fetchJson(url);
+            if (res?.success && Array.isArray(res.primarySources)) {
+                for (const item of res.primarySources) {
+                    const streamUrl = item.url || item.originalUrl;
+                    if (streamUrl) {
+                        allUrls.push({
+                            url: streamUrl,
+                            server: `Praxi - ${item.name || item.providerName || 'Server'}`,
+                            headers: item.headers || {
+                                Referer: 'https://praxi.nabilekson.workers.dev/',
+                                Origin: 'https://praxi.nabilekson.workers.dev'
                             }
-                        };
-                    });
-
-                if (server && server !== 'all') {
-                    const clean = server.toLowerCase().replace('flaxmovies - ', '');
-                    const filtered = allUrls.filter(u => u.server.toLowerCase().includes(clean));
-                    if (filtered.length) allUrls = filtered;
+                        });
+                    }
                 }
+            }
+        },
 
-                if (allUrls.length) {
-                    return { allUrls };
+        async () => {
+            const url = isTv
+                ? `https://freakyniki.elaxo.lol/?tmdb_id=${id}&season=${s}&episode=${e}`
+                : `https://freakyniki.elaxo.lol/?tmdb_id=${id}`;
+            const res = await fetchJson(url);
+            if (Array.isArray(res?.streams)) {
+                for (const item of res.streams) {
+                    const streamUrl = item.url || item.raw_url;
+                    if (streamUrl) {
+                        allUrls.push({
+                            url: streamUrl,
+                            server: `FreakyNiki - ${item.server || item.provider || 'Server'}`,
+                            headers: {
+                                Referer: 'https://freakyniki.elaxo.lol/',
+                                Origin: 'https://freakyniki.elaxo.lol'
+                            }
+                        });
+                    }
                 }
             }
-        } catch { }
-    }
+        }
+    ];
+
+    await Promise.allSettled(endpoints.map(fn => fn().catch(() => { })));
 
-    return null;
-}
+    if (!allUrls.length) return null;
 
-export async function getSources() {
-    return ['FlaxMovies - Airflix', 'FlaxMovies - Xpass-VIP 1'];
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls
+    };
 }

package/src/sources/hexa.js

@@ -0,0 +1,54 @@
+import { fetchJson, fetchText } from '../utils/helpers.js';
+
+const API = "https://enc-dec.app/api";
+
+function getRandomHex(size = 32) {
+    const array = new Uint8Array(size);
+    crypto.getRandomValues(array);
+    return Array.from(array).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+export async function getStream({ id, s, e }) {
+    const isTv = s != null && e != null;
+    const key = getRandomHex(32);
+
+    const headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+        "Referer": "https://hexa.su/",
+        "Accept": "text/plain",
+        "X-Fingerprint-Lite": "e9136c41504646444",
+        "X-Api-Key": key
+    };
+
+    const encHexaRes = await fetchJson(`${API}/enc-hexa`);
+    if (!encHexaRes || encHexaRes.status !== 200) return null;
+    headers["X-Cap-Token"] = encHexaRes.result.token;
+
+    const url = isTv
+        ? `https://theemoviedb.hexa.su/api/tmdb/tv/${id}/season/${s}/episode/${e}/images`
+        : `https://theemoviedb.hexa.su/api/tmdb/movie/${id}/images`;
+
+    const encrypted = await fetchText(url, { headers });
+    if (!encrypted) return null;
+
+    const decRes = await fetchJson(`${API}/dec-hexa`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text: encrypted, key })
+    });
+
+    if (!decRes || decRes.status !== 200 || !decRes.result) return null;
+
+    const data = decRes.result;
+    const streamUrl = data.url || data.file || (Array.isArray(data.sources) ? data.sources[0]?.url : null);
+
+    if (!streamUrl) return null;
+
+    return {
+        url: streamUrl,
+        headers: {
+            Referer: "https://hexa.su/",
+            Origin: "https://hexa.su"
+        }
+    };
+}

package/src/sources/hyper.js

@@ -0,0 +1,36 @@
+import { fetchJson } from '../utils/helpers.js';
+
+export async function getStream({ id, s, e }) {
+    const isTv = s != null && e != null;
+    const path = isTv
+        ? `/local/stream/series/tmdb:${id}:${s}:${e}.json`
+        : `/local/stream/movie/tmdb:${id}.json`;
+
+    const url = `https://hyper.stravo.site${path}`;
+    const res = await fetchJson(url);
+    if (!res || !Array.isArray(res.streams)) return null;
+
+    const validStreams = res.streams.filter(item => {
+        if (!item.url || item.externalUrl) return false;
+        if (typeof item.title === 'string' && item.title.includes('🔒')) return false;
+        return true;
+    });
+
+    if (!validStreams.length) return null;
+
+    const allUrls = validStreams.map(item => ({
+        url: item.url,
+        server: `Hyper - ${item.title?.replace(/[^\x20-\x7E]+/g, '').trim() || 'Server'}`,
+        headers: item.behaviorHints?.proxyHeaders?.request || {
+            Referer: 'https://mzfi.me/',
+            Accept: '*/*'
+        },
+        skipProxy: item.behaviorHints?.notWebReady === false
+    }));
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls
+    };
+}

package/src/sources/kickassanime.js

@@ -0,0 +1,125 @@
+import { fetchJson, USER_AGENT } from '../utils/helpers.js';
+
+const BASE = "https://kaa.lt";
+const HLS_BASE = "https://hls.krussdomi.com/manifest";
+const HEADERS = { "User-Agent": USER_AGENT, Accept: "application/json" };
+
+async function kaaSearch(query) {
+    const res = await fetchJson(`${BASE}/api/fsearch`, {
+        method: "POST",
+        headers: { ...HEADERS, "Content-Type": "application/json" },
+        body: JSON.stringify({ page: 1, query }),
+    }).catch(() => null);
+    return Array.isArray(res?.result) ? res.result : [];
+}
+
+async function kaaShowInfo(showSlug) {
+    return fetchJson(`${BASE}/api/show/${showSlug}`, { headers: HEADERS }).catch(() => null);
+}
+
+async function kaaEpisodePage(showSlug, ep) {
+    return fetchJson(`${BASE}/api/show/${showSlug}/episodes?ep=${ep}&lang=ja-JP`, { headers: HEADERS }).catch(() => null);
+}
+
+async function kaaAllEpisodes(showSlug) {
+    const first = await kaaEpisodePage(showSlug, 1);
+    if (!first) return [];
+    const pages = Array.isArray(first.pages) ? first.pages : [];
+    const all = Array.isArray(first.result) ? [...first.result] : [];
+
+    if (pages.length > 1) {
+        const rest = await Promise.all(
+            pages.slice(1).map(async (pg) => {
+                const startEp = pg.eps?.[0];
+                if (!startEp) return [];
+                const d = await kaaEpisodePage(showSlug, startEp);
+                return Array.isArray(d?.result) ? d.result : [];
+            })
+        );
+        for (const batch of rest) all.push(...batch);
+    }
+
+    return all;
+}
+
+async function kaaEpisodeServers(showSlug, fullEpSlug) {
+    return fetchJson(`${BASE}/api/show/${showSlug}/episode/${fullEpSlug}`, { headers: HEADERS }).catch(() => null);
+}
+
+export async function getStream({ id, s, e, tmdbApiKey, sdk }) {
+    try {
+        const apiKey = tmdbApiKey || sdk?.tmdbApiKey || process.env.TMDB_API_KEY || '45dbdd5e714da212424bda0336167447';
+        const isTv = !!s;
+        const mediaType = isTv ? 'tv' : 'movie';
+        const epNum = e ? Number(e) : 1;
+
+        let titles = [];
+        try {
+            const tmdbRes = await fetchJson(`https://api.themoviedb.org/3/${mediaType}/${id}?api_key=${apiKey}&append_to_response=alternative_titles`);
+            if (tmdbRes) {
+                const primary = tmdbRes.title || tmdbRes.name;
+                const original = tmdbRes.original_title || tmdbRes.original_name;
+                if (primary) titles.push(primary);
+                if (original && !titles.includes(original)) titles.push(original);
+
+                const alts = tmdbRes.alternative_titles?.titles || tmdbRes.alternative_titles?.results || [];
+                for (const alt of alts) {
+                    const candidate = alt.title || alt.name;
+                    if (candidate && !titles.includes(candidate)) {
+                        titles.push(candidate);
+                    }
+                }
+            }
+        } catch { }
+
+        if (!titles.length) return null;
+
+        let showSlug = null;
+        for (const title of titles) {
+            const results = await kaaSearch(title);
+            if (results.length) {
+                showSlug = results[0].slug;
+                break;
+            }
+        }
+
+        if (!showSlug) return null;
+
+        const showInfo = await kaaShowInfo(showSlug);
+        let fullEpSlug = null;
+
+        if (showInfo?.type === "movie") {
+            const m = (showInfo.watch_uri || "").match(/\/(ep-(\d+)-([a-f0-9]+))$/i);
+            if (m) fullEpSlug = m[1];
+        } else {
+            const episodes = await kaaAllEpisodes(showSlug);
+            const epItem = episodes.find((item) => item.episode_number === epNum);
+            if (epItem) fullEpSlug = `ep-${epItem.episode_number}-${epItem.slug}`;
+        }
+
+        if (!fullEpSlug) return null;
+
+        const episodeData = await kaaEpisodeServers(showSlug, fullEpSlug);
+        const servers = Array.isArray(episodeData?.servers) ? episodeData.servers : [];
+
+        const urls = [];
+        for (const srv of servers) {
+            if (!srv.src) continue;
+            const m = srv.src.match(/[?&]id=([^&]+)/);
+            if (m) {
+                urls.push({
+                    url: `${HLS_BASE}/${m[1]}/master.m3u8`,
+                    server: `KickAssAnime (${srv.name || 'Server'})`,
+                });
+            }
+        }
+
+        return urls.length ? { allUrls: urls } : null;
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getSources() {
+    return ['KickAssAnime'];
+}

package/src/sources/lmscript.js

@@ -1,43 +1,71 @@
 import { getTmdbInfo } from '../utils/helpers.js';
 
 export async function getStream(args) {
-    const { id, s, e, tmdbApiKey } = args;
+    const { id, s, e, tmdbApiKey, sdk } = args;
     const type = (s != null && e != null) ? 'tv' : 'movie';
+    const apiKey = tmdbApiKey || sdk?.tmdbApiKey || process.env.TMDB_API_KEY || '45dbdd5e714da212424bda0336167447';
 
     try {
-        const tmdbInfo = await getTmdbInfo(tmdbApiKey, id, type, s);
-        const name = tmdbInfo.titles[0] || '';
-        if (!name) return null;
-
         if (type === 'tv') {
             return null;
-        } else {
-            const url = `https://lmscript.xyz/v1/movies?filters[q]=${encodeURIComponent(name)}&expand=streams`;
+        }
+
+        const tmdbInfo = await getTmdbInfo(apiKey, id, type, s);
+        const titles = tmdbInfo?.titles || [];
+        if (!titles.length) return null;
+
+        let movie = null;
+        for (const title of titles) {
+            const url = `https://lmscript.xyz/v1/movies?filters[q]=${encodeURIComponent(title)}&expand=streams`;
             const response = await fetch(url);
+            if (!response.ok) continue;
             const data = await response.json();
 
-            const movie = data.items?.find(item => `${item.tmdb_prefix}` === `${id}` || `${item.tmdb_id}` === `${id}`);
-            if (!movie) return null;
+            const found = data.items?.find(item => {
+                const tmdbPrefixMatch = `${item.tmdb_prefix}` === `${id}`;
+                const tmdbIdMatch = `${item.tmdb_id}` === `${id}`;
+                const titleMatch = item.title?.toLowerCase() === title.toLowerCase();
+                return tmdbPrefixMatch || tmdbIdMatch || titleMatch;
+            });
+
+            if (found) {
+                movie = found;
+                break;
+            }
+        }
 
-            const streams = movie.streams || {};
-            const SOURCE_ORDER = ["1080p", "720p", "480p", "360p"];
-            const sortedStreams = Object.keys(streams).sort((a, b) => SOURCE_ORDER.indexOf(a) - SOURCE_ORDER.indexOf(b));
+        if (!movie) return null;
 
-            if (!sortedStreams.length) return null;
+        const streams = movie.streams || {};
+        const SOURCE_ORDER = ["1080p", "720p", "480p", "360p"];
+        const sortedStreams = Object.keys(streams).sort((a, b) => {
+            const indexA = SOURCE_ORDER.indexOf(a);
+            const indexB = SOURCE_ORDER.indexOf(b);
+            return (indexA === -1 ? 99 : indexA) - (indexB === -1 ? 99 : indexB);
+        });
 
-            const allUrls = sortedStreams.map(quality => {
-                const streamUrl = streams[quality];
-                return {
-                    url: streamUrl,
-                    quality,
-                    type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
-                    headers: {}
-                };
-            });
+        if (!sortedStreams.length) return null;
 
-            return { allUrls };
-        }
-    } catch (err) {
+        const allUrls = sortedStreams.map(quality => {
+            const streamUrl = streams[quality];
+            return {
+                url: streamUrl,
+                quality,
+                server: `LMScript - ${quality}`,
+                type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                headers: {
+                    Referer: 'https://lookmovie2.to/',
+                    Origin: 'https://lookmovie2.to'
+                }
+            };
+        });
+
+        return {
+            url: allUrls[0].url,
+            headers: allUrls[0].headers,
+            allUrls
+        };
+    } catch {
         return null;
     }
 }