@vyla-entertainment/sdk 1.5.0 → 1.8.0

package/src/sources/vixsrc.js

@@ -13,7 +13,11 @@ const HEADERS = {
 function extract(regex, text) {
     const m = text?.match(regex);
     if (!m) return null;
-    return m[1].replace(/\\/g, '');
+    let val = m[1];
+    val = val.replace(/\\u0026/gi, '&');
+    val = val.replace(/\\\//g, '/');
+    val = val.replace(/\\/g, '');
+    return val;
 }
 
 export async function getStream({ id, s, e, absoluteBase }) {
@@ -22,36 +26,40 @@ export async function getStream({ id, s, e, absoluteBase }) {
             ? `${BASE_URL}/api/tv/${id}/${s}/${e}`
             : `${BASE_URL}/api/movie/${id}`;
 
-        const apiProxy = absoluteBase
+        const apiProxy = absoluteBase && absoluteBase !== '/'
             ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(apiUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify(HEADERS))}`
             : apiUrl;
 
-        const apiText = await fetchText(apiProxy).catch(() => null);
+        const apiText = await fetchText(apiProxy, { headers: HEADERS }).catch(() => null);
         const apiData = JSON.parse(apiText || '{}');
         if (!apiData.src) return null;
 
         const embedUrl = apiData.src.startsWith('http') ? apiData.src : `${BASE_URL}${apiData.src}`;
-        const embedProxy = absoluteBase
+        const embedProxy = absoluteBase && absoluteBase !== '/'
             ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(embedUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify(HEADERS))}`
             : embedUrl;
 
-        const html = await fetchText(embedProxy).catch(() => null);
+        const html = await fetchText(embedProxy, { headers: HEADERS }).catch(() => null);
         if (!html) return null;
 
         const token = extract(/token["']\s*:\s*["']([^"']+)/, html);
         const expires = extract(/expires["']\s*:\s*["']([^"']+)/, html);
         let playlist = extract(/url["']\s*:\s*["']([^"']+)/, html);
+
         if (!token || !expires || !playlist) return null;
 
