@vyla-entertainment/sdk 1.0.0

package/src/config.js

@@ -0,0 +1,519 @@
+export const SOURCES = [
+    {
+        key: '1embed',
+        label: '1Embed',
+        sourceFile: '1embed',
+        proxyParam: '1e',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+    },
+
+    {
+        key: '123anime',
+        label: '123Anime',
+        sourceFile: '123anime',
+        proxyParam: 'a1',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: false,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /hlsx\d+cdn\.|burntburst\d+\.store|echovideo\.ru/i,
+            headers: {
+                Referer: 'https://play2.echovideo.ru/',
+                Origin: 'https://play2.echovideo.ru',
+            },
+        },],
+    },
+
+    {
+        key: 'anihq-sub',
+        label: 'AniHQ (Sub)',
+        sourceFile: 'anihq',
+        proxyParam: 'ahsub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
+    {
+        key: 'anihq-dub',
+        label: 'AniHQ (Dub)',
+        sourceFile: 'anihq',
+        proxyParam: 'ahdub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
+    {
+        key: 'anineko-sub',
+        sourceFile: 'anineko',
+        label: 'AniNeko (Sub)',
+        proxyParam: 'anksub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2
+    },
+
+    {
+        key: 'anineko-dub',
+        sourceFile: 'anineko',
+        label: 'AniNeko (Dub)',
+        proxyParam: 'ankdub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2
+    },
+
+    {
+        key: 'anipm-sub',
+        sourceFile: 'anipm',
+        label: 'AniPM (Sub)',
+        proxyParam: 'apsub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        skipProxy: true,
+        skipVerify: true,
+        multiUrl: true,
+        verifyHeaders: {
+            Referer: 'https://ani.pm/',
+            Origin: 'https://ani.pm',
+        },
+    },
+
+    {
+        key: 'anipm-dub',
+        sourceFile: 'anipm',
+        label: 'AniPM (Dub)',
+        proxyParam: 'apdub',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        skipProxy: true,
+        skipVerify: true,
+        multiUrl: true,
+        verifyHeaders: {
+            Referer: 'https://ani.pm/',
+            Origin: 'https://ani.pm',
+        },
+    },
+
+    {
+        key: 'flaxmovies',
+        label: 'FlaxMovies',
+        sourceFile: 'flaxmovies',
+        proxyParam: 'fx',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        disabled: true, // Temporarily disabled because their site is down, all streams are returning 403's
+        cdnHeaders: [{
+            pattern: /flix2watch\.pro/i,
+            headers: {
+                Referer: 'https://flaxmovies.xyz/',
+                Origin: 'https://flaxmovies.xyz',
+            },
+        },],
+    },
+
+    {
+        key: 'fsharetv',
+        label: 'FShareTV',
+        sourceFile: 'fsharetv',
+        proxyParam: 'fs',
+        timeout: 25000,
+        jitter: 600,
+        retries: 2,
+        multiUrl: false,
+        verifyHeaders: {
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.9',
+            Referer: 'https://fsharetv.cc',
+        },
+    },
+
+    {
+        key: 'goated',
+        label: 'Goated',
+        sourceFile: 'goated',
+        proxyParam: 'gt',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+    },
+
+    {
+        key: 'fsonic',
+        label: 'Fsonic',
+        sourceFile: 'fsonic',
+        proxyParam: 'fn',
+        timeout: 35000,
+        jitter: 600,
+        retries: 1,
+        multiUrl: true,
+    },
+
+    {
+        key: 'fsonline',
+        label: 'FSOnline',
+        sourceFile: 'fsonline',
+        proxyParam: 'fo',
+        timeout: 20000,
+        retries: 1,
+        jitter: 0,
+        multiUrl: true,
+        skipProxy: true,
+    },
+
+    {
+        key: 'hexa',
+        label: 'Hexa',
+        sourceFile: 'hexa',
+        proxyParam: 'hx',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+    },
+
+    {
+        key: 'kisskh',
+        label: 'KissKH',
+        sourceFile: 'kisskh',
+        proxyParam: 'kk',
+        timeout: 30000,
+        jitter: 500,
+        retries: 1,
+    },
+
+    {
+        key: 'lookmovie',
+        label: 'LookMovie',
+        sourceFile: 'lookmovie',
+        proxyParam: 'lm',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        verifyHeaders: {
+            'Accept-Language': 'en-US,en;q=0.9',
+        },
+    },
+
+    {
+        key: 'mapple',
+        label: 'Mapple',
+        sourceFile: 'mapple',
+        proxyParam: 'mp',
+        timeout: 15000,
+        retries: 1,
+        jitter: 0
+    },
+
+    {
+        key: 'meowtv',
+        label: 'MeowTV',
+        sourceFile: 'meowtv',
+        proxyParam: 'mt',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
+    {
+        key: 'nebula',
+        label: 'Nebula',
+        sourceFile: 'nebula',
+        proxyParam: 'nb',
+        timeout: 25000,
+        jitter: 500,
+        retries: 1,
+        multiUrl: true,
+        skipProxy: true,
+    },
+
+    {
+        key: 'nekowatch-sub',
+        sourceFile: 'nekowatch',
+        label: 'NekoWatch (Sub)',
+        proxyParam: 'nwsub',
+        timeout: 30000,
+        jitter: 500,
+        retries: 2
+    },
+
+    {
+        key: 'nekowatch-dub',
+        sourceFile: 'nekowatch',
+        label: 'NekoWatch (Dub)',
+        proxyParam: 'nwdub',
+        timeout: 30000,
+        jitter: 500,
+        retries: 2
+    },
+
+    {
+        key: 'opstream',
+        label: 'OpStream',
+        sourceFile: 'opstream',
+        proxyParam: 'op',
+        timeout: 35000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+        verifyHeaders: {
+            Referer: 'https://opstream.fun/',
+            Origin: 'https://opstream.fun',
+        },
+    },
+
+    {
+        key: 'peachify',
+        label: 'Peachify',
+        sourceFile: 'peachify',
+        proxyParam: 'pf',
+        timeout: 30000,
+        jitter: 500,
+        retries: 1,
+        multiUrl: true
+    },
+
+    {
+        key: 'pengu',
+        label: 'Pengu',
+        sourceFile: 'pengu',
+        proxyParam: 'pg',
+        timeout: 25000,
+        jitter: 500,
+        retries: 1,
+        multiUrl: true,
+        skipProxy: true,
+        disabled: true, // Temporarily disabled because they now require google auth
+    },
+
+    {
+        key: 'purstream',
+        sourceFile: 'purstream',
+        label: 'Purstream',
+        proxyParam: 'ps',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+    },
+
+    {
+        key: 'vidapi',
+        label: 'VidAPI',
+        sourceFile: 'vidapi',
+        proxyParam: 'va',
+        timeout: 25000,
+        jitter: 500,
+        retries: 1,
+        multiUrl: true
+    },
+
+    {
+        key: 'vidcore',
+        sourceFile: 'vidcore',
+        label: 'Vidcore',
+        proxyParam: 'vc',
+        timeout: 30000,
+        jitter: 500,
+        retries: 2,
+        sourcesTimeout: 10000,
+    },
+
+    {
+        key: 'videasy',
+        label: 'Videasy',
+        sourceFile: 'videasy',
+        proxyParam: 'vy',
+        timeout: 40000,
+        sourcesTimeout: 10000,
+        jitter: 900,
+        retries: 3,
+        multiUrl: true,
+        verifyHeaders: {
+            Accept: 'application/json, /; q=0.01',
+            Referer: 'https://player.videasy.net/',
+            Origin: 'https://player.videasy.net',
+        },
+    },
+
+    {
+        key: 'vidfast',
+        label: 'Vidfast',
+        sourceFile: 'vidfast',
+        proxyParam: 'vf',
+        timeout: 35000,
+        jitter: 500,
+        retries: 1,
+    },
+
+    {
+        key: 'vidlink',
+        label: 'Vidlink',
+        sourceFile: 'vidlink',
+        proxyParam: 'vl',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        skipProxy: true,
+        multiUrl: true,
+        disabled: true, // Temporarily disabled because their site is down, all streams are returning 403's
+    },
+
+    {
+        key: 'vidnest',
+        label: 'VidNest',
+        sourceFile: 'vidnest',
+        proxyParam: 'vdn',
+        timeout: 20000,
+        retries: 1,
+        jitter: 0,
+        multiUrl: true,
+    },
+
+    {
+        key: 'vidnest-sub',
+        label: 'VidNest (Sub)',
+        sourceFile: 'vidnest',
+        proxyParam: 'vdn',
+        timeout: 20000,
+        retries: 1,
+        jitter: 0,
+        multiUrl: true,
+        skipProxy: true,
+    },
+
+    {
+        key: 'vidnest-dub',
+        label: 'VidNest (Dub)',
+        sourceFile: 'vidnest',
+        proxyParam: 'vdn',
+        timeout: 20000,
+        retries: 1,
+        jitter: 0,
+        multiUrl: true,
+        skipProxy: true,
+    },
+
+    {
+        key: 'vidrift',
+        label: 'VidRift',
+        sourceFile: 'vidrift',
+        proxyParam: 'vr',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true
+    },
+
+    {
+        key: 'vidrock',
+        label: 'VidRock',
+        sourceFile: 'vidrock',
+        proxyParam: 'vr',
+        timeout: 20000,
+        jitter: 800,
+        retries: 3,
+        multiUrl: true,
+        cdnHeaders: [{
+            pattern: /./,
+            headers: {
+                Accept: '/',
+                'Accept-Language': 'en-US,en;q=0.9',
+                Referer: 'https://vidrock.ru/',
+                Origin: 'https://vidrock.ru',
+            },
+        },],
+    },
+
+    {
+        key: 'vidsync',
+        label: 'VidSync',
+        sourceFile: 'vidsync',
+        proxyParam: 'vs',
+        timeout: 20000,
+        retries: 2,
+        multiUrl: true,
+        disabled: true, // Temporarily disabled due to enc dec issues
+    },
+
+    {
+        key: 'vidup',
+        label: 'VidUp',
+        sourceFile: 'vidup',
+        proxyParam: 'vu',
+        timeout: 35000,
+        jitter: 500,
+        retries: 1,
+        multiUrl: true
+    },
+
+    {
+        key: 'vidzee',
+        label: 'VidZee',
+        sourceFile: 'vidzee',
+        proxyParam: 'vz',
+        timeout: 20000,
+        sourcesTimeout: 10000,
+        jitter: 400,
+        retries: 3,
+        disabled: true, // Temporarily disabled because their site is down, all streams are returning 403's
+        verifyHeaders: {
+            Accept: '/',
+            'Accept-Language': 'en-US,en;q=0.9',
+            Referer: 'https://player.vidzee.wtf',
+            Origin: 'https://player.vidzee.wtf',
+        },
+    },
+
+    {
+        key: 'vixsrc',
+        label: 'VixSrc',
+        sourceFile: 'vixsrc',
+        proxyParam: 'vx',
+        timeout: 35000,
+        jitter: 0,
+        retries: 2,
+        multiUrl: false,
+        skipProxy: true,
+        verifyHeaders: {
+            Accept: 'application/json, text/javascript, /; q=0.01',
+            'Accept-Language': 'en-US,en;q=0.9',
+            Referer: 'https://vixsrc.to/',
+            Origin: 'https://vixsrc.to',
+        },
+    },
+
+    {
+        key: 'xpass',
+        sourceFile: 'xpass',
+        label: 'XPass',
+        proxyParam: 'xp',
+        timeout: 20000,
+        jitter: 500,
+        retries: 2,
+        skipProxy: true,
+    },
+];
+
+export const HEALTH_PROBE_ID = '155';
+export const SOURCE_MAP = Object.fromEntries(SOURCES.map(s => [s.key, s]));
+export default SOURCES;

package/src/downloads/downloads.js

@@ -0,0 +1,8 @@
+import { getDownloads, getDownloadsTv } from "./sources/trendimovies.js";
+
+export async function fetchDownloads(id, s = null, e = null) {
+    const res = s != null && e != null
+        ? await getDownloadsTv(id, s, e)
+        : await getDownloads(id);
+    return res;
+}

package/src/downloads/sources/trendimovies.js

@@ -0,0 +1,63 @@
+const BASE = "https://trendimovies.com";
+
+const HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+    Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Referer": "https://trendimovies.com/",
+};
+
+async function fetchPage(path) {
+    const res = await fetch(`${BASE}${path}`, { headers: HEADERS });
+    if (!res.ok) throw new Error(`trendimovies ${res.status}`);
+    return res.text();
+}
+
+function parseLinks(html) {
+    const m = html.match(/DownloadSection[^>]*props="([^"]+)"/s) ||
+        html.match(/props="([^"]+)"[^>]*ssr[^>]*client="load"[^>]*opts="[^"]*DownloadSection/s);
+    if (!m) {
+        const alt = html.match(/"DownloadSection"/);
+        if (!alt) return [];
+        const propsMatch = html.match(/props="({[^"]*DownloadSection[^"]*})"/s);
+        if (!propsMatch) return [];
+        return extractLinks(propsMatch[1].replace(/"/g, '"').replace(/'/g, "'"));
+    }
+    return extractLinks(m[1].replace(/"/g, '"').replace(/'/g, "'"));
+}
+
+function extractLinks(propsJson) {
+    try {
+        const parsed = JSON.parse(propsJson);
+        const rawLinks = parsed?.links?.[1];
+        if (!Array.isArray(rawLinks)) return [];
+        return rawLinks
+            .map(item => item?.[1])
+            .filter(l => l && typeof l === "object")
+            .map(l => ({
+                url: unwrap(l.url),
+                quality: unwrap(l.quality) || "HD",
+                size: unwrap(l.file_size) || null,
+                type: "mkv",
+                active: unwrap(l.is_active) !== false,
+            }))
+            .filter(l => l.url && l.active);
+    } catch {
+        return [];
+    }
+}
+
+function unwrap(v) {
+    if (Array.isArray(v) && v.length === 2 && (v[0] === 0 || v[0] === 1)) return v[1];
+    return v;
+}
+
+export async function getDownloads(tmdbId) {
+    const html = await fetchPage(`/movie/${tmdbId}`);
+    return parseLinks(html);
+}
+
+export async function getDownloadsTv(tmdbId, season, episode) {
+    const html = await fetchPage(`/tv/${tmdbId}/season/${season}/episode/${episode}`);
+    return parseLinks(html);
+}

