@vyla-entertainment/sdk 1.21.0 → 1.23.0

package/src/sources/castle.js

@@ -0,0 +1,415 @@
+import crypto from 'node:crypto';
+
+const TMDB_BASE_URL = 'https://api.themoviedb.org/3';
+const CASTLE_BASE = 'https://api.hlowb.com';
+const PKG = 'com.external.castle';
+const CHANNEL = 'IndiaA';
+const CLIENT = '1';
+const LANG = 'en-US';
+const SUFFIX = 'T!BgJB';
+const APK_SIGN_KEY = 'ED0955EB04E67A1D9F3305B95454FED485261475';
+
+const WORKING_HEADERS = {
+    'User-Agent': 'okhttp/4.9.3',
+    Accept: 'application/json',
+    'Accept-Language': 'en-US,en;q=0.9',
+    Connection: 'Keep-Alive',
+    Referer: CASTLE_BASE,
+};
+
+export const CASTLE_PLAYBACK_HEADERS = {
+    'User-Agent':
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36',
+    Accept:
+        'video/webm,video/ogg,video/*;q=0.9,application/ogg;q=0.7,audio/*;q=0.6,*/*;q=0.5',
+    'Accept-Language': 'en-US,en;q=0.9',
+    'Accept-Encoding': 'identity',
+    Connection: 'keep-alive',
+    'Sec-Fetch-Dest': 'video',
+    'Sec-Fetch-Mode': 'no-cors',
+    'Sec-Fetch-Site': 'cross-site',
+    DNT: '1',
+};
+
+const QUALITY_MAP = { 1: '480p', 2: '720p', 3: '1080p' };
+
+function safeJsonParse(text) {
+    const safe = text.replace(/:(\s*)(-?\d{16,})(\s*[,}\]])/g, ':$1"$2"$3');
+    return JSON.parse(safe);
+}
+
+class CastleScraper {
+    constructor(apiKey) {
+        this.tmdbKey =
+            apiKey ||
+            process.env.CASTLE_TMDB_API_KEY ||
+            process.env.TMDB_API_KEY ||
+            '439c478a771f35c05022f9feabcca01c';
+        this.securityKey = null;
+    }
+
+    deriveKey(apiKeyB64) {
+        const apiKeyBytes = Buffer.from(apiKeyB64, 'base64');
+        let keyMaterial = Buffer.concat([apiKeyBytes, Buffer.from(SUFFIX, 'ascii')]);
+        if (keyMaterial.length < 16) {
+            keyMaterial = Buffer.concat([
+                keyMaterial,
+                Buffer.alloc(16 - keyMaterial.length),
+            ]);
+        } else if (keyMaterial.length > 16) {
+            keyMaterial = keyMaterial.subarray(0, 16);
+        }
+        return keyMaterial;
+    }
+
+    decryptCastle(encryptedB64, securityKeyB64) {
+        const aesKey = this.deriveKey(securityKeyB64);
+        const iv = aesKey;
+        const encrypted = Buffer.from(encryptedB64, 'base64');
+        const decipher = crypto.createDecipheriv('aes-128-cbc', aesKey, iv);
+        decipher.setAutoPadding(true);
+        return Buffer.concat([
+            decipher.update(encrypted),
+            decipher.final(),
+        ]).toString('utf-8');
+    }
+
+    async request(url, init) {
+        const r = await fetch(url, {
+            ...init,
+            headers: { ...WORKING_HEADERS, ...(init?.headers || {}) },
+        });
+        if (!r.ok) throw new Error(`Castle request failed ${r.status} for ${url}`);
+        return r;
+    }
+
+    async extractCipher(response) {
+        const text = (await response.text()).trim();
+        if (!text) throw new Error('Empty response');
+        try {
+            const j = JSON.parse(text);
+            if (j && typeof j.data === 'string') return j.data.trim();
+        } catch { }
+        return text;
+    }
+
+    async decryptedJson(response, securityKey) {
+        const cipher = await this.extractCipher(response);
+        return safeJsonParse(this.decryptCastle(cipher, securityKey));
+    }
+
+    async getSecurityKey() {
+        if (this.securityKey) return this.securityKey;
+        const url = `${CASTLE_BASE}/v0.1/system/getSecurityKey/1?channel=${CHANNEL}&clientType=${CLIENT}&lang=${LANG}`;
+        const r = await this.request(url);
+        const data = await r.json();
+        if (data.code !== 200 || !data.data) {
+            throw new Error(`Security key API error: ${JSON.stringify(data)}`);
+        }
+        this.securityKey = data.data;
+        return this.securityKey;
+    }
+
+    async searchCastle(securityKey, keyword, page = 1, size = 30) {
+        const params = new URLSearchParams({
+            channel: CHANNEL,
+            clientType: CLIENT,
+            keyword,
+            lang: LANG,
+            mode: '1',
+            packageName: PKG,
+            page: String(page),
+            size: String(size),
+        });
+        const url = `${CASTLE_BASE}/film-api/v1.1.0/movie/searchByKeyword?${params}`;
+        return this.decryptedJson(await this.request(url), securityKey);
+    }
+
+    async getDetails(securityKey, movieId) {
+        const url = `${CASTLE_BASE}/film-api/v1.1/movie?channel=${CHANNEL}&clientType=${CLIENT}&lang=${LANG}&movieId=${movieId}&packageName=${PKG}`;
+        return this.decryptedJson(await this.request(url), securityKey);
+    }
+
+    async getVideo2(securityKey, movieId, episodeId, resolution = 2) {
+        const url = `${CASTLE_BASE}/film-api/v2.0.1/movie/getVideo2?clientType=${CLIENT}&packageName=${PKG}&channel=${CHANNEL}&lang=${LANG}`;
+        const body = {
+            mode: '1',
+            appMarket: 'GuanWang',
+            clientType: '1',
+            woolUser: 'false',
+            apkSignKey: APK_SIGN_KEY,
+            androidVersion: '13',
+            movieId: String(movieId),
+            episodeId: String(episodeId),
+            isNewUser: 'true',
+            resolution: String(resolution),
+            packageName: PKG,
+        };
+        const r = await this.request(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        return this.decryptedJson(r, securityKey);
+    }
+
+    async getVideoV1(securityKey, movieId, episodeId, languageId, resolution = 2) {
+        const params = new URLSearchParams({
+            apkSignKey: APK_SIGN_KEY,
+            channel: CHANNEL,
+            clientType: CLIENT,
+            episodeId: String(episodeId),
+            lang: LANG,
+            languageId: String(languageId),
+            mode: '1',
+            movieId: String(movieId),
+            packageName: PKG,
+            resolution: String(resolution),
+        });
+        const url = `${CASTLE_BASE}/film-api/v1.9.1/movie/getVideo?${params}`;
+        return this.decryptedJson(await this.request(url), securityKey);
+    }
+
+    extractDataBlock(obj) {
+        if (obj && typeof obj.data === 'object' && obj.data) return obj.data;
+        return obj && typeof obj === 'object' ? obj : {};
+    }
+
+    qualityValue(quality) {
+        if (!quality) return 0;
+        let q = String(quality).toLowerCase();
+        q = q.replace(/^(sd|hd|fhd|uhd|4k)\s*/, '').replace(/p$/, '').trim();
+        if (q === '4k' || q === '2160') return 2160;
+        const known = [1440, 1080, 720, 480, 360, 240];
+        const n = parseInt(q, 10);
+        if (known.includes(n)) return n;
+        return n > 0 ? n : 0;
+    }
+
+    formatSize(size) {
+        if (typeof size === 'number' && size > 0) {
+            return size > 1_000_000_000
+                ? `${(size / 1_000_000_000).toFixed(2)} GB`
+                : `${Math.round(size / 1_000_000)} MB`;
+        }
+        return 'Unknown';
+    }
+
+    async getTmdbDetails(tmdbId, mediaType) {
+        const endpoint = mediaType === 'tv' ? 'tv' : 'movie';
+        const url = `${TMDB_BASE_URL}/${endpoint}/${tmdbId}?api_key=${this.tmdbKey}&append_to_response=external_ids`;
+        const r = await this.request(url);
+        const data = await r.json();
+        const title = mediaType === 'tv' ? data.name : data.title;
+        const releaseDate =
+            mediaType === 'tv' ? data.first_air_date : data.release_date;
+        const year = releaseDate ? parseInt(String(releaseDate).split('-')[0], 10) : null;
+        return { title, year, tmdbId };
+    }
+
+    findMovieId(searchResult, tmdbInfo) {
+        const data = this.extractDataBlock(searchResult);
+        const rows = data.rows || [];
+        if (!rows.length) throw new Error('No search results found');
+        const searchTitle = (tmdbInfo.title || '').toLowerCase();
+
+        for (const item of rows) {
+            const itemTitle = String(item.title || item.name || '').toLowerCase();
+            if (
+                itemTitle &&
+                (itemTitle.includes(searchTitle) || searchTitle.includes(itemTitle))
+            ) {
+                const id = item.id || item.redirectId || item.redirectIdStr;
+                if (id) return String(id);
+            }
+        }
+        const first = rows[0];
+        const id = first.id || first.redirectId || first.redirectIdStr;
+        if (id) return String(id);
+        throw new Error('Could not extract movie ID from search results');
+    }
+
+    processVideoResponse(videoData, media, season, episode, resolution, languageInfo) {
+        const streams = [];
+        const data = this.extractDataBlock(videoData);
+        const videoUrl = data.videoUrl;
+        if (!videoUrl) return streams;
+
+        let mediaTitle = media.title || 'Unknown';
+        if (media.year) mediaTitle += ` (${media.year})`;
+        if (season && episode) {
+            mediaTitle = `${media.title} S${String(season).padStart(2, '0')}E${String(
+                episode
+            ).padStart(2, '0')}`;
+        }
+
+        const quality = QUALITY_MAP[resolution] || `${resolution}p`;
+
+        if (Array.isArray(data.videos)) {
+            for (const video of data.videos) {
+                let q = String(
+                    video.resolutionDescription || video.resolution || quality
+                ).replace(/^(SD|HD|FHD)\s+/i, '');
+                const name = languageInfo
+                    ? `Castle ${languageInfo} - ${q}`
+                    : `Castle - ${q}`;
+                streams.push({
+                    name,
+                    title: mediaTitle,
+                    url: video.url || videoUrl,
+                    quality: q,
+                    size: this.formatSize(video.size),
+                    provider: 'castle',
+                });
+            }
+        } else {
+            const name = languageInfo
+                ? `Castle ${languageInfo} - ${quality}`
+                : `Castle - ${quality}`;
+            streams.push({
+                name,
+                title: mediaTitle,
+                url: videoUrl,
+                quality,
+                size: this.formatSize(data.size),
+                provider: 'castle',
+            });
+        }
+        return streams;
+    }
+
+    async fetchSources(tmdbId, season = 0, episode = 0) {
+        const mediaType = season && episode ? 'tv' : 'movie';
+        try {
+            const tmdbInfo = await this.getTmdbDetails(tmdbId, mediaType);
+            const securityKey = await this.getSecurityKey();
+
+            const searchTerm = tmdbInfo.year
+                ? `${tmdbInfo.title} ${tmdbInfo.year}`
+                : tmdbInfo.title;
+            const searchResult = await this.searchCastle(securityKey, searchTerm);
+            let movieId = this.findMovieId(searchResult, tmdbInfo);
+
+            let details = await this.getDetails(securityKey, movieId);
+
+            if (mediaType === 'tv') {
+                const data = this.extractDataBlock(details);
+                const seasons = data.seasons || [];
+                const s = seasons.find((x) => x.number === season);
+                if (s && s.movieId && String(s.movieId) !== movieId) {
+                    movieId = String(s.movieId);
+                    details = await this.getDetails(securityKey, movieId);
+                }
+            }
+
+            const data = this.extractDataBlock(details);
+            const episodes = data.episodes || [];
+
+            let episodeId = null;
+            if (mediaType === 'tv') {
+                const ep = episodes.find((e) => e.number === episode);
+                if (ep && ep.id) episodeId = String(ep.id);
+            } else if (episodes.length) {
+                episodeId = String(episodes[0].id);
+            }
+            if (!episodeId) throw new Error('Could not find episode ID');
+
+            const epObj = episodes.find((e) => String(e.id) === episodeId);
+            const tracks = epObj?.tracks || [];
+
+            const resolution = 2;
+            let allStreams = [];
+
+            for (let i = 0; i < tracks.length; i++) {
+                const track = tracks[i];
+                const langName =
+                    track.languageName || track.abbreviate || `Lang${i + 1}`;
+                if (track.existIndividualVideo && track.languageId) {
+                    try {
+                        const videoData = await this.getVideoV1(
+                            securityKey,
+                            movieId,
+                            episodeId,
+                            String(track.languageId),
+                            resolution
+                        );
+                        const langStreams = this.processVideoResponse(
+                            videoData,
+                            tmdbInfo,
+                            season,
+                            episode,
+                            resolution,
+                            `[${langName}]`
+                        );
+                        allStreams.push(...langStreams);
+                    } catch (e) {
+                        console.error(`[Castle] ${langName}: v1 failed - ${e?.message || e}`);
+                    }
+                }
+            }
+
+            if (!allStreams.length) {
+                const videoData = await this.getVideo2(
+                    securityKey,
+                    movieId,
+                    episodeId,
+                    resolution
+                );
+                allStreams = this.processVideoResponse(
+                    videoData,
+                    tmdbInfo,
+                    season,
+                    episode,
+                    resolution,
+                    '[Shared]'
+                );
+            }
+
+            allStreams.sort(
+                (a, b) => this.qualityValue(b.quality) - this.qualityValue(a.quality)
+            );
+            return allStreams;
+        } catch (e) {
+            console.error(`[Castle] Error: ${e?.message || e}`);
+            return [];
+        }
+    }
+}
+
+export async function getStream(args) {
+    const { id, s, e, sdk } = args || {};
+    const scraper = new CastleScraper(sdk?.tmdbApiKey);
+    const tmdbId = parseInt(String(id), 10);
+    const season = s != null ? parseInt(String(s), 10) : 0;
+    const episode = e != null ? parseInt(String(e), 10) : 0;
+
+    const streams = await scraper.fetchSources(tmdbId, season, episode).catch(() => []);
+    if (!streams || !streams.length) return null;
+
+    const seen = new Set();
+    const allUrls = [];
+
+    for (const item of streams) {
+        if (!item?.url || seen.has(item.url)) continue;
+        seen.add(item.url);
+        allUrls.push({
+            url: item.url,
+            server: item.name || 'Castle',
+            quality: item.quality || 'Auto',
+            type: item.url.includes('.m3u8')
+                ? 'hls'
+                : item.url.includes('.mpd')
+                    ? 'dash'
+                    : 'mp4',
+            headers: CASTLE_PLAYBACK_HEADERS,
+        });
+    }
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls,
+    };
+}

