@vyla-entertainment/sdk 1.0.0 → 1.2.0

package/src/sources/anineko.js

@@ -1,4 +1,4 @@
-import { getTmdbInfo } from '../utils/helpers.js';
+import { getTmdbInfo, USER_AGENT, fetchText } from '../utils/helpers.js';
 
 const BASE_URL = "https://anineko.to";
 
@@ -10,7 +10,10 @@ function decodeEntities(str) {
 
 async function search(query) {
     try {
-        const html = await fetchText(`${BASE_URL}/browser?keyword=${encodeURIComponent(query)}`, { signal: AbortSignal.timeout(6000) });
+        const html = await fetchText(`${BASE_URL}/browser?keyword=${encodeURIComponent(query)}`, {
+            headers: { 'User-Agent': USER_AGENT },
+            signal: AbortSignal.timeout(6000)
+        });
         const results = [];
         let idx = 0;
         while ((idx = html.indexOf('nv-anime-thumb', idx)) !== -1) {
@@ -27,40 +30,144 @@ async function search(query) {
             }
             idx += 14;
         }
+        if (results.length === 0) {
+            const linkMatches = [...html.matchAll(/href=["']\/watch\/([^"']+)["']/gi)];
+            for (const match of linkMatches) {
+                if (!results.find(r => r.slug === match[1])) {
+                    const linkIdx = html.indexOf(match[0]);
+                    const titleStart = html.lastIndexOf('>', linkIdx);
+                    const titleEnd = html.indexOf('<', linkIdx);
+                    if (titleStart !== -1 && titleEnd !== -1 && titleEnd > linkIdx) {
+                        const title = html.slice(titleStart + 1, Math.min(titleEnd, linkIdx + 200)).trim();
+                        if (title.length > 2 && title.length < 100) {
+                            results.push({ slug: match[1], text: title });
+                        }
+                    }
+                }
+            }
+        }
         return results;
     } catch { return []; }
 }
 
 async function extractHls(embedUrl) {
     try {
-        const html = await fetchText(embedUrl, { headers: { Referer: `${BASE_URL}/` }, signal: AbortSignal.timeout(6000) });
-        const m = html.match(/const\s+src\s*=\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) || html.match(/file\s*:\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) || html.match(/["'](https?:\/\/[^"']+\/master\.m3u8[^"']*)["']/i) || html.match(/["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i);
+        const html = await fetchText(embedUrl, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                Referer: `${BASE_URL}/`
+            },
+            signal: AbortSignal.timeout(6000)
+        });
+        const m = html.match(/const\s+src\s*=\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) ||
+            html.match(/file\s*:\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) ||
+            html.match(/["'](https?:\/\/[^"']+\/master\.m3u8[^"']*)["']/i) ||
+            html.match(/["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i) ||
+            html.match(/src:\s*["'](https?:\/\/[^"']+\.m3u8[^"']*)["']/i);
         if (m) return decodeEntities(m[1]);
     } catch { }
     return null;
 }
 
-export async function getStream({ id, s, e, audio }) {
+export async function getStream({ id, s, e, audio, tmdbApiKey }) {
     try {
-        const info = await getTmdbInfo(id, s ? 'tv' : 'movie', s);
+        const info = await getTmdbInfo(tmdbApiKey, id, s ? 'tv' : 'movie', s);
         if (!info || !info.isAnime) return null;
         let seriesSlug = null;
         for (const title of info.titles) {
-            const results = await search(title);
-            const targetClean = cleanTitle(title);
-            for (const r of results) if (cleanTitle(r.text) === targetClean || r.text.toLowerCase().includes(title.toLowerCase())) { seriesSlug = r.slug; break; }
-            if (seriesSlug) break;
+            const potentialSlug = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+            if (!potentialSlug) continue;
+            try {
+                const checkHtml = await fetchText(`${BASE_URL}/watch/${potentialSlug}/ep-${e || 1}`, {
+                    headers: { 'User-Agent': USER_AGENT, Referer: `${BASE_URL}/watch/${potentialSlug}` },
+                    signal: AbortSignal.timeout(4000)
+                });
+                if (checkHtml && checkHtml.includes('nv-watch-page')) {
+                    seriesSlug = potentialSlug;
+                    break;
+                }
+            } catch {}
+        }
+
+        if (!seriesSlug) {
+            for (const title of info.titles) {
+                const results = await search(title);
+                const targetClean = cleanTitle(title);
+
+                const exactSlugMatch = results.find(r => {
+                    const slugClean = cleanTitle(r.slug);
+                    return slugClean === targetClean || r.slug === targetClean;
+                });
+
+                if (exactSlugMatch) {
+                    seriesSlug = exactSlugMatch.slug;
+                    break;
+                }
+
+                const sortedResults = [...results].sort((a, b) => a.slug.length - b.slug.length);
+
+                for (const r of sortedResults) {
+                    const resultClean = cleanTitle(r.text);
+                    const isExactMatch = resultClean === targetClean;
+                    const isCloseMatch = r.text.toLowerCase().includes(title.toLowerCase());
+                    if (isExactMatch || isCloseMatch) {
+                        seriesSlug = r.slug;
+                        break;
+                    }
+                }
+                if (seriesSlug) break;
+            }
         }
         if (!seriesSlug && info.titles.length) {
             const fSearch = await search(info.titles[0]);
-            if (fSearch.length) seriesSlug = fSearch[0].slug;
+            const sortedResults = [...fSearch].sort((a, b) => a.slug.length - b.slug.length);
+            if (sortedResults.length) seriesSlug = sortedResults[0].slug;
         }
         if (!seriesSlug) return null;
-        const watchHtml = await fetchText(`${BASE_URL}/watch/${seriesSlug}/ep-${e || 1}`, { headers: { Referer: `${BASE_URL}/watch/${seriesSlug}` }, signal: AbortSignal.timeout(6000) });
+        const watchHtml = await fetchText(`${BASE_URL}/watch/${seriesSlug}/ep-${e || 1}`, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                Referer: `${BASE_URL}/watch/${seriesSlug}`
+            },
+            signal: AbortSignal.timeout(6000)
+        });
         const byAudio = { sub: [], dub: [] };
-        for (const panel of watchHtml.matchAll(/<div\b[^>]*class=["'][^"']*nv-server-grid[^"']*["'][^>]*data-id=["']([^"']+)["'][^>]*>([\s\S]*?)(?=<div\b[^>]*class=["'][^"']*nv-server-grid|$)/gi)) {
-            const panelAudio = panel[1].toLowerCase().includes("dub") ? "dub" : "sub";
-            for (const btn of panel[2].matchAll(/data-video=["']([^"']+)["']/gi)) byAudio[panelAudio].push(decodeEntities(btn[1]));
+
+        const iframeMatch = watchHtml.match(/<iframe[^>]*src=["']([^"']+)["'][^>]*>/i);
+        if (iframeMatch) {
+            const iframeSrc = decodeEntities(iframeMatch[1]);
+            const hls = await extractHls(iframeSrc);
+            if (hls) {
+                const audioType = audio === 'dub' ? 'dub' : 'sub';
+                byAudio[audioType].push(iframeSrc);
+            }
+        }
+
+        if (byAudio.sub.length === 0 && byAudio.dub.length === 0) {
+            const tabMatches = [...watchHtml.matchAll(/<button[^>]*class=["'][^"']*nv-server-tab[^"']*["'][^>]*data-id=["']([^"']+)["'][^>]*>/gi)];
+            const tabMap = {};
+            for (const match of tabMatches) {
+                const tabId = match[1].toLowerCase();
+                const tabClassMatch = match[0].match(/class=["'][^"']*(tab_\d+)[^"']/i);
+                if (tabClassMatch) {
+                    const tabClass = tabClassMatch[1];
+                    tabMap[tabClass] = tabId.includes('dub') ? 'dub' : 'sub';
+                }
+            }
+
+            const btnRegex = /<button\s+[^>]*class=["'][^"']*server-video[^"']*["'][^>]*>/gi;
+            const btnMatches = [...watchHtml.matchAll(btnRegex)];
+            for (const match of btnMatches) {
+                const btnHtml = match[0];
+                const videoMatch = btnHtml.match(/data-video=["']([^"']+)["']/i);
+                const tabMatch = btnHtml.match(/data-tab=["']([^"']+)["']/i);
+                if (videoMatch && tabMatch) {
+                    const videoUrl = decodeEntities(videoMatch[1]);
+                    const tabClass = tabMatch[1];
+                    const audioType = tabMap[tabClass] || 'sub';
+                    byAudio[audioType].push(videoUrl);
+                }
+            }
         }
         const audiosToTry = audio === "all" ? ["sub", "dub"] : (audio === "dub" ? ["dub", "sub"] : ["sub", "dub"]);
         const allUrls = [];

package/src/sources/cinejoy.js

@@ -0,0 +1,210 @@
+import crypto from "crypto";
+
+export const ID = "cinejoy";
+export const DOMAIN = "https://cinejoy.to";
+export const API_DOMAIN = "https://api.shegu.st";
+export const ENC_DEC_API = "https://enc-dec.app/api";
+export const RETURN_ALL_URLS = true;
+
+const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36";
+
+function countLeadingZeroBits(buffer) {
+    let count = 0;
+    for (const value of buffer) {
+        if (value === 0) {
+            count += 8;
+            continue;
+        }
+        count += 8 - value.toString(2).length;
+        break;
+    }
+    return count;
+}
+
+function solveChallenge(data) {
+    const saltStr = `pow2-salt|${data.s}|${data.b}`;
+    const salt = crypto.createHash("sha256").update(saltStr).digest();
+    const n = data.n;
+    const r = data.r;
+    const p = data.p;
+    const d = data.d;
+    const b = data.b;
+    const s = data.s;
+
+    for (let counter = 0; counter < 1000000; counter++) {
+        const payload = `pow2|${b}|${s}|${counter}`;
+        const result = crypto.scryptSync(payload, salt, 32, {
+            N: n,
+            r: r,
+            p: p,
+            maxmem: 128 * n * r * 2
+        });
+
+        if (countLeadingZeroBits(result) >= d) {
+            const solved = { ...data, c: counter };
+            return Buffer.from(JSON.stringify(solved)).toString("base64");
+        }
+    }
+    throw new Error("Challenge solve failed");
+}
+
+async function getTmdbMetadata(tmdbId, isTv) {
+    const apiKey = process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? "tv" : "movie";
+    try {
+        const url = `https://api.themoviedb.org/3/${type}/${tmdbId}?api_key=${apiKey}&append_to_response=external_ids`;
+        const res = await fetch(url, { signal: AbortSignal.timeout(10000) });
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const year = isTv ? (data.first_air_date ? data.first_air_date.split("-")[0] : "") : (data.release_date ? data.release_date.split("-")[0] : "");
+        const imdbId = data.external_ids?.imdb_id || "";
+        return { title, year, imdbId };
+    } catch (err) {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, clientIP }) {
+    try {
+        const isTv = s && e && s !== "null" && e !== "null";
+        const meta = await getTmdbMetadata(id, isTv);
+        if (!meta) return null;
+
+        let servers = [];
+        try {
+            const serverRes = await fetch(`${API_DOMAIN}/servers`, {
+                headers: {
+                    "Origin": DOMAIN,
+                    "Referer": DOMAIN + "/",
+                    "User-Agent": UA
+                },
+                signal: AbortSignal.timeout(15000)
+            });
+            if (serverRes.ok) {
+                const data = await serverRes.json();
+                servers = data.servers || [];
+            }
+        } catch (err) { }
+
+        const activeServers = servers
+            .filter(srv => srv.status === "ok" && srv.name)
+            .map(srv => srv.name);
+
+        if (activeServers.length === 0) return null;
+
+        const allUrls = [];
+
+        for (const serverName of activeServers) {
+            try {
+                const queryParts = [
+                    `title=${encodeURIComponent(meta.title)}`,
+                    `type=${isTv ? "series" : "movie"}`,
+                    `year=${meta.year}`,
+                    `imdb=${meta.imdbId}`,
+                    `tmdb=${id}`,
+                    `server=${serverName}`
+                ];
+                if (isTv) {
+                    queryParts.push(`season=${s}`, `episode=${e}`);
+                }
+
+                const plainUrl = `${API_DOMAIN}/?${queryParts.join("&")}`;
+
+                const encRes = await fetch(`${ENC_DEC_API}/enc-cinejoy?url=${encodeURIComponent(plainUrl)}`, {
+                    headers: { "User-Agent": UA },
+                    signal: AbortSignal.timeout(15000)
+                });
+                if (!encRes.ok) continue;
+                const encData = await encRes.json();
+                if (encData.status !== 200) continue;
+
+                const rid = encData.result;
+
+                const challengeRes = await fetch(`${API_DOMAIN}/challenge?rid=${rid}`, {
+                    headers: {
+                        "Origin": DOMAIN,
+                        "Referer": DOMAIN + "/",
+                        "User-Agent": UA
+                    },
+                    signal: AbortSignal.timeout(30000)
+                });
+                if (!challengeRes.ok) continue;
+
+                const challengeData = await challengeRes.json();
+
+                const solved = solveChallenge(challengeData);
+
+                const streamRes = await fetch(`${API_DOMAIN}/${rid}`, {
+                    headers: {
+                        "Origin": DOMAIN,
+                        "Referer": DOMAIN + "/",
+                        "User-Agent": UA,
+                        "X-At": solved
+                    },
+                    signal: AbortSignal.timeout(30000)
+                });
+
+                if (!streamRes.ok) continue;
+
+                const encryptedText = await streamRes.text();
+
+                const decRes = await fetch(`${ENC_DEC_API}/dec-cinejoy`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "User-Agent": UA
+                    },
+                    body: JSON.stringify({ text: encryptedText }),
+                    signal: AbortSignal.timeout(15000)
+                });
+                if (!decRes.ok) continue;
+                const decData = await decRes.json();
+                if (decData.status !== 200) continue;
+
+                let decryptedText = decData.result;
+
+                if (!decryptedText) continue;
+
+                if (typeof decryptedText === "string") {
+                    try {
+                        decryptedText = JSON.parse(decryptedText);
+                    } catch (e) { }
+                }
+
+                let streamUrl = "";
+                if (decryptedText && typeof decryptedText === "object") {
+                    if (decryptedText.stream && decryptedText.stream[0]) {
+                        streamUrl = decryptedText.stream[0].playlist || decryptedText.stream[0].url || "";
+                    } else {
+                        streamUrl = decryptedText.url || decryptedText.playlist || decryptedText.file || "";
+                    }
+                } else if (typeof decryptedText === "string") {
+                    streamUrl = decryptedText.trim();
+                }
+
+                if (streamUrl.startsWith("http")) {
+                    allUrls.push({
+                        url: streamUrl,
+                        headers: {
+                            "User-Agent": UA,
+                            "Referer": DOMAIN + "/",
+                            "Origin": DOMAIN
+                        },
+                        server: serverName,
+                        quality: "Auto",
+                        type: "hls",
+                        skipVerify: true,
+                        skipProxy: true
+                    });
+                }
+            } catch (err) { }
+        }
+
+        if (allUrls.length > 0) {
+            return { ...allUrls[0], allUrls };
+        }
+    } catch (err) { }
+    return null;
+}

package/src/sources/flaxmovies.js

@@ -1,14 +1,118 @@
-import { fetchJson } from '../utils/helpers.js';
+import { USER_AGENT, fetchJson } from '../utils/helpers.js';
 
-const API_BASE = 'https://itjiocunahckqxcnzpoy.supabase.co/functions/v1';
-const APIKEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Iml0amlvY3VuYWhja3F4Y256cG95Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzczMzM1MjQsImV4cCI6MjA5MjkwOTUyNH0.9x9ykdHAzrv_GSvnawPeQaOxQeh3sZg0QAh4u9VOF4M';
-const HEADERS = { 'apikey': APIKEY, 'authorization': `Bearer ${APIKEY}`, 'content-type': 'application/json', 'origin': 'https://flaxmovies.xyz', 'referer': 'https://flaxmovies.xyz/' };
+const BASE_URL = 'https://flaxmovies.xyz';
 
-export async function getStream({ id, s, e }) {
+async function getWorkerUrls(embedUrl) {
+    const foundUrls = [];
     try {
-        const isMovie = !s;
-        const data = await fetchJson(isMovie ? `${API_BASE}/get-movie` : `${API_BASE}/get-tv`, { method: 'POST', headers: HEADERS, body: JSON.stringify(isMovie ? { id: String(id) } : { id: String(id), season: Number(s), episode: Number(e) }), signal: AbortSignal.timeout(15000) });
-        if (!data?.signed_url) return null;
-        return { allUrls: [{ url: data.signed_url, headers: { 'Referer': 'https://flaxmovies.xyz/', 'Origin': 'https://flaxmovies.xyz' } }] };
-    } catch { return null; }
+        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 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);
+                        }
+                    }
+                } 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
+                            }
+                        };
+                    });
+
+                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 };
+                }
+            }
+        } catch { }
+    }
+
+    return null;
+}
+
+export async function getSources() {
+    return ['FlaxMovies - Airflix', 'FlaxMovies - Xpass-VIP 1'];
 }