-        playlist = playlist.replace(/\\/g, '');
+        if (playlist.startsWith('/')) {
+            playlist = `${BASE_URL}${playlist}`;
+        }
+
         const lang = extract(/lang(?:uage)?["']\s*:\s*["']([a-z]{2,5})/i, html) || 'en';
         const rawMasterUrl = `${playlist}${playlist.includes('?') ? '&' : '?'}token=${token}&expires=${expires}&h=1&lang=${lang}`;
 
-        const masterProxy = absoluteBase
-            ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(rawMasterUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify(HEADERS))}`
+        const masterProxy = absoluteBase && absoluteBase !== '/'
+            ? `${absoluteBase.replace(/^https:\/\/(localhost|127\.0\.0\.1)/, 'http://$1')}/api?url=${encodeURIComponent(rawMasterUrl)}&proxyHeaders=${encodeURIComponent(JSON.stringify({ ...HEADERS, Referer: embedUrl }))}`
             : rawMasterUrl;
 
-        const playlistText = await fetchText(rawMasterUrl, { headers: HEADERS }).catch(() => null);
+        const playlistText = await fetchText(masterProxy, { headers: { ...HEADERS, 'Referer': embedUrl } }).catch(() => null);
         if (!playlistText?.includes('#EXTM3U')) return null;
 
         let finalUrl = null;
@@ -74,17 +82,23 @@ export async function getStream({ id, s, e, absoluteBase }) {
         if (!finalUrl) finalUrl = rawMasterUrl;
 
         if (!finalUrl.startsWith('http')) {
-            const base = rawMasterUrl.split('/playlist/')[0];
-            finalUrl = finalUrl.startsWith('/') ? `${base}${finalUrl}` : `${base}/${finalUrl}`;
+            const baseMatch = rawMasterUrl.match(/^(https?:\/\/[^\/]+)/);
+            const base = baseMatch ? baseMatch[1] : BASE_URL;
+            if (finalUrl.startsWith('/')) {
+                finalUrl = `${base}${finalUrl}`;
+            } else {
+                const pathParts = rawMasterUrl.split('/');
+                pathParts.pop();
+                finalUrl = `${pathParts.join('/')}/${finalUrl}`;
+            }
         }
 
-        const alreadyProxied = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/api\?url=/.test(finalUrl);
-
         return {
             allUrls: [
                 {
                     url: finalUrl,
-                    skipProxy: alreadyProxied,
+                    server: 'VixSrc',
+                    skipProxy: true,
                     headers: {
                         ...HEADERS,
                         'Referer': `${BASE_URL}/`

package/src/utils/helpers.js

@@ -67,8 +67,7 @@ function cacheGet(cache, key) {
 
 function cacheSet(cache, key, val, ttl) { cache.set(key, { val, ts: Date.now(), ttl }); }
 
-export async function createStreamArgs(source, tmdbApiKey, id, s, e, clientIP=null) {
-    const getAbsoluteBase = host => (host.startsWith('localhost') || host.startsWith('127.0.0.1')) ? `http://${host}` : `https://${host}`;
+export async function createStreamArgs(source, tmdbApiKey, id, s, e, clientIP = null) {
     const audio = /dub$/.test(source.key) ? 'dub' : 'sub';
     return {
         id: id,
@@ -83,13 +82,25 @@ export async function createStreamArgs(source, tmdbApiKey, id, s, e, clientIP=nu
 }
 
 export async function validateTmdbId(tmdbApiKey, tmdbId, mediaType = 'movie') {
-    const key = `${tmdbId}-${mediaType}`;
+    let apiKey = tmdbApiKey;
+    let id = tmdbId;
+    let type = mediaType;
+    if (id === 'movie' || id === 'tv' || !id) {
+        if (apiKey && apiKey !== 'movie' && apiKey !== 'tv') {
+            type = id || 'movie';
+            id = apiKey;
+            apiKey = process.env.TMDB_API_KEY;
+        }
+    }
+    if (!apiKey) {
+        apiKey = process.env.TMDB_API_KEY;
+    }
+    const key = `${id}-${type}`;
     const cached = cacheGet(tmdbValidationCache, key);
     if (cached !== undefined) return cached;
-    const k = tmdbApiKey;
-    if (!k) return { valid: false, error: 'TMDB API key not configured' };
+    if (!apiKey) return { valid: false, error: 'TMDB API key not configured' };
     try {
-        const res = await fetch(`https://api.themoviedb.org/3/${mediaType}/${tmdbId}?api_key=${k}`, { signal: AbortSignal.timeout(5000) });
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`, { signal: AbortSignal.timeout(5000) });
         if (res.ok) {
             const data = await res.json();
             const isValid = !!(data?.id && (data?.title || data?.name));
@@ -108,15 +119,30 @@ export async function validateTmdbId(tmdbApiKey, tmdbId, mediaType = 'movie') {
 }
 
 export async function getTmdbInfo(tmdbApiKey, tmdbId, mediaType, season) {
-    const key = `${tmdbId}-${mediaType}-${season || ''}`;
+    let apiKey = tmdbApiKey;
+    let id = tmdbId;
+    let type = mediaType;
+    let s = season;
+    if (apiKey === 'movie' || apiKey === 'tv') {
+        type = apiKey;
+        id = tmdbId;
+        apiKey = process.env.TMDB_API_KEY;
+    } else if (id === 'movie' || id === 'tv') {
+        type = id;
+        id = apiKey;
+        apiKey = process.env.TMDB_API_KEY;
+    }
+    if (!apiKey) {
+        apiKey = process.env.TMDB_API_KEY;
+    }
+    const key = `${id}-${type}-${s || ''}`;
     const cached = cacheGet(tmdbInfoCache, key);
     if (cached !== undefined) return cached;
-    const k = tmdbApiKey;
-    if (!k) return { isAnime: false, titles: [], year: null, imdbId: null };
+    if (!apiKey) return { isAnime: false, titles: [], year: null, imdbId: null };
     try {
         const [mainRes, seasonRes] = await Promise.all([
-            fetch(`https://api.themoviedb.org/3/${mediaType}/${tmdbId}?api_key=${k}&append_to_response=external_ids`, { signal: AbortSignal.timeout(5000) }),
-            season && mediaType === 'tv' ? fetch(`https://api.themoviedb.org/3/tv/${tmdbId}/season/${season}?api_key=${k}`, { signal: AbortSignal.timeout(5000) }) : Promise.resolve(null),
+            fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}&append_to_response=external_ids`, { signal: AbortSignal.timeout(5000) }),
+            s && type === 'tv' ? fetch(`https://api.themoviedb.org/3/tv/${id}/season/${s}?api_key=${apiKey}`, { signal: AbortSignal.timeout(5000) }) : Promise.resolve(null),
         ]);
         let mainData = null, seasonData = null;
         if (mainRes.ok) mainData = await mainRes.json(); else mainRes.body?.cancel();
@@ -125,10 +151,10 @@ export async function getTmdbInfo(tmdbApiKey, tmdbId, mediaType, season) {
         const isAnime = genres.some(g => g.id === 16) && ((mainData?.origin_country || []).includes('JP') || mainData?.original_language === 'ja');
         const titles = [];
         if (seasonData?.name) titles.push(seasonData.name);
-        const t = mainData?.title || mainData?.name || '';
+        const titleText = mainData?.title || mainData?.name || '';
         const ot = mainData?.original_title || mainData?.original_name || '';
-        if (t) titles.push(t);
-        if (ot && ot !== t) titles.push(ot);
+        if (titleText) titles.push(titleText);
+        if (ot && ot !== titleText) titles.push(ot);
         const dateStr = seasonData?.air_date || mainData?.release_date || mainData?.first_air_date || '';
         const result = { isAnime, titles: [...new Set(titles.filter(Boolean))], year: dateStr ? parseInt(dateStr.slice(0, 4), 10) : null, imdbId: mainData?.imdb_id || mainData?.external_ids?.imdb_id || null };
         cacheSet(tmdbInfoCache, key, result, 600000);
@@ -178,16 +204,26 @@ export async function tmdbToAnilist(tmdbId, mediaType, season, titles = [], year
 }
 
 export async function imdbToTmdb(tmdbApiKey, imdbId, mediaType = 'movie') {
-    const key = `imdb-${imdbId}`;
+    let apiKey = tmdbApiKey;
+    let id = imdbId;
+    let type = mediaType;
+    if (id === 'movie' || id === 'tv') {
+        type = id;
+        id = apiKey;
+        apiKey = process.env.TMDB_API_KEY;
+    }
+    if (!apiKey) {
+        apiKey = process.env.TMDB_API_KEY;
+    }
+    const key = `imdb-${id}`;
     const cached = cacheGet(tmdbInfoCache, key);
     if (cached !== undefined) return cached;
-    const k = tmdbApiKey;
-    if (!k) return null;
+    if (!apiKey) return null;
     try {
-        const data = await fetchJson(`https://api.themoviedb.org/3/find/${imdbId}?api_key=${k}&external_source=imdb_id`, { signal: AbortSignal.timeout(5000) });
+        const data = await fetchJson(`https://api.themoviedb.org/3/find/${id}?api_key=${apiKey}&external_source=imdb_id`, { signal: AbortSignal.timeout(5000) });
         let result = null;
-        if (mediaType === 'movie' && data.movie_results?.length) result = data.movie_results[0].id;
-        else if (mediaType === 'tv' && data.tv_results?.length) result = data.tv_results[0].id;
+        if (type === 'movie' && data.movie_results?.length) result = data.movie_results[0].id;
+        else if (type === 'tv' && data.tv_results?.length) result = data.tv_results[0].id;
         if (result) cacheSet(tmdbInfoCache, key, result, 600000);
         return result;
     } catch { return null; }

package/src/sources/goated.js

@@ -1,262 +0,0 @@
-import crypto from "crypto";
-
-export const ID = "goated";
-export const DOMAIN = "https://goated.cx";
-export const RETURN_ALL_URLS = true;
-
-const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
-
-const enc = new TextEncoder();
-const info = enc.encode("goated-api-v1");
-const salt = enc.encode("goated-stream-salt");
-
-const generateRandomIP = () => {
-    const p = () => Math.floor(Math.random() * 255);
-    let first = p();
-    while ([0, 10, 127, 169, 172, 192].includes(first)) first = p();
-    return `${first}.${p()}.${p()}.${p()}`;
-};
-
-let cachedSession = null;
-let sessionExpiresAt = 0;
-let cachedProviders = null;
-let providersExpiresAt = 0;
-
-async function getValidSession(sessionIp) {
-    const now = Date.now();
-    if (cachedSession && now < sessionExpiresAt) {
-        return cachedSession;
-    }
-    try {
-        const chalRes = await fetch(`${DOMAIN}/api/auth/challenge`, {
-            headers: {
-                "User-Agent": UA,
-                "X-Forwarded-For": sessionIp,
-                "X-Real-IP": sessionIp,
-                Origin: DOMAIN,
-                Referer: DOMAIN + "/",
-            },
-            signal: AbortSignal.timeout(7000),
-        });
-
-        if (!chalRes.ok) throw new Error();
-        const chalData = await chalRes.json();
-        const { challenge, difficulty } = chalData;
-        const targetPrefix = "0".repeat(Math.ceil((difficulty || 16) / 4));
-        let nonceStr = "";
-
-        for (let i = 0; i < 5000000; i++) {
-            const nonce = Math.random().toString(36).substring(2, 10);
-            const hash = crypto.createHash("sha256").update(`${challenge}:${nonce}`).digest("hex");
-            if (hash.startsWith(targetPrefix)) {
-                nonceStr = nonce;
-                break;
-            }
-        }
-
-        if (!nonceStr) throw new Error();
-
-        const res = await fetch(`${DOMAIN}/api/auth/session`, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "User-Agent": UA,
-                "X-Forwarded-For": sessionIp,
-                "X-Real-IP": sessionIp,
-                Origin: DOMAIN,
-                Referer: DOMAIN + "/",
-            },
-            body: JSON.stringify({ challenge, nonce: nonceStr }),
-            signal: AbortSignal.timeout(7000),
-        });
-
-        if (!res.ok) throw new Error();
-        const data = await res.json();
-        if (!data.token) throw new Error();
-
-        cachedSession = data.token;
-        sessionExpiresAt = now + (data.expiresIn || 600) * 1000 - 30000;
-        return cachedSession;
-    } catch (e) {
-        throw new Error();
-    }
-}
-
-async function getProviders() {
-    const now = Date.now();
-    if (cachedProviders && now < providersExpiresAt) return cachedProviders;
-    try {
-        const res = await fetch(`${DOMAIN}/api/providers`, {
-            headers: { "User-Agent": UA },
-            signal: AbortSignal.timeout(5000)
-        });
-        if (!res.ok) return [];
-        const data = await res.json();
-        cachedProviders = data.providers || [];
-        providersExpiresAt = now + 3600 * 1000;
-        return cachedProviders;
-    } catch (e) {
-        return [];
-    }
-}
-
-async function deriveKey(tokenString) {
-    const rawKey = await crypto.subtle.importKey("raw", enc.encode(tokenString), "HKDF", false, ["deriveKey"]);
-    return crypto.subtle.deriveKey(
-        { name: "HKDF", hash: "SHA-256", salt, info },
-        rawKey,
-        { name: "AES-GCM", length: 256 },
-        false,
-        ["encrypt", "decrypt"],
-    );
-}
-
-async function encryptParams(payloadObj, key) {
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const data = enc.encode(JSON.stringify(payloadObj));
-    const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, data);
-    const combined = new Uint8Array(iv.length + ct.byteLength);
-    combined.set(iv);
-    combined.set(new Uint8Array(ct), iv.length);
-    return Buffer.from(combined).toString("base64");
-}
-
-async function decryptUrl(b64Url, key) {
-    const raw = Buffer.from(b64Url, "base64");
-    const iv = raw.slice(0, 12);
-    const ct = raw.slice(12);
-    try {
-        const plain = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ct);
-        return Buffer.from(plain).toString("utf8");
-    } catch {
-        return null;
-    }
-}
-
-async function decryptDeep(obj, key) {
-    if (!obj || typeof obj !== "object") return obj;
-    if (Array.isArray(obj)) return Promise.all(obj.map(x => decryptDeep(x, key)));
-
-    const out = {};
-    for (const [k, v] of Object.entries(obj)) {
-        if ((k === "url" || k === "file") && typeof v === "string" && v.length > 40) {
-            try {
-                const dec = await decryptUrl(v, key);
-                out[k] = dec ? dec : v;
-            } catch {
-                out[k] = v;
-            }
-        } else if (k === "links" && Array.isArray(v)) {
-            out[k] = await Promise.all(v.map(async x => {
-                if (typeof x === "string" && x.length > 40) {
-                    try {
-                        const dec = await decryptUrl(x, key);
-                        return dec ? dec : x;
-                    } catch {
-                        return x;
-                    }
-                }
-                return x;
-            }));
-        } else {
-            out[k] = await decryptDeep(v, key);
-        }
-    }
-    return out;
-}
-
-export async function getStream({ id, s, e, clientIP }) {
-    try {
-        const sessionIp = generateRandomIP();
-        const sessionJwt = await getValidSession(sessionIp);
-        const actualKey = await deriveKey(sessionJwt);
-
-        const isTv = s && e && s !== "null" && e !== "null";
-        const contentType = isTv ? "tv" : "movies";
-        const refererPath = isTv ? `tv/${id}-${s}-${e}/play` : `movie/${id}/play`;
-
-        let providers = await getProviders();
-        let activeProviders = providers.filter(p => p.active && (p.endpoints || []).includes(contentType));
-        if (activeProviders.length === 0) activeProviders = [{ name: null }];
-
-        const fetchProviderStream = async (provider) => {
-            try {
-                const payload = isTv
-                    ? { type: "tv", id: id.toString(), season: s.toString(), episode: e.toString() }
-                    : { type: "movie", id: id.toString() };
-
-                if (provider.name) payload.provider = provider.name;
-
-                const dParam = await encryptParams(payload, actualKey);
-
-                const streamRes = await fetch(`${DOMAIN}/api/stream?d=${encodeURIComponent(dParam)}`, {
-                    headers: {
-                        Authorization: `Bearer ${sessionJwt}`,
-                        "User-Agent": UA,
-                        "X-Forwarded-For": sessionIp,
-                        "X-Real-IP": sessionIp,
-                        Origin: DOMAIN,
-                        Referer: `${DOMAIN}/${refererPath}`,
-                    },
-                    signal: AbortSignal.timeout(10000)
-                });
-
-                if (!streamRes.ok) return [];
-                let rawData = await streamRes.json();
-
-                if (rawData.enc) {
-                    const raw = Buffer.from(rawData.enc, "base64");
-                    const decIv = raw.slice(0, 12);
-                    const decCt = raw.slice(12);
-                    const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv: decIv }, actualKey, decCt);
-                    rawData = JSON.parse(Buffer.from(decrypted).toString("utf-8"));
-                }
-
-                const streamData = await decryptDeep(rawData, actualKey);
-
-                if (!streamData.ok || !streamData.streams || streamData.streams.length === 0) return [];
-
-                const validStreams = [];
-                for (const stream of streamData.streams) {
-                    if (!stream.url) continue;
-                    if (stream.quality && stream.quality.toUpperCase() !== "AUTO" && streamData.streams.some(st => st.quality && st.quality.toUpperCase() === "AUTO")) continue;
-
-                    let finalUrl = stream.url;
-                    if (finalUrl.startsWith("/api/")) finalUrl = `${DOMAIN}${finalUrl}`;
-
-                    validStreams.push({
-                        url: finalUrl,
-                        headers: {
-                            "User-Agent": UA,
-                            Referer: DOMAIN + "/",
-                            Origin: DOMAIN,
-                        },
-                        server: stream.source || stream.server || provider.nickname || provider.name || "Goated",
-                        quality: stream.quality || "Auto",
-                        type: finalUrl.includes(".mp4") ? "mp4" : "hls",
-                        skipVerify: true,
-                        skipProxy: true,
-                    });
-                }
-                return validStreams;
-            } catch (err) {
-                return [];
-            }
-        };
-
-        const promises = activeProviders.map(p => fetchProviderStream(p));
-        const results = await Promise.allSettled(promises);
-
-        const allUrls = [];
-        for (const res of results) {
-            if (res.status === "fulfilled" && res.value.length > 0) {
-                allUrls.push(...res.value);
-            }
-        }
-
-        if (allUrls.length > 0) {
-            return { ...allUrls[0], allUrls };
-        }
-    } catch (err) { }
-    return null;
-}

package/src/sources/nebula.js

@@ -1,62 +0,0 @@
-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;
-    }
-}