@vyla-entertainment/sdk 1.21.0 → 1.23.0

package/src/sources/vidora.js

@@ -0,0 +1,94 @@
+const BASE_URL = 'https://vidoraplayer.duckdns.org';
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36';
+
+const HEADERS = {
+    'User-Agent': UA,
+    Referer: `${BASE_URL}/`,
+    Origin: BASE_URL,
+    Accept: 'application/x-ndjson, text/plain, */*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+
+function parseNdjson(text) {
+    if (!text) return [];
+    const normalized = text.replace(/\}\s*\{/g, '}\n{');
+    const lines = normalized.split('\n');
+    const items = [];
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line) continue;
+        try {
+            items.push(JSON.parse(line));
+        } catch { }
+    }
+    return items;
+}
+
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    const isTv = s != null && e != null;
+
+    const query = isTv
+        ? `type=tv&id=${id}&season=${s}&episode=${e}`
+        : `type=movie&id=${id}`;
+
+    const urls = [
+        `${BASE_URL}/api/sources?${query}`,
+        `${BASE_URL}/api/sources?${query}&gen=2`,
+    ];
+
+    const responses = await Promise.all(
+        urls.map(url =>
+            fetch(url, { headers: HEADERS })
+                .then(r => (r.ok ? r.text() : ''))
+                .catch(() => '')
+        )
+    );
+
+    const allUrls = [];
+    const seen = new Set();
+
+    for (const text of responses) {
+        const events = parseNdjson(text);
+        for (const item of events) {
+            const list = [];
+            if (item?.event === 'source' && item?.source) {
+                list.push(item.source);
+            } else if (item?.event === 'done' && Array.isArray(item?.sources)) {
+                list.push(...item.sources);
+            } else if (item?.url) {
+                list.push(item);
+            }
+
+            for (const src of list) {
+                if (!src?.url) continue;
+                const fullUrl = src.url.startsWith('http')
+                    ? src.url
+                    : `${BASE_URL}${src.url.startsWith('/') ? '' : '/'}${src.url}`;
+
+                if (!seen.has(fullUrl)) {
+                    seen.add(fullUrl);
+                    allUrls.push({
+                        url: fullUrl,
+                        server: `Vidora - ${src.label || src.server || src.providerGroup || 'Default'}`,
+                        quality: src.quality || 'Auto',
+                        type: src.type || (fullUrl.includes('.m3u8') ? 'hls' : 'mp4'),
+                        headers: {
+                            Referer: `${BASE_URL}/`,
+                            Origin: BASE_URL,
+                            'User-Agent': UA,
+                        },
+                    });
+                }
+            }
+        }
+    }
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls,
+    };
+}

package/src/sources/zenox.js

@@ -0,0 +1,108 @@
+const BASE_URL = 'https://zenox.lol';
+const API_URL = `${BASE_URL}/api/v1/playback/session`;
+const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36';
+
+const HEADERS = {
+    'Content-Type': 'application/json',
+    Origin: BASE_URL,
+    Referer: `${BASE_URL}/`,
+    'User-Agent': UA,
+};
+
+const PLAYBACK_HEADERS = {
+    Origin: BASE_URL,
+    Referer: `${BASE_URL}/`,
+};
+
+async function fetchServerStream(payload, srv) {
+    try {
+        const res = await fetch(API_URL, {
+            method: 'POST',
+            headers: HEADERS,
+            body: JSON.stringify({
+                ...payload,
+                serverIndex: srv.index,
+                serverName: srv.name,
+            }),
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok) return null;
+        const data = await res.json();
+        if (
+            !data?.success ||
+            !data?.streamUrl ||
+            data.streamUrl.includes('/primary/') ||
+            data.serverName?.toLowerCase() === 'primary'
+        ) {
+            return null;
+        }
+
+        const streamUrl = data.streamUrl.startsWith('http')
+            ? data.streamUrl
+            : `${BASE_URL}${data.streamUrl}`;
+
+        return {
+            url: streamUrl,
+            server: `Zenox - ${data.serverName || srv.name}`,
+            quality: 'Auto',
+            type: streamUrl.includes('.m3u8') ? 'hls' : (streamUrl.includes('.mpd') ? 'dash' : 'mp4'),
+            headers: PLAYBACK_HEADERS,
+        };
+    } catch {
+        return null;
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, title, year, imdbId } = args || {};
+    const idNum = parseInt(id, 10);
+    if (!idNum) return null;
+
+    const isTv = s != null && e != null;
+    const payload = {
+        mediaId: idNum,
+        mediaType: isTv ? 'tv' : 'movie',
+        season: isTv ? (parseInt(s, 10) || 1) : 1,
+        episode: isTv ? (parseInt(e, 10) || 1) : 1,
+        title: title || '',
+        year: String(year || ''),
+        imdbId: imdbId || '',
+        autoUseCommunity: false,
+        isManualSwitch: true,
+    };
+
+    const activeServers = [
+        { name: 'Vbot', index: 1 },
+        { name: 'Temporary', index: 1 },
+    ];
+
+    const results = await Promise.allSettled(
+        activeServers.map(srv => fetchServerStream(payload, srv))
+    );
+
+    const allUrls = [];
+    const seen = new Set();
+
+    for (const r of results) {
+        if (r.status === 'fulfilled' && r.value?.url && !seen.has(r.value.url)) {
+            seen.add(r.value.url);
+            allUrls.push(r.value);
+        }
+    }
+
+    if (!allUrls.length) {
+        const delta = await fetchServerStream(payload, { name: 'Delta', index: 0 });
+        if (delta?.url && !seen.has(delta.url)) {
+            seen.add(delta.url);
+            allUrls.push(delta);
+        }
+    }
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls,
+    };
+}