package/src/sources/frame.js

@@ -0,0 +1,88 @@
+import { USER_AGENT, fetchJson } from '../utils/helpers.js';
+
+const BASE_URL = 'https://api.peestream.in';
+
+const PROVIDERS = [
+    { id: 'vaplayer', name: 'FRAME Zephyr' },
+    { id: 'castle', name: 'FRAME Atlas' },
+    { id: 'hera', name: 'FRAME Luna' },
+    { id: 'multivid', name: 'FRAME Volt' },
+    { id: 'netmirror', name: 'FRAME Echo' },
+    { id: 'vidsuper-castle', name: 'FRAME Rift' },
+    { id: 'vidsuper-vixsrc', name: 'FRAME Quill' }
+];
+
+async function fetchProviderStreams(provider, type, id, s, e) {
+    try {
+        const queryParams = new URLSearchParams({
+            q: String(id),
+            type,
+            provider: provider.id
+        });
+        if (type === 'tv') {
+            queryParams.set('season', String(s));
+            queryParams.set('episode', String(e));
+        }
+
+        const url = `${BASE_URL}/api/search?${queryParams.toString()}`;
+        const data = await fetchJson(url, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Accept': 'application/json',
+                'Referer': 'https://peestream.in/'
+            },
+            signal: AbortSignal.timeout(12000)
+        });
+
+        if (!data || !Array.isArray(data.results) || !data.results.length) return [];
+
+        const streams = [];
+        for (const result of data.results) {
+            for (const stream of result.streams || []) {
+                if (!stream || !stream.url) continue;
+                streams.push({
+                    url: stream.url,
+                    server: provider.name,
+                    quality: stream.quality || 'Auto',
+                    type: stream.type === 'm3u8' || stream.url.includes('.m3u8') ? 'hls' : 'mp4',
+                    headers: stream.headers || {
+                        'User-Agent': USER_AGENT
+                    }
+                });
+            }
+        }
+        return streams;
+    } catch {
+        return [];
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, server } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+
+    let targets = PROVIDERS;
+    if (server && server !== 'all') {
+        const clean = server.toLowerCase().replace('frame ', '').trim();
+        targets = PROVIDERS.filter(p => p.id.toLowerCase() === clean || p.name.toLowerCase().includes(clean));
+        if (!targets.length) targets = PROVIDERS;
+    }
+
+    const settled = await Promise.allSettled(
+        targets.map(p => fetchProviderStreams(p, type, id, s, e))
+    );
+
+    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() {
+    return PROVIDERS.map(p => p.name);
+}