package/src/sources/framextv.js

@@ -0,0 +1,126 @@
+const FRAMEX_BASE = 'https://api.framextv.cc';
+const STREAMOS_BASE = 'https://api.streamos.top';
+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 FRAMEX_HEADERS = {
+    'User-Agent': UA,
+    Referer: 'https://framextv.cc/',
+    Origin: 'https://framextv.cc',
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+
+const STREAMOS_HEADERS = {
+    'User-Agent': UA,
+    Referer: 'https://streamos.top/',
+    Origin: 'https://streamos.top',
+};
+
+const STREAMOS_SERVERS = [
+    'auto',
+    'miami',
+    'boise',
+    'vegas',
+    'reno',
+    'oakland',
+    'seattle',
+    'phoenix',
+    'atlanta',
+    'portland',
+    'austin',
+    'dallas',
+    'tampa',
+    'orlando',
+    'munich',
+    'berlin',
+    'france',
+    'india',
+    'mexico',
+    'delhi',
+];
+
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    const isTv = s != null && e != null;
+
+    const framexQuery = isTv
+        ? `type=tv&id=${id}&season=${s}&episode=${e}&codecs=hevc`
+        : `type=movie&id=${id}&codecs=hevc`;
+
+    const framexUrls = [
+        `${FRAMEX_BASE}/api/stream?${framexQuery}`,
+        `${FRAMEX_BASE}/api/stream?${framexQuery}&provider=sparky`,
+        `${FRAMEX_BASE}/api/stream?${framexQuery}&provider=titan`,
+    ];
+
+    const streamOsBaseQuery = isTv
+        ? `id=${id}&season=${s}&episode=${e}&kind=tv`
+        : `id=${id}&kind=movie`;
+
+    const allUrls = [];
+    const seen = new Set();
+
+    const framexPromises = Promise.all(
+        framexUrls.map(url =>
+            fetch(url, { headers: FRAMEX_HEADERS })
+                .then(r => (r.ok ? r.json() : null))
+                .catch(() => null)
+        )
+    );
+
+    const streamOsChecks = Promise.all(
+        STREAMOS_SERVERS.slice(0, 8).map(async server => {
+            const serverParam = server === 'auto' ? '' : `&server=${server}`;
+            const url = `${STREAMOS_BASE}/api/relay/hls?${streamOsBaseQuery}${serverParam}`;
+            try {
+                const res = await fetch(url, { method: 'HEAD', headers: STREAMOS_HEADERS });
+                if (res.ok) {
+                    return {
+                        url,
+                        server: `StreamOS - ${server.toUpperCase()}`,
+                        quality: '1080p',
+                        type: 'hls',
+                        headers: STREAMOS_HEADERS,
+                    };
+                }
+            } catch { }
+            return null;
+        })
+    );
+
+    const [framexResults, streamOsResults] = await Promise.all([framexPromises, streamOsChecks]);
+
+    for (const data of framexResults) {
+        if (!data?.success || !Array.isArray(data.sources)) continue;
+        for (const src of data.sources) {
+            if (!src?.url || seen.has(src.url)) continue;
+            seen.add(src.url);
+            allUrls.push({
+                url: src.url,
+                server: `FrameX - ${src.server || data.provider || 'Direct'}`,
+                quality: src.quality || 'Auto',
+                type: src.type || (src.url.includes('.m3u8') ? 'hls' : 'mp4'),
+                headers: {
+                    'User-Agent': UA,
+                    Referer: 'https://framextv.cc/',
+                    Origin: 'https://framextv.cc',
+                },
+            });
+        }
+    }
+
+    for (const stream of streamOsResults) {
+        if (stream && !seen.has(stream.url)) {
+            seen.add(stream.url);
+            allUrls.push(stream);
+        }
+    }
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls,
+    };
+}