package/src/health.js

@@ -0,0 +1,38 @@
+import { HEALTH_PROBE_ID } from "./config.js";
+
+const withTimeout = (promise, ms) => Promise.race([promise, new Promise(r => setTimeout(() => r(null), ms))]);
+async function withRetry(fn, attempts = 2, delay = 300) {
+    for (let i = 0; i < attempts; i++) {
+        try {
+            const result = await fn();
+            if (result != null) return result;
+        } catch (err) {
+            if (i === attempts - 1) throw err;
+            await new Promise(r => setTimeout(r, delay + Math.random() * delay * 0.5));
+        }
+    }
+    return null;
+}
+
+export async function probeSource(tmdbApiKey, cfg, mod) {
+    const audio = /dub$/.test(cfg.key) ? 'dub' : 'sub';
+    const streamArgs = {
+        id: HEALTH_PROBE_ID,
+        s: null,
+        e: null,
+        clientIP: null,
+        absoluteBase: null,
+        audio,
+        tmdbApiKey,
+        config: cfg,
+    };
+
+    const t = Date.now();
+    const result = await withTimeout(
+        withRetry(() => mod.getStream(streamArgs), cfg.retries, 300),
+        cfg.timeout
+    );
+
+    const firstUrl = result?.url ?? result?.allUrls?.[0]?.url;
+    return { ok: !!(typeof firstUrl === 'string' && firstUrl.startsWith('http')), ms: Date.now() - t };
+}