package/src/sources/fsonic.js

@@ -4,10 +4,10 @@ const BASE_URL = 'https://www.fsonic.net';
 const FSHARE_BASE = 'https://fsharetv.co';
 const HEADERS = { 'User-Agent': USER_AGENT, 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'en-US,en;q=0.9' };
 
-export async function getStream({ id, s }) {
+export async function getStream({ id, s, tmdbApiKey }) {
     if (s != null) return null;
     try {
-        const info = await getTmdbInfo(id, 'movie');
+        const info = await getTmdbInfo(tmdbApiKey, id, 'movie');
         if (!info?.titles?.length) return null;
         let watchSlug = null;
         for (const title of info.titles) {

package/src/sources/fsonline.js

@@ -4,10 +4,10 @@ const ORIGIN = 'https://www3.fsonline.app';
 const AJAX_URL = `${ORIGIN}/wp-admin/admin-ajax.php`;
 const HEADERS = { 'User-Agent': USER_AGENT, 'Origin': ORIGIN, 'Referer': `${ORIGIN}/` };
 
-export async function getStream({ id, s, e }) {
+export async function getStream({ id, s, e, tmdbApiKey }) {
     try {
         const isTv = s != null && e != null;
-        const info = await getTmdbInfo(id, isTv ? 'tv' : 'movie');
+        const info = await getTmdbInfo(tmdbApiKey, id, isTv ? 'tv' : 'movie');
         if (!info?.titles?.length) return null;
         const searchHtml = await fetchText(`${ORIGIN}/?s=${encodeURIComponent(info.titles[0] + (info.year ? ' ' + info.year : ''))}`, { headers: HEADERS });
         const typeFolder = isTv ? 'seriale' : 'film';