@vyla-entertainment/sdk 1.0.0 → 1.2.0

package/src/sources/lmscript.js

@@ -0,0 +1,43 @@
+import { getTmdbInfo } from '../utils/helpers.js';
+
+export async function getStream(args) {
+    const { id, s, e, tmdbApiKey } = args;
+    const type = (s != null && e != null) ? 'tv' : 'movie';
+
+    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 response = await fetch(url);
+            const data = await response.json();
+
+            const movie = data.items?.find(item => `${item.tmdb_prefix}` === `${id}` || `${item.tmdb_id}` === `${id}`);
+            if (!movie) return null;
+
+            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 (!sortedStreams.length) return null;
+
+            const allUrls = sortedStreams.map(quality => {
+                const streamUrl = streams[quality];
+                return {
+                    url: streamUrl,
+                    quality,
+                    type: streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                    headers: {}
+                };
+            });
+
+            return { allUrls };
+        }
+    } catch (err) {
+        return null;
+    }
+}

package/src/sources/mapple.js

@@ -76,13 +76,29 @@ export async function getStream(args) {
         const reqMatch = html.match(/window\.__REQUEST_TOKEN__\s*=\s*"([^"]+)"/);
         if (!reqMatch) return null;
         const requestToken = reqMatch[1];
-        const initRes = await fetch(`${BASE_URL}/api/playback-init`, { method: "POST", headers: { "Content-Type": "application/json", ...PROXY_HEADERS, Referer: pageUrl }, body: JSON.stringify({ mediaId: Number(id), mediaType, requestToken }), signal: AbortSignal.timeout(10000) });
+        const cookies = pageRes.headers.getSetCookie();
+        const cookieHeader = cookies.map(c => c.split(';')[0]).join('; ');
+        
+        const initHeaders = { "Content-Type": "application/json", ...PROXY_HEADERS, Referer: pageUrl };
+        if (cookieHeader) initHeaders.Cookie = cookieHeader;
+
+        const initRes = await fetch(`${BASE_URL}/api/playback-init`, { 
+            method: "POST", 
+            headers: initHeaders, 
+            body: JSON.stringify({ mediaId: Number(id), mediaType, requestToken }), 
+            signal: AbortSignal.timeout(10000) 
+        });
         const initData = await initRes.json();
         let streamToken = initData.token;
         if (initData.requiresPow && initData.pow) {
             const powRes = solvePoW(initData.pow.challenge, initData.pow.difficulty);
             if (powRes.found) {
-                const solveRes = await fetch(`${BASE_URL}/api/playback-init`, { method: "POST", headers: { "Content-Type": "application/json", ...PROXY_HEADERS, Referer: pageUrl }, body: JSON.stringify({ mediaId: Number(id), mediaType, requestToken, pow: { challengeId: initData.pow.challengeId, nonce: powRes.nonce } }), signal: AbortSignal.timeout(10000) });
+                const solveRes = await fetch(`${BASE_URL}/api/playback-init`, { 
+                    method: "POST", 
+                    headers: initHeaders, 
+                    body: JSON.stringify({ mediaId: Number(id), mediaType, requestToken, pow: { challengeId: initData.pow.challengeId, nonce: powRes.nonce } }), 
+                    signal: AbortSignal.timeout(10000) 
+                });
                 streamToken = (await solveRes.json()).token;
             }
         }