package/src/sources/meowtv.js

@@ -0,0 +1,140 @@
+const BASE_URL = 'https://api.meowtv.ru';
+const DEC_API = 'https://enc-dec.app/api';
+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,
+    Origin: 'https://meowtv.ru',
+    Referer: 'https://meowtv.ru/',
+    Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+
+const SERVERS = [
+    { id: 'acme', label: 'Acme' },
+    { id: 'dcloud', label: 'Dcloud' },
+    { id: 'tik', label: 'TCloud' },
+    { id: 'ipcloud', label: 'IPcloud' },
+    { id: 'turkce', label: 'Türkçe', movieOnly: true },
+    { id: 'hindi', label: 'Hindi' },
+    { id: 'english', label: 'English' },
+];
+
+async function decryptMeow(data) {
+    try {
+        const res = await fetch(`${DEC_API}/dec-meowtv`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': UA,
+            },
+            body: JSON.stringify({ data }),
+        });
+        if (!res.ok) return null;
+        const json = await res.json();
+        return json?.status === 200 ? json.result : null;
+    } catch {
+        return null;
+    }
+}
+
+function extractUrls(result) {
+    const urls = [];
+    if (!result) return urls;
+    if (typeof result === 'string' && /^https?:\/\//.test(result)) {
+        urls.push({ url: result, quality: 'Auto', type: result.includes('.m3u8') ? 'hls' : 'mp4' });
+    } else if (result?.url && typeof result.url === 'string') {
+        urls.push({
+            url: result.url,
+            quality: result.quality || 'Auto',
+            type: result.type || (result.url.includes('.m3u8') ? 'hls' : 'mp4'),
+        });
+    } else if (Array.isArray(result?.sources)) {
+        for (const s of result.sources) {
+            if (s?.url) {
+                urls.push({
+                    url: s.url,
+                    quality: s.quality || 'Auto',
+                    type: s.type || (s.url.includes('.m3u8') ? 'hls' : 'mp4'),
+                });
+            }
+        }
+    } else if (result?.stream) {
+        const sUrl = typeof result.stream === 'string' ? result.stream : result.stream?.url;
+        if (sUrl) {
+            urls.push({
+                url: sUrl,
+                quality: result.stream?.quality || 'Auto',
+                type: sUrl.includes('.m3u8') ? 'hls' : 'mp4',
+            });
+        }
+    }
+    return urls;
+}
+
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    const isTv = s != null && e != null;
+
+    const ticketRes = await fetch(`${BASE_URL}/streams/ticket`, {
+        method: 'POST',
+        headers: HEADERS,
+    }).then(r => (r.ok ? r.json() : null)).catch(() => null);
+
+    const ticket = ticketRes?.ticket;
+    if (!ticket) return null;
+
+    const requestHeaders = {
+        ...HEADERS,
+        'X-Stream-Ticket': ticket,
+    };
+
+    const targetServers = isTv ? SERVERS.filter(srv => !srv.movieOnly) : SERVERS;
+
+    const responses = await Promise.allSettled(
+        targetServers.map(async server => {
+            const url = isTv
+                ? `${BASE_URL}/streams/tv/${id}/${s}/${e}?s=${encodeURIComponent(server.id)}`
+                : `${BASE_URL}/streams/movie/${id}?s=${encodeURIComponent(server.id)}`;
+
+            const res = await fetch(url, { headers: requestHeaders });
+            if (!res.ok) return null;
+            const data = await res.json();
+            const decrypted = await decryptMeow(data);
+            return { server, decrypted };
+        })
+    );
+
+    const allUrls = [];
+    const seen = new Set();
+
+    for (const res of responses) {
+        if (res.status !== 'fulfilled' || !res.value?.decrypted) continue;
+        const { server, decrypted } = res.value;
+        const found = extractUrls(decrypted);
+
+        for (const item of found) {
+            if (!item?.url || seen.has(item.url)) continue;
+            seen.add(item.url);
+            allUrls.push({
+                url: item.url,
+                server: `MeowTV - ${server.label}`,
+                quality: item.quality || 'Auto',
+                type: item.type || (item.url.includes('.m3u8') ? 'hls' : 'mp4'),
+                headers: {
+                    Referer: 'https://meowtv.ru/',
+                    Origin: 'https://meowtv.ru',
+                    'User-Agent': UA,
+                },
+            });
+        }
+    }
+
+    if (!allUrls.length) return null;
+
+    return {
+        url: allUrls[0].url,
+        headers: allUrls[0].headers,
+        allUrls,
+    };
+}