@vyla-entertainment/sdk 1.10.0 → 1.12.0

package/src/sources/meowtv.js

@@ -4,7 +4,7 @@ const API_BASE = 'https://api.meowtv.ru';
 const REFERER = 'https://meowtv.ru/';
 const ENC_DEC_API = 'https://enc-dec.app/api/dec-meowtv';
 
-const HEADERS = {
+const BASE_HEADERS = {
     'User-Agent': USER_AGENT,
     'Accept': 'application/json',
     'Referer': REFERER,
@@ -13,13 +13,46 @@ const HEADERS = {
 };
 
 const SERVERS = [
-    'hindiv3'
+    'dcloud', 'acme', 'tcloud', 'ipcloud', 'turkce', 'hindiv3'
 ];
 
 const TIMEOUT_MS = 15000;
 
 export const VERIFY_HEADERS = { 'User-Agent': USER_AGENT, 'Referer': REFERER, 'Origin': 'https://meowtv.ru' };
 
+let cachedTicket = null;
+let ticketExpiry = 0;
+
+/**
+ * Fetches a stream ticket or returns a cached valid ticket.
+ */
+async function getTicket(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && cachedTicket && now < ticketExpiry - 10000) {
+        return cachedTicket;
+    }
+
+    try {
+        const res = await fetchJson(`${API_BASE}/streams/ticket`, {
+            method: 'POST',
+            headers: {
+                ...BASE_HEADERS,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({})
+        });
+
+        if (res?.ticket) {
+            cachedTicket = res.ticket;
+            ticketExpiry = typeof res.exp === 'number' ? res.exp : now + 60000;
+            return cachedTicket;
+        }
+    } catch {
+    }
+
+    return null;
+}
+
 async function decryptPayload(payload) {
     try {
         const response = await fetchJson(ENC_DEC_API, {
@@ -47,6 +80,12 @@ export async function getStream({ id, s, e, server }) {
             targets = SERVERS.includes(cleanName) ? [cleanName] : [targets[0]];
         }
 
+        const ticket = await getTicket();
+        const requestHeaders = {
+            ...BASE_HEADERS,
+            ...(ticket ? { 'x-stream-ticket': ticket } : {})
+        };
+
         const results = await Promise.all(targets.map(async srv => {
             try {
                 return await Promise.race([
@@ -56,7 +95,7 @@ export async function getStream({ id, s, e, server }) {
                             : `/streams/movie/${id}?s=${encodeURIComponent(srv)}`;
 
                         const payload = await fetchJson(`${API_BASE}${path}`, {
-                            headers: HEADERS
+                            headers: requestHeaders
                         });
 
                         if (!payload) return null;

package/src/sources/movienight.js

@@ -0,0 +1,117 @@
+import { getUA } from '../utils/helpers.js';
+
+const BASE_URL = 'https://movienig.ht';
+
+const PRIORITY_SERVERS = [
+    { id: 'dallas', label: 'Dallas 4K' },
+    { id: 'austin', label: 'Austin' },
+    { id: 'helena', label: 'Helena' },
+    { id: 'seattle', label: 'Seattle 4K' },
+    { id: 'vixsrc-1', label: 'Newport Beach' },
+    { id: 'tucson', label: 'Tucson' },
+    { id: 'salem', label: 'Salem' },
+];
+
+async function resolveDetails(sdk, id, isTv) {
+    const apiKey = sdk?.tmdbApiKey || process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? 'tv' : 'movie';
+    try {
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}&append_to_response=external_ids`, {
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const releaseDate = isTv ? data.first_air_date : data.release_date;
+        const year = releaseDate ? parseInt(releaseDate.split('-')[0], 10) : null;
+        const imdbId = data.imdb_id || data.external_ids?.imdb_id || null;
+        return { title, year, imdbId };
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, sdk }) {
+    const isTv = Boolean(s && e);
+    const ua = getUA();
+
+    const details = await resolveDetails(sdk, id, isTv);
+    const title = details?.title || String(id);
+    const year = details?.year;
+    const imdbId = details?.imdbId;
+
+    const encTitle = encodeURIComponent(title);
+    const yearQuery = year ? `&year=${year}` : '';
+    const imdbQuery = imdbId ? `&imdbId=${imdbId}` : '';
+
+    const seenUrls = new Set();
+    const allUrls = [];
+
+    const defaultHeaders = {
+        'User-Agent': ua,
+        Referer: `${BASE_URL}/`,
+        Origin: BASE_URL,
+        Accept: 'text/event-stream',
+    };
+
+    const tasks = PRIORITY_SERVERS.map(async (server) => {
+        try {
+            const url = isTv
+                ? `${BASE_URL}/api/stream/v1/tv/${id}/${s}/${e}?title=${encTitle}${yearQuery}${imdbQuery}&server=${server.id}&only=1`
+                : `${BASE_URL}/api/stream/v1/movie/${id}?title=${encTitle}${yearQuery}${imdbQuery}&server=${server.id}&only=1`;
+
+            const res = await fetch(url, {
+                headers: defaultHeaders,
+                signal: AbortSignal.timeout(6000),
+            });
+
+            if (!res.ok) return;
+            const bodyStr = await res.text();
+
+            if (bodyStr.includes('event: done')) {
+                const doneIdx = bodyStr.indexOf('event: done');
+                const dataIdx = bodyStr.indexOf('data: ', doneIdx);
+
+                if (dataIdx !== -1) {
+                    const jsonStart = dataIdx + 6;
+                    const jsonEnd = bodyStr.indexOf('\n', jsonStart);
+                    const jsonText = (jsonEnd !== -1 ? bodyStr.substring(jsonStart, jsonEnd) : bodyStr.substring(jsonStart)).trim();
+
+                    const data = JSON.parse(jsonText);
+                    if (Array.isArray(data?.sources)) {
+                        for (const src of data.sources) {
+                            if (!src || typeof src !== 'object') continue;
+                            const rawUrl = String(src.url || '').trim();
+                            if (!rawUrl || seenUrls.has(rawUrl)) continue;
+
+                            seenUrls.add(rawUrl);
+
+                            const quality = src.quality ? String(src.quality) : 'Auto';
+                            const titleQuality = quality !== 'Auto' ? ` (${quality})` : '';
+
+                            allUrls.push({
+                                url: rawUrl,
+                                label: `MovieNight ${server.label}${titleQuality}`,
+                                headers: {
+                                    'User-Agent': ua,
+                                    Referer: `${BASE_URL}/`,
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        } catch { }
+    });
+
+    await Promise.all(tasks);
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}

package/src/sources/movy.js

@@ -0,0 +1,282 @@
+import { getUA } from '../utils/helpers.js';
+
+const API_BASE = 'https://api.wecollege.net';
+const REFERER = 'https://www.movy.bz/';
+const ORIGIN = 'https://www.movy.bz';
+const MAGIC = [109, 118, 109, 49];
+
+const SERVERS = [
+    { endpoint: 'miami', name: 'Miami', note: 'Original audio (Up to 4K)' },
+    { endpoint: 'seattle', name: 'Seattle', note: 'Original audio' },
+    { endpoint: 'denver', name: 'Denver', note: 'Original audio' },
+    { endpoint: 'chicago', name: 'Chicago', note: 'Original audio' },
+    { endpoint: 'dallas', name: 'Dallas', note: 'Original audio' },
+    { endpoint: 'atlanta', name: 'Atlanta', note: 'Original audio' },
+    { endpoint: 'houston', name: 'Houston', note: 'Original audio' },
+    { endpoint: 'austin', name: 'Austin', note: 'Original audio' },
+    { endpoint: 'boston', name: 'Boston', note: 'Original audio' },
+    { endpoint: 'munich', name: 'Munich', note: 'German audio', extra: 'language=german' },
+    { endpoint: 'berlin', name: 'Berlin', note: 'German audio' },
+    { endpoint: 'paris', name: 'Paris', note: 'French audio' },
+    { endpoint: 'delhi', name: 'Delhi', note: 'Hindi audio' },
+    { endpoint: 'cancun', name: 'Cancun', note: 'Spanish audio' },
+];
+
+const seedCache = new Map();
+
+function _l(e) {
+    let v = e >>> 0;
+    v = (v ^ (v >>> 16)) >>> 0;
+    v = Math.imul(v, 0x85ebca6b) >>> 0;
+    v = (v ^ (v >>> 13)) >>> 0;
+    v = Math.imul(v, 0xc2b2ae35) >>> 0;
+    return (v ^ (v >>> 16)) >>> 0;
+}
+
+function _u(e, t) {
+    const shift = t & 31;
+    if (shift === 0) return e >>> 0;
+    return (((e << shift) >>> 0) | (e >>> (32 - shift))) >>> 0;
+}
+
+function _fnv1a(str) {
+    let t = 0x811c9dc5 >>> 0;
+    for (let i = 0; i < str.length; i++) {
+        const code = str.charCodeAt(i);
+        t = Math.imul((t ^ code) >>> 0, 0x1000193) >>> 0;
+    }
+    return _l(t);
+}
+
+function _initKeyState(seed, tmdbId) {
+    const s = new Array(61).fill(0);
+    const isSet = new Array(61).fill(false);
+    const idVal = ((tmdbId >>> 0) ^ 0x9e3779b9) >>> 0;
+    let r = _l((_fnv1a(seed) ^ _l(idVal)) >>> 0);
+
+    for (let e = 0; e < 8; e++) {
+        const t = r % 61;
+        r = _u((r + 0x9e3779b9) >>> 0, 7 + (7 & e));
+        s[t] = (r ^ _l(r)) >>> 0;
+        isSet[t] = true;
+        r = _l((r + t) >>> 0);
+    }
+
+    const acc = _l((0xa5a5a5a5 ^ r) >>> 0);
+    return { s, isSet, acc };
+}
+
+function _nextKeystreamWord(state, t) {
+    const r = state.s;
+    let nState = state.acc;
+    const i = nState % 61;
+    const d = state.isSet[i] ? r[i] : 0;
+    const c = Math.imul((t + 1) >>> 0, 0x9e3779b9) >>> 0;
+    const a = nState;
+    const sVal = (d ^ c) >>> 0;
+    const h = state.isSet[i] ? ((a | sVal) >>> 0) : ((a ^ sVal) >>> 0);
+    const term1 = _u((h + nState) >>> 0, 31 & i);
+    const term2 = _u(nState, 31 & (i * 7));
+    nState = _l((((term1 ^ term2) >>> 0) + 0x9e3779b9) >>> 0);
+    r[i] = nState;
+    state.isSet[i] = true;
+    state.acc = nState;
+    return nState >>> 0;
+}
+
+function _generateKeyStream(seed, tmdbId, len) {
+    const state = _initKeyState(seed, tmdbId);
+    const out = new Uint8Array(len);
+    let wordIdx = 0;
+    let byteIdx = 0;
+
+    while (byteIdx < len) {
+        const word = _nextKeystreamWord(state, wordIdx++);
+        out[byteIdx++] = word & 0xFF;
+        if (byteIdx < len) out[byteIdx++] = (word >>> 8) & 0xFF;
+        if (byteIdx < len) out[byteIdx++] = (word >>> 16) & 0xFF;
+        if (byteIdx < len) out[byteIdx++] = (word >>> 24) & 0xFF;
+    }
+    return out;
+}
+
+function decrypt(cipherB64, seed, tmdbId) {
+    try {
+        let normalized = cipherB64.replace(/-/g, '+').replace(/_/g, '/');
+        while (normalized.length % 4 !== 0) normalized += '=';
+        const cipherBytes = Buffer.from(normalized, 'base64');
+        if (cipherBytes.length <= MAGIC.length) return null;
+
+        const ks = _generateKeyStream(seed, tmdbId, cipherBytes.length);
+        const decrypted = new Uint8Array(cipherBytes.length);
+        for (let i = 0; i < cipherBytes.length; i++) {
+            decrypted[i] = cipherBytes[i] ^ ks[i];
+        }
+
+        for (let k = 0; k < MAGIC.length; k++) {
+            if (decrypted[k] !== MAGIC[k]) return null;
+        }
+
+        return Buffer.from(decrypted.subarray(MAGIC.length)).toString('utf8');
+    } catch {
+        return null;
+    }
+}
+
+async function getSeed(tmdbId, ua) {
+    const now = Date.now();
+    const cached = seedCache.get(tmdbId);
+    if (cached && cached.expiresAt > now + 5000) {
+        return cached.seed;
+    }
+
+    try {
+        const res = await fetch(`${API_BASE}/seed?mediaId=${tmdbId}`, {
+            headers: {
+                'User-Agent': ua,
+                Referer: REFERER,
+                Origin: ORIGIN,
+            },
+            signal: AbortSignal.timeout(8000),
+        });
+
+        if (res.ok) {
+            const data = await res.json();
+            const seed = data?.seed ? String(data.seed) : '';
+            const ttlMs = typeof data?.ttlMs === 'number' ? data.ttlMs : 30000;
+            if (seed) {
+                seedCache.set(tmdbId, { seed, expiresAt: now + ttlMs });
+                return seed;
+            }
+        }
+    } catch { }
+
+    return null;
+}
+
+async function resolveDetails(sdk, id, isTv) {
+    const apiKey = sdk?.tmdbApiKey || process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? 'tv' : 'movie';
+    try {
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}&append_to_response=external_ids`, {
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const releaseDate = isTv ? data.first_air_date : data.release_date;
+        const year = releaseDate ? parseInt(releaseDate.split('-')[0], 10) : null;
+        const imdbId = data.imdb_id || data.external_ids?.imdb_id || null;
+        return { title, year, imdbId };
+    } catch {
+        return null;
+    }
+}
+
+function formatQuality(raw) {
+    const lower = String(raw).toLowerCase();
+    if (lower.includes('2160') || lower.includes('4k')) return '4K';
+    if (lower.includes('1080')) return '1080p';
+    if (lower.includes('720')) return '720p';
+    if (lower.includes('480')) return '480p';
+    if (lower.includes('360')) return '360p';
+    if (raw) return String(raw);
+    return 'Auto';
+}
+
+export async function getStream({ id, s, e, sdk }) {
+    const isTv = Boolean(s && e);
+    const mediaType = isTv ? 'tv' : 'movie';
+    const tmdbId = parseInt(id, 10);
+    const ua = getUA();
+
+    const details = await resolveDetails(sdk, id, isTv);
+    const title = details?.title || String(id);
+    const year = details?.year;
+    const imdbId = details?.imdbId;
+
+    const seed = await getSeed(tmdbId, ua);
+    if (!seed) return null;
+
+    const params = new URLSearchParams({
+        title,
+        mediaType,
+        tmdbId: String(tmdbId),
+        enc: '2',
+        seed,
+    });
+
+    if (year) params.set('year', String(year));
+    if (isTv) {
+        if (s) params.set('seasonId', String(s));
+        if (e) params.set('episodeId', String(e));
+    }
+    if (imdbId) params.set('imdbId', imdbId);
+
+    const baseQuery = params.toString();
+    const seenUrls = new Set();
+    const allUrls = [];
+
+    const defaultHeaders = {
+        'User-Agent': ua,
+        Referer: REFERER,
+        Origin: ORIGIN,
+    };
+
+    const tasks = SERVERS.map(async (server) => {
+        let fullUrl = `${API_BASE}/${server.endpoint}/sources?${baseQuery}`;
+        if (server.extra) fullUrl += `&${server.extra}`;
+
+        try {
+            const res = await fetch(fullUrl, {
+                headers: defaultHeaders,
+                signal: AbortSignal.timeout(8000),
+            });
+
+            if (!res.ok) return;
+            const encText = (await res.text()).trim();
+            if (!encText || encText.startsWith('<')) return;
+
+            const decJsonStr = decrypt(encText, seed, tmdbId);
+            if (!decJsonStr) return;
+
+            const parsed = JSON.parse(decJsonStr);
+            if (!Array.isArray(parsed?.sources)) return;
+
+            for (const src of parsed.sources) {
+                if (!src || typeof src !== 'object') continue;
+                const streamUrl = String(src.url || '').trim();
+                if (!streamUrl || seenUrls.has(streamUrl)) continue;
+
+                seenUrls.add(streamUrl);
+
+                const cleanQuality = formatQuality(src.quality || 'Auto');
+                const isSpecificAudio = server.note.toLowerCase().includes('audio') && !server.note.toLowerCase().includes('original');
+                const langLabel = isSpecificAudio ? server.note.split(' ')[0] : '';
+                const label = isSpecificAudio
+                    ? `${server.name} (${langLabel}) · ${cleanQuality}`
+                    : `${server.name} · ${cleanQuality}`;
+
+                allUrls.push({
+                    url: streamUrl,
+                    label,
+                    headers: {
+                        'User-Agent': ua,
+                        Referer: REFERER,
+                    },
+                });
+            }
+        } catch { }
+    });
+
+    await Promise.all(tasks);
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}

package/src/sources/pstream.js

@@ -0,0 +1,68 @@
+import { USER_AGENT } from '../utils/helpers.js';
+
+async function safeImport(moduleName) {
+    try {
+        return await import(`./${moduleName}.js`);
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, clientIP, sdk } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+    const allUrls = [];
+
+    const providers = [
+        { name: 'CineSu', key: 'cinesu', fnName: 'fetchCineSuStreams' },
+        { name: 'ZxcStream', key: 'zxcstream', fnName: 'fetchZxcStreams' },
+        { name: 'VidFast', key: 'vidfast', fnName: 'fetchVidFastStreams' },
+        { name: '1Embed', key: '1embed', fnName: 'fetchOneEmbedStreams' },
+    ];
+
+    await Promise.all(
+        providers.map(async ({ name, key, fnName }) => {
+            try {
+                let streamResult = null;
+
+                if (sdk) {
+                    try {
+                        streamResult = await sdk.getStream(key, id, s, e, clientIP);
+                    } catch { }
+                }
+
+                if (!streamResult) {
+                    const mod = await safeImport(key);
+                    if (mod) {
+                        if (typeof mod.getStream === 'function') {
+                            streamResult = await mod.getStream(args);
+                        } else if (typeof mod[fnName] === 'function') {
+                            const raw = await mod[fnName]({ type, id, season: s, episode: e });
+                            if (Array.isArray(raw)) {
+                                streamResult = { allUrls: raw };
+                            }
+                        }
+                    }
+                }
+
+                if (!streamResult) return;
+
+                const streams = streamResult.allUrls || (streamResult.url ? [streamResult] : []);
+                for (const item of streams) {
+                    allUrls.push({
+                        url: item.url,
+                        server: `FlyStream (${item.source || item.server || name})`,
+                        quality: item.quality || 'Auto',
+                        type: item.type || item.format || (item.url?.includes('.m3u8') ? 'hls' : 'mp4'),
+                        headers: item.headers || {
+                            'User-Agent': USER_AGENT,
+                        },
+                    });
+                }
+            } catch { }
+        })
+    );
+
+    return allUrls.length ? { allUrls } : null;
+}

package/src/sources/purstream.js

@@ -1,7 +1,7 @@
 import { fetchJson, USER_AGENT, getTmdbInfo } from '../utils/helpers.js';
 
-const DOMAIN = 'https://purstream.club';
-const API_BASE = 'https://api.purstream.club/api/v1';
+const DOMAIN = 'https://purstream.ad';
+const API_BASE = 'https://api.purstream.ad/api/v1';
 
 const HEADERS = {
     'User-Agent': USER_AGENT,

package/src/sources/streamaggregator.js

@@ -0,0 +1,127 @@
+import { getUA } from '../utils/helpers.js';
+
+const BASE_URL = 'https://streamaggregator.in';
+
+async function resolveDetails(sdk, id, isTv) {
+    const apiKey = sdk?.tmdbApiKey || process.env.TMDB_API_KEY;
+    if (!apiKey) return null;
+    const type = isTv ? 'tv' : 'movie';
+    try {
+        const res = await fetch(`https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`, {
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const releaseDate = isTv ? data.first_air_date : data.release_date;
+        const year = releaseDate ? releaseDate.split('-')[0] : null;
+        return { title, year };
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream({ id, s, e, sdk }) {
+    const isTv = Boolean(s && e);
+    const mediaType = isTv ? 'tv' : 'movie';
+    const ua = getUA();
+
+    const details = await resolveDetails(sdk, id, isTv);
+    const title = details?.title || String(id);
+    const year = details?.year || '';
+
+    const formattedTitle = encodeURIComponent(title).replaceAll('%20', '+');
+    const params = new URLSearchParams({
+        type: mediaType,
+        stream: 'true',
+    });
+
+    if (year) params.set('year', String(year));
+    if (isTv) {
+        params.set('season', String(s));
+        params.set('episode', String(e));
+    }
+
+    const scrapeUrl = `${BASE_URL}/api/scrape?title=${formattedTitle}&${params.toString()}`;
+
+    const res = await fetch(scrapeUrl, {
+        headers: {
+            'User-Agent': ua,
+            Referer: `${BASE_URL}/`,
+            Origin: BASE_URL,
+            Accept: 'application/x-ndjson, text/plain, */*',
+        },
+        signal: AbortSignal.timeout(18000),
+    });
+
+    if (!res.ok) return null;
+
+    const lines = [];
+    if (res.body?.getReader) {
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder('utf-8');
+        let buffer = '';
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split('\n');
+                buffer = parts.pop() || '';
+                for (const part of parts) {
+                    const trimmed = part.trim();
+                    if (trimmed) lines.push(trimmed);
+                }
+            }
+        } catch { }
+        if (buffer.trim()) lines.push(buffer.trim());
+    } else {
+        const text = await res.text();
+        for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (trimmed) lines.push(trimmed);
+        }
+    }
+
+    const seenUrls = new Set();
+    const allUrls = [];
+
+    for (const line of lines) {
+        try {
+            const item = JSON.parse(line);
+            const streamUrl = String(item?.url || '').trim();
+            if (!streamUrl || !streamUrl.startsWith('http') || seenUrls.has(streamUrl)) continue;
+
+            seenUrls.add(streamUrl);
+
+            const serverName = item.server || item.providerKey || 'Stream';
+            const quality = item.quality ? ` · ${item.quality}` : '';
+            const size = item.size ? ` (${item.size})` : '';
+            const label = `${serverName}${quality}${size}`;
+
+            const headers = {
+                'User-Agent': ua,
+                ...(item.headers && typeof item.headers === 'object' ? item.headers : {}),
+            };
+
+            if (item.referer) {
+                headers.Referer = item.referer;
+            }
+
+            allUrls.push({
+                url: streamUrl,
+                label,
+                headers,
+            });
+        } catch { }
+    }
+
+    if (allUrls.length === 0) return null;
+
+    return {
+        url: allUrls[0].url,
+        allUrls,
+        headers: allUrls[0].headers,
+    };
+}