@@ -96,8 +112,28 @@ export async function getStream(args) {
         const allUrls = [];
         for (const srv of targets) {
             try {
-                const streamUrl = `${BASE_URL}/api/stream?mediaId=${id}&mediaType=${mediaType}&tv_slug=${tvSlug}&source=${srv.id}&apikey=mptv_sk_a8f29c4e7b3d1f&requestToken=${requestToken}&token=${streamToken}`;
-                const streamRes = await fetch(streamUrl, { headers: { ...PROXY_HEADERS, Referer: pageUrl }, signal: AbortSignal.timeout(8000) });
+                const encryptRes = await fetch(`${BASE_URL}/api/encrypt`, {
+                    method: "POST",
+                    headers: initHeaders,
+                    body: JSON.stringify({
+                        data: {
+                            mediaId: Number(id),
+                            mediaType,
+                            tv_slug: tvSlug,
+                            source: srv.id,
+                            apikey: "mptv_sk_a8f29c4e7b3d1f"
+                        }
+                    }),
+                    signal: AbortSignal.timeout(8000)
+                });
+                const encryptData = await encryptRes.json();
+                if (!encryptData.encrypted) continue;
+
+                const streamUrl = `${BASE_URL}/api/stream-encrypted?data=${encodeURIComponent(encryptData.encrypted)}&requestToken=${encodeURIComponent(requestToken)}&token=${encodeURIComponent(streamToken)}`;
+                const streamRes = await fetch(streamUrl, { 
+                    headers: { ...PROXY_HEADERS, Referer: pageUrl, ...(cookieHeader ? { Cookie: cookieHeader } : {}) }, 
+                    signal: AbortSignal.timeout(8000) 
+                });
                 const streamData = await streamRes.json();
                 if (streamData.success && streamData.data?.stream_url) {
                     let fileUrl = streamData.data.stream_url;

package/src/sources/meowtv.js

@@ -13,15 +13,7 @@ const HEADERS = {
 };
 
 const SERVERS = [
-    'pseudo',
-    'lynx',
-    'tik',
-    'ipcloud',
-    'v4:English',
-    'turkce',
-    'v5:Hindi',
-    'v4:Hindi',
-    'v6:Hindi'
+    'hindiv3'
 ];
 
 const TIMEOUT_MS = 15000;

package/src/sources/peestream.js

@@ -0,0 +1,122 @@
+import { USER_AGENT, fetchJson, getTmdbInfo } from '../utils/helpers.js';
+
+const BASE_URL = 'https://providers.peestream.in';
+
+export async function getStream(args) {
+    const { id, s, e, server, tmdbApiKey } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+
+    let title = args.title || '';
+    let releaseYear = args.year || '';
+    let imdbId = args.imdbId || '';
+
+    if (!title) {
+        try {
+            const info = await getTmdbInfo(id, type, s, tmdbApiKey);
+            if (info) {
+                title = info.title || '';
+                if (info.year) releaseYear = info.year;
+                if (info.imdbId) imdbId = info.imdbId;
+            }
+        } catch { }
+    }
+
+    const queryParams = new URLSearchParams({
+        type,
+        tmdbId: String(id),
+        title: title || String(id)
+    });
+    if (releaseYear) queryParams.set('releaseYear', String(releaseYear));
+    if (imdbId) queryParams.set('imdbId', String(imdbId));
+    if (isTv) {
+        queryParams.set('season', String(s));
+        queryParams.set('episode', String(e));
+    }
+
+    const allUrls = [];
+
+    try {
+        const scrapeUrl = `${BASE_URL}/scrape?${queryParams.toString()}`;
+        const res = await fetch(scrapeUrl, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Accept': 'text/event-stream',
+                'Referer': `${BASE_URL}/`
+            },
+            signal: AbortSignal.timeout(15000)
+        });
+
+        if (res.ok) {
+            const text = await res.text();
+            const events = text.split('\n\n');
+            for (const ev of events) {
+                if (ev.includes('event: completed')) {
+                    const dataMatch = ev.match(/data:\s*(.+)/);
+                    if (dataMatch) {
+                        try {
+                            const parsed = JSON.parse(dataMatch[1].trim());
+                            const stream = parsed.stream;
+                            const streamUrl = stream?.playlist || stream?.url || stream?.file;
+                            if (streamUrl) {
+                                allUrls.push({
+                                    url: streamUrl,
+                                    server: `PeeStream - ${parsed.sourceId || 'Poseidon'}`,
+                                    quality: 'Auto',
+                                    type: stream.type === 'hls' || streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                                    headers: stream.headers || {
+                                        'User-Agent': USER_AGENT
+                                    }
+                                });
+                            }
+                        } catch { }
+                    }
+                }
+            }
+        }
+    } catch { }
+
+    if (!allUrls.length) {
+        try {
+            const searchUrl = `${BASE_URL}/api/search?q=${encodeURIComponent(title || id)}&type=${type}&tmdbId=${id}${isTv ? `&season=${s}&episode=${e}` : ''}`;
+            const data = await fetchJson(searchUrl, {
+                headers: {
+                    'User-Agent': USER_AGENT,
+                    'Accept': 'application/json',
+                    'Referer': `${BASE_URL}/`
+                },
+                signal: AbortSignal.timeout(10000)
+            });
+
+            if (data && Array.isArray(data.results)) {
+                for (const result of data.results) {
+                    const pName = result.providerName || result.provider || 'PeeStream';
+                    for (const stream of result.streams || []) {
+                        if (!stream || !stream.url) continue;
+                        allUrls.push({
+                            url: stream.url,
+                            server: `PeeStream - ${stream.name || pName}`,
+                            quality: stream.quality || 'Auto',
+                            type: stream.type === 'm3u8' || stream.url.includes('.m3u8') ? 'hls' : 'mp4',
+                            headers: stream.headers || {
+                                'User-Agent': USER_AGENT
+                            }
+                        });
+                    }
+                }
+            }
+        } catch { }
+    }
+
+    if (server && server !== 'all') {
+        const clean = server.toLowerCase().replace('peestream - ', '');
+        const filtered = allUrls.filter(u => u.server.toLowerCase().includes(clean));
+        if (filtered.length) return { allUrls: filtered };
+    }
+
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources() {
+    return ['PeeStream - vaplayer'];
+}

package/src/sources/videasy.js

@@ -1,28 +1,24 @@
 import { getTmdbInfo, fetchJson, fetchText, USER_AGENT } from '../utils/helpers.js';
 
-const WINGS_BASE = "https://api.wingsdatabase.com";
+const SPEEDRACE_BASE = "https://api.speedracelight.com";
 const HEADERS = { "Accept": "*/*", "Origin": "https://player.videasy.to", "Referer": "https://player.videasy.to/", "User-Agent": USER_AGENT };
 const SERVERS = [
-    { id: 'jett', name: 'Jett' },
     { id: 'cdn', name: 'Yoru' },
-    { id: 'tejo', name: 'Tejo' },
-    { id: 'neon2', name: 'Neon' },
-    { id: 'ym', name: 'Sage' },
-    { id: 'downloader2', name: 'Cypher' },
     { id: 'm4uhd', name: 'Breach' },
+    { id: 'vsrc', name: 'Neon' },
     { id: 'hdmovie', name: 'Vyse' },
     { id: 'meine', name: 'Killjoy' },
     { id: 'lamovie', name: 'Omen' },
     { id: 'superflix', name: 'Raze' }
 ];
 
-export async function getStream({ id, s, e, server }) {
+export async function getStream({ id, s, e, server, 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 seedData = await fetchJson(`${WINGS_BASE}/seed?mediaId=${id}`, { headers: HEADERS, signal: AbortSignal.timeout(5000) });
+        const seedData = await fetchJson(`${SPEEDRACE_BASE}/seed?mediaId=${id}`, { headers: HEADERS, signal: AbortSignal.timeout(5000) });
         const seed = seedData?.seed;
         if (!seed) return null;
 
@@ -36,9 +32,7 @@ export async function getStream({ id, s, e, server }) {
         }
 
         const settled = await Promise.allSettled(targets.map(async srv => {
-            if (srv.id === 'cdn' && isTv) throw new Error();
-
-            let url = `${WINGS_BASE}/${srv.id}/sources-with-title?title=${encTitle}&mediaType=${isTv ? 'tv' : 'movie'}&year=${info.year || ''}&tmdbId=${id}&imdbId=${info.imdbId || "tt0000000"}&enc=2&seed=${seed}`;
+            let url = `${SPEEDRACE_BASE}/${srv.id}/sources-with-title?title=${encTitle}&mediaType=${isTv ? 'tv' : 'movie'}&year=${info.year || ''}&tmdbId=${id}&imdbId=${info.imdbId || "tt0000000"}&enc=2&seed=${seed}`;
             if (isTv) url += `&episodeId=${e}&seasonId=${s}`;
 
             const encText = await fetchText(url, { headers: HEADERS, signal: AbortSignal.timeout(10000) });

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