@vyla-entertainment/sdk 1.6.0 → 1.8.0

package/src/sources/vidvault.js

@@ -0,0 +1,114 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+const BASE_URL = "https://vidvault.ru";
+const HEADERS = {
+    "Referer": `${BASE_URL}/`,
+    "Origin": BASE_URL,
+    "User-Agent": USER_AGENT,
+};
+
+async function getToken() {
+    const res = await fetch(`${BASE_URL}/api/get-token`, {
+        method: "GET",
+        headers: HEADERS
+    });
+    const data = await res.json();
+    return data.t;
+}
+
+function getCaptionType(url) {
+    return url.toLowerCase().includes(".vtt") ? "vtt" : "srt";
+}
+
+export async function getStream(args) {
+    const { id, s, e } = args;
+    const type = (s != null && e != null) ? "tv" : "movie";
+
+    try {
+        const token = await getToken();
+
+        const payload = { type, tmdbId: String(id) };
+        if (type === "tv") {
+            payload.season = String(s);
+            payload.episode = String(e);
+        }
+
+        const res = await fetch(`${BASE_URL}/api/download-proxy`, {
+            method: "POST",
+            headers: {
+                ...HEADERS,
+                "Content-Type": "application/json",
+                "x-request-token": token
+            },
+            body: JSON.stringify(payload)
+        });
+        const data = await res.json();
+
+        const allUrls = [];
+        const subtitles = [];
+
+        const mp4 = data?.mp4Data;
+        if (mp4) {
+            const country = mp4.country || "";
+            const lanName = mp4.lanName || "";
+            const detailPath = mp4.detailPath || "";
+
+            const downloads = mp4.downloadInfo?.data?.downloads || [];
+            for (const d of downloads) {
+                if (!d?.url) continue;
+                allUrls.push({
+                    quality: `${d.resolution}p ${detailPath} ${country} ${lanName}`.trim(),
+                    url: d.url,
+                    type: "mp4",
+                    headers: HEADERS
+                });
+            }
+
+            const srtCaptions = mp4.downloadInfo?.data?.captions || [];
+            for (const c of srtCaptions) {
+                if (!c?.url) continue;
+                subtitles.push({
+                    label: c.lanName || c.lan || "Unknown",
+                    type: getCaptionType(c.url),
+                    language: c.lan || "",
+                    url: c.url
+                });
+            }
+        }
+
+        const mkvFiles = data?.mkvData?.files || [];
+        for (const f of mkvFiles) {
+            if (!f?.url) continue;
+            allUrls.push({
+                quality: `MKV ${f.size || ""}`.trim(),
+                url: f.url,
+                type: "mp4",
+                headers: HEADERS
+            });
+        }
+
+        const mkvV2 = data?.mkvV2Data;
+        if (mkvV2?.url) {
+            allUrls.push({
+                quality: `${mkvV2.quality || ""} ${mkvV2.language || ""} ${mkvV2.country || ""} (${mkvV2.size || ""})`.trim(),
+                url: mkvV2.url,
+                type: "mp4",
+                headers: HEADERS
+            });
+        }
+
+        const mkvV3 = data?.mkvV3Data;
+        if (mkvV3?.url) {
+            allUrls.push({
+                quality: `${mkvV3.quality || ""} ${mkvV3.language || ""} ${mkvV3.country || ""} (${mkvV3.size || ""})`.trim(),
+                url: mkvV3.url,
+                type: "mp4",
+                headers: HEADERS
+            });
+        }
+
+        return allUrls.length ? { allUrls, subtitles } : null;
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/vidzee.js

@@ -1,70 +1,47 @@
-import { webcrypto } from 'node:crypto';
+// i can't fix this, i'll wait for someone else to fix this lol
+
+import crypto from 'node:crypto';
 import { fetchJson, USER_AGENT } from '../utils/helpers.js';
 
-const PLAYER_URL = 'https://player.vidzee.wtf';
 const CORE_URL = 'https://core.vidzee.wtf';
+const PLAYER_URL = 'https://player.vidzee.wtf';
+const KEY = 'c4a8f1d7e2b9a6c3d0f5e8a1b7c4d9e2';
 
-let cachedKey = null, cachedKeyTs = 0;
-
-async function getDecKey(headers) {
-    const now = Date.now();
-    if (cachedKey && now - cachedKeyTs < 300000) return cachedKey;
-
-    const res = await fetch(`${CORE_URL}/api-key`, {
-        headers,
-        signal: AbortSignal.timeout(7000)
-    });
-    if (!res.ok) throw new Error(`API key fetch failed: ${res.status}`);
-
-    const e = await res.text();
-    const t = Buffer.from(e.replace(/\s+/g, ''), 'base64');
-
-    const s = new Uint8Array(t.length - 28 + 16);
-    s.set(t.subarray(28), 0);
-    s.set(t.subarray(12, 28), t.length - 28);
-
-    const keyMat = await webcrypto.subtle.digest('SHA-256', new TextEncoder().encode('c4a8f1d7e2b9a6c3d0f5e8a1b7c4d9e2'));
-    const key = await webcrypto.subtle.importKey('raw', keyMat, { name: 'AES-GCM' }, false, ['decrypt']);
+function decryptAes(encryptedBase64) {
+    const keyBuf = Buffer.from(KEY, 'utf8');
+    const ciphertext = Buffer.from(encryptedBase64, 'base64');
 
     try {
-        const decrypted = await webcrypto.subtle.decrypt({
-            name: 'AES-GCM',
-            iv: t.subarray(0, 12),
-            tagLength: 128
-        }, key, s);
-
-        cachedKey = new TextDecoder().decode(decrypted);
-        cachedKeyTs = now;
-        return cachedKey;
-    } catch (err) {
-        throw new Error('Failed to decrypt Vidzee master key');
-    }
-}
+        const decipher = crypto.createDecipheriv('aes-256-ecb', keyBuf, null);
+        decipher.setAutoPadding(true);
+        let dec = decipher.update(ciphertext);
+        dec = Buffer.concat([dec, decipher.final()]);
+        const text = dec.toString('utf8');
+        if (text.startsWith('http') || text.includes('{')) return text;
+    } catch { }
 
-function decrypt(enc, key) {
     try {
-        const dec = Buffer.from(enc, 'base64').toString('utf8');
-        const sep = dec.indexOf(':');
-        if (sep === -1) return '';
+        const iv = Buffer.alloc(16, 0);
+        const decipher = crypto.createDecipheriv('aes-256-cbc', keyBuf, iv);
+        decipher.setAutoPadding(true);
+        let dec = decipher.update(ciphertext);
+        dec = Buffer.concat([dec, decipher.final()]);
+        const text = dec.toString('utf8');
+        if (text.startsWith('http') || text.includes('{')) return text;
+    } catch { }
 
-        const ivBase64 = dec.slice(0, sep);
-        const ciphertext = dec.slice(sep + 1);
-        const keyPadded = key.padEnd(32, '\0');
-
-        const decrypted = CryptoJS.AES.decrypt(
-            ciphertext,
-            CryptoJS.enc.Utf8.parse(keyPadded),
-            {
-                iv: CryptoJS.enc.Base64.parse(ivBase64),
-                mode: CryptoJS.mode.CBC,
-                padding: CryptoJS.pad.Pkcs7
-            }
-        );
-
-        return decrypted.toString(CryptoJS.enc.Utf8) || '';
-    } catch (err) {
-        return '';
-    }
+    try {
+        const iv = ciphertext.subarray(0, 16);
+        const data = ciphertext.subarray(16);
+        const decipher = crypto.createDecipheriv('aes-256-cbc', keyBuf, iv);
+        decipher.setAutoPadding(true);
+        let dec = decipher.update(data);
+        dec = Buffer.concat([dec, decipher.final()]);
+        const text = dec.toString('utf8');
+        if (text.startsWith('http') || text.includes('{')) return text;
+    } catch { }
+
+    return null;
 }
 
 export async function getStream({ id, s, e, clientIP }) {
@@ -77,44 +54,53 @@ export async function getStream({ id, s, e, clientIP }) {
     };
 
     try {
-        const decKey = await getDecKey(headers);
-
-        const serversToTry = [3, 0, 1, 2, 4, 5, 6, 8];
+        const isTv = s != null && e != null;
+        const servers = ['tik', 'ipcloud', 'v6:Hindi'];
+        const results = [];
 
-        for (const sr of serversToTry) {
+        for (const sr of servers) {
             try {
-                const url = `${PLAYER_URL}/api/server?id=${id}&sr=${sr}${s ? `&ss=${s}&ep=${e || 1}` : ''}`;
-                const data = await fetchJson(url, { headers, signal: AbortSignal.timeout(5000) });
-
-                if (data?.url?.length) {
-                    for (const entry of data.url) {
-                        if (!entry.link) continue;
-
-                        const decrypted = decrypt(entry.link, decKey);
-                        if (decrypted?.startsWith('http')) {
+                const url = isTv
+                    ? `${CORE_URL}/streams/tv/${id}/${s}/${e}?s=${encodeURIComponent(sr)}&e=${e}`
+                    : `${CORE_URL}/streams/movie/${id}?s=${encodeURIComponent(sr)}&e=1`;
+
+                const data = await fetchJson(url, { headers, signal: AbortSignal.timeout(6000) });
+
+                if (data && data.c) {
+                    const decryptedText = decryptAes(data.c);
+                    if (decryptedText) {
+                        let streamUrl = decryptedText;
+                        let extraHeaders = {};
+
+                        if (decryptedText.startsWith('{')) {
+                            try {
+                                const parsed = JSON.parse(decryptedText);
+                                streamUrl = parsed.url || parsed.link || parsed.file;
+                                if (parsed.headers) extraHeaders = parsed.headers;
+                            } catch { }
+                        }
 
-                            return {
-                                allUrls: [
-                                    {
-                                        url: decrypted,
-                                        skipHlsCheck: true,
-                                        headers: {
-                                            'User-Agent': USER_AGENT,
-                                            'Referer': PLAYER_URL,
-                                            'Origin': PLAYER_URL
-                                        }
-                                    }
-                                ]
-                            };
+                        if (streamUrl && streamUrl.startsWith('http')) {
+                            results.push({
+                                url: streamUrl,
+                                server: `VidZee - ${sr}`,
+                                skipHlsCheck: true,
+                                headers: {
+                                    'User-Agent': USER_AGENT,
+                                    'Referer': PLAYER_URL,
+                                    'Origin': PLAYER_URL,
+                                    ...extraHeaders
+                                }
+                            });
                         }
                     }
                 }
             } catch (err) {
-                continue;
             }
         }
-        return null;
-    } catch (err) {
+
+        return results.length ? { allUrls: results } : null;
+    } catch {
         return null;
     }
 }

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; }