@vyla-entertainment/sdk 1.20.0 → 1.22.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/cinecat.js

@@ -1,19 +1,38 @@
-import { fetchJson } from '../utils/helpers.js';
-
-export async function getStream({ id, s, e }) {
-    const isTv = s != null && e != null;
-    const url = isTv
-        ? `https://zcdn.bluevelvet.space/cdn?tmdb=${id}&type=tv&season=${s}&episode=${e}`
-        : `https://zcdn.bluevelvet.space/cdn?tmdb=${id}&type=movie`;
-
-    const res = await fetchJson(url);
-    if (!res || !res.ready || !res.url) return null;
-
-    return {
-        url: res.url,
-        headers: {
-            Referer: 'https://zcdn.bluevelvet.space/',
-            Origin: 'https://zcdn.bluevelvet.space',
-        }
-    };
+import { fetchJson } from '../utils/helpers.js';
+
+const BASE_URL = 'https://zcdn.bluevelvet.space';
+
+export async function getStream(args) {
+    const { id, s, e } = args || {};
+    const isTv = s != null && e != null;
+
+    const url = isTv
+        ? `${BASE_URL}/cdn?tmdb=${id}&type=tv&season=${s}&episode=${e}`
+        : `${BASE_URL}/cdn?tmdb=${id}&type=movie`;
+
+    try {
+        const res = await fetchJson(url);
+        if (!res || !res.ready || !res.url) return null;
+
+        const headers = {
+            Referer: `${BASE_URL}/`,
+            Origin: BASE_URL,
+        };
+
+        const allUrls = [{
+            url: res.url,
+            server: 'CineCat',
+            quality: 'Auto',
+            type: res.url.includes('.m3u8') ? 'hls' : 'mp4',
+            headers,
+        }];
+
+        return {
+            url: res.url,
+            headers,
+            allUrls,
+        };
+    } catch {
+        return null;
+    }
 }