package/src/sdk.js

@@ -0,0 +1,65 @@
+import SOURCES, { SOURCE_MAP } from "./config.js";
+import { fetchDownloads } from "./downloads/downloads.js";
+import { probeSource } from "./health.js";
+import { fetchSubtitles, getSubPathsMovie, getSubPathsTv } from "./subtitles.js";
+import { createStreamArgs } from "./utils/helpers.js";
+
+const ALL_SOURCE_MODULES = Object.fromEntries(
+    await Promise.all(SOURCES.map(async cfg => [cfg.key, await import(`./sources/${cfg.sourceFile}.js`)]))
+);
+
+const SOURCE_MODULES = Object.fromEntries(
+    Object.entries(ALL_SOURCE_MODULES).filter(([key]) => !SOURCE_MAP[key]?.disabled)
+);
+
+export default class VylaSDK {
+    constructor({ tmdbApiKey } = {}) {
+        this.tmdbApiKey = tmdbApiKey;
+    }
+    getSources(excludeDisabled = false) {
+        if (excludeDisabled) {
+            return SOURCES.filter(cfg => !cfg.disabled);
+        }
+        return SOURCES;
+    }
+    async probeAllSources() {
+        const active = SOURCES.filter(cfg => !cfg.disabled);
+
+        const results = await Promise.allSettled(
+            active.map(async cfg => await probeSource(cfg, SOURCE_MODULES[cfg.key]))
+        );
+
+        const sources = Object.fromEntries(
+            active.map((cfg, i) => [
+                cfg.key,
+                results[i].status === 'fulfilled' ? results[i].value : { ok: false, ms: null },
+            ])
+        );
+
+        return sources;
+    }
+    async probeSource(key) {
+        const cfg = SOURCES.find(cfg => cfg.key === key);
+        if (!cfg) throw new Error(`Source with key "${key}" not found`);
+        const mod = SOURCE_MODULES[key];
+        if (!mod) throw new Error(`Source module for key "${key}" not found`);
+        return await probeSource(this.tmdbApiKey, cfg, mod);
+    }
+    async getStream(key, id, s = null, e = null, clientIP = null) {
+        const cfg = SOURCES.find(cfg => cfg.key === key);
+        if (!cfg) throw new Error(`Source with key "${key}" not found`);
+        const mod = SOURCE_MODULES[key];
+        if (!mod) throw new Error(`Source module for key "${key}" not found`);
+        const streamArgs = await createStreamArgs(cfg, this.tmdbApiKey, id, s, e, clientIP);
+        return await mod.getStream(streamArgs);
+    }
+    async getSubtitles(id, s = null, e = null) {
+        const paths = s != null && e != null
+            ? await getSubPathsTv(id, s, e)
+            : await getSubPathsMovie(id);
+        return await fetchSubtitles(paths);
+    }
+    async getDownloads(id, s = null, e = null) {
+        return await fetchDownloads(id, s, e);
+    }
+}