mirror of
https://github.com/Inside4ndroid/TMDB-Embed-API.git
synced 2026-10-22 09:35:11 +00:00
423 lines
19 KiB
JavaScript
423 lines
19 KiB
JavaScript
#!/usr/bin/env node
|
|
const cheerio = require('cheerio');
|
|
// --- Constants ---
|
|
const VIDSRC_PROXY_URL = process.env.VIDSRC_PROXY_URL;
|
|
let BASEDOM = "https://cloudnestra.com"; // This can be updated by serversLoad
|
|
const SOURCE_URL = "https://vidsrc.xyz/embed";
|
|
// --- Helper: Conditional Proxied Fetch ---
|
|
// This function wraps the native fetch. If VIDSRC_PROXY_URL is set in the environment,
|
|
// it routes requests through the proxy. Otherwise, it makes a direct request.
|
|
async function fetchWrapper(url, options) {
|
|
if (VIDSRC_PROXY_URL) {
|
|
const proxiedUrl = `${VIDSRC_PROXY_URL}${encodeURIComponent(url)}`;
|
|
console.log(`[VidSrc Proxy] Fetching: ${url} via proxy`);
|
|
// Note: The proxy will handle the actual fetching, so we send the request to the proxy URL.
|
|
// We pass the original headers in the options, the proxy should forward them.
|
|
return fetch(proxiedUrl, options);
|
|
}
|
|
// If no proxy is set, fetch directly.
|
|
console.log(`[VidSrc Direct] Fetching: ${url}`);
|
|
return fetch(url, options);
|
|
}
|
|
// --- Helper Functions (copied and adapted from src/extractor.ts) ---
|
|
async function serversLoad(html) {
|
|
const $ = cheerio.load(html);
|
|
const servers = [];
|
|
const title = $("title").text() ?? "";
|
|
const baseFrameSrc = $("iframe").attr("src") ?? "";
|
|
if (baseFrameSrc) {
|
|
try {
|
|
const fullUrl = baseFrameSrc.startsWith("//") ? "https:" + baseFrameSrc : baseFrameSrc;
|
|
BASEDOM = new URL(fullUrl).origin;
|
|
}
|
|
catch (e) {
|
|
console.warn(`(Attempt 1) Failed to parse base URL from iframe src: ${baseFrameSrc} using new URL(), error: ${e.message}`);
|
|
// Attempt 2: Regex fallback for origin
|
|
const originMatch = (baseFrameSrc.startsWith("//") ? "https:" + baseFrameSrc : baseFrameSrc).match(/^(https?:\/\/[^/]+)/);
|
|
if (originMatch && originMatch[1]) {
|
|
BASEDOM = originMatch[1];
|
|
console.log(`(Attempt 2) Successfully extracted origin using regex: ${BASEDOM}`);
|
|
} else {
|
|
console.error(`(Attempt 2) Failed to extract origin using regex from: ${baseFrameSrc}. Using default: ${BASEDOM}`);
|
|
// Keep the default BASEDOM = "https://cloudnestra.com" if all fails
|
|
}
|
|
}
|
|
}
|
|
$(".serversList .server").each((index, element) => {
|
|
const server = $(element);
|
|
servers.push({
|
|
name: server.text().trim(),
|
|
dataHash: server.attr("data-hash") ?? null,
|
|
});
|
|
});
|
|
return {
|
|
servers: servers,
|
|
title: title,
|
|
};
|
|
}
|
|
async function parseMasterM3U8(m3u8Content, masterM3U8Url) {
|
|
const lines = m3u8Content.split('\n').map(line => line.trim());
|
|
const streams = [];
|
|
for (let i = 0; i < lines.length; i++) {
|
|
if (lines[i].startsWith("#EXT-X-STREAM-INF:")) {
|
|
const infoLine = lines[i];
|
|
let quality = "unknown";
|
|
const resolutionMatch = infoLine.match(/RESOLUTION=(\d+x\d+)/);
|
|
if (resolutionMatch && resolutionMatch[1]) {
|
|
quality = resolutionMatch[1];
|
|
}
|
|
else {
|
|
const bandwidthMatch = infoLine.match(/BANDWIDTH=(\d+)/);
|
|
if (bandwidthMatch && bandwidthMatch[1]) {
|
|
quality = `${Math.round(parseInt(bandwidthMatch[1]) / 1000)}kbps`;
|
|
}
|
|
}
|
|
if (i + 1 < lines.length && lines[i + 1] && !lines[i + 1].startsWith("#")) {
|
|
const streamUrlPart = lines[i + 1];
|
|
try {
|
|
const fullStreamUrl = new URL(streamUrlPart, masterM3U8Url).href;
|
|
streams.push({ quality: quality, url: fullStreamUrl });
|
|
}
|
|
catch (e) {
|
|
console.error(`Error constructing URL for stream part: ${streamUrlPart} with base: ${masterM3U8Url}`, e);
|
|
streams.push({ quality: quality, url: streamUrlPart }); // Store partial URL as a fallback
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sort streams by quality (highest first)
|
|
streams.sort((a, b) => {
|
|
// Extract resolution height from quality (e.g., "1280x720" -> 720)
|
|
const getHeight = (quality) => {
|
|
const match = quality.match(/(\d+)x(\d+)/);
|
|
return match ? parseInt(match[2], 10) : 0;
|
|
};
|
|
|
|
const heightA = getHeight(a.quality);
|
|
const heightB = getHeight(b.quality);
|
|
|
|
// Higher resolution comes first
|
|
return heightB - heightA;
|
|
});
|
|
|
|
return streams;
|
|
}
|
|
async function PRORCPhandler(prorcp) {
|
|
try {
|
|
const prorcpUrl = `${BASEDOM}/prorcp/${prorcp}`;
|
|
const prorcpFetch = await fetchWrapper(prorcpUrl, {
|
|
headers: {
|
|
"accept": "*/*", "accept-language": "en-US,en;q=0.9", "priority": "u=1",
|
|
"sec-ch-ua": "\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"",
|
|
"sec-ch-ua-mobile": "?0", "sec-ch-ua-platform": "\"Windows\"",
|
|
"sec-fetch-dest": "script", "sec-fetch-mode": "no-cors", "sec-fetch-site": "same-origin",
|
|
'Sec-Fetch-Dest': 'iframe', "Referer": `${BASEDOM}/`, "Referrer-Policy": "origin",
|
|
},
|
|
timeout: 10000
|
|
});
|
|
if (!prorcpFetch.ok) {
|
|
console.error(`Failed to fetch prorcp: ${prorcpUrl}, status: ${prorcpFetch.status}`);
|
|
return null;
|
|
}
|
|
const prorcpResponse = await prorcpFetch.text();
|
|
const regex = /file:\s*'([^']*)'/gm;
|
|
const match = regex.exec(prorcpResponse);
|
|
if (match && match[1]) {
|
|
const masterM3U8Url = match[1];
|
|
const m3u8FileFetch = await fetchWrapper(masterM3U8Url, {
|
|
headers: { "Referer": prorcpUrl, "Accept": "*/*" },
|
|
timeout: 10000
|
|
});
|
|
if (!m3u8FileFetch.ok) {
|
|
console.error(`Failed to fetch master M3U8: ${masterM3U8Url}, status: ${m3u8FileFetch.status}`);
|
|
return null;
|
|
}
|
|
const m3u8Content = await m3u8FileFetch.text();
|
|
return parseMasterM3U8(m3u8Content, masterM3U8Url);
|
|
}
|
|
console.warn("No master M3U8 URL found in prorcp response for:", prorcpUrl);
|
|
return null;
|
|
}
|
|
catch (error) {
|
|
console.error(`Error in PRORCPhandler for ${BASEDOM}/prorcp/${prorcp}:`, error);
|
|
return null;
|
|
}
|
|
}
|
|
async function SRCRCPhandler(srcrcpPath, refererForSrcrcp) {
|
|
try {
|
|
const srcrcpUrl = BASEDOM + srcrcpPath;
|
|
console.log(`[VidSrc - SRCRCP] Fetching: ${srcrcpUrl} (Referer: ${refererForSrcrcp})`);
|
|
const response = await fetchWrapper(srcrcpUrl, {
|
|
headers: {
|
|
"accept": "*/*",
|
|
"accept-language": "en-US,en;q=0.9",
|
|
"sec-ch-ua": "\"Chromium\";v=\"128\", \"Not;A=Brand\";v=\"24\", \"Google Chrome\";v=\"128\"",
|
|
"sec-ch-ua-mobile": "?0",
|
|
"sec-ch-ua-platform": "\"Windows\"",
|
|
"sec-fetch-dest": "iframe",
|
|
"sec-fetch-mode": "navigate",
|
|
"sec-fetch-site": "same-origin", // This might need to be 'cross-site' if BASEDOM's origin differs from srcrcp link's origin
|
|
"Referer": refererForSrcrcp,
|
|
"Referrer-Policy": "origin",
|
|
},
|
|
timeout: 10000
|
|
});
|
|
|
|
if (!response.ok) {
|
|
console.error(`[VidSrc - SRCRCP] Failed to fetch ${srcrcpUrl}, status: ${response.status}`);
|
|
return null;
|
|
}
|
|
|
|
const responseText = await response.text();
|
|
console.log(`[VidSrc - SRCRCP] Response from ${srcrcpUrl} (first 500 chars): ${responseText.substring(0, 500)}`);
|
|
|
|
// Attempt 1: Check for "file: '...'" like in PRORCP
|
|
const fileRegex = /file:\s*'([^']*)'/gm;
|
|
const fileMatch = fileRegex.exec(responseText);
|
|
if (fileMatch && fileMatch[1]) {
|
|
const masterM3U8Url = fileMatch[1];
|
|
console.log(`[VidSrc - SRCRCP] Found M3U8 URL (via fileMatch): ${masterM3U8Url}`);
|
|
const m3u8FileFetch = await fetchWrapper(masterM3U8Url, {
|
|
headers: { "Referer": srcrcpUrl, "Accept": "*/*" },
|
|
timeout: 10000
|
|
});
|
|
if (!m3u8FileFetch.ok) {
|
|
console.error(`[VidSrc - SRCRCP] Failed to fetch master M3U8: ${masterM3U8Url}, status: ${m3u8FileFetch.status}`);
|
|
return null;
|
|
}
|
|
const m3u8Content = await m3u8FileFetch.text();
|
|
return parseMasterM3U8(m3u8Content, masterM3U8Url);
|
|
}
|
|
|
|
// Attempt 2: Check if the responseText itself is an M3U8 playlist
|
|
if (responseText.trim().startsWith("#EXTM3U")) {
|
|
console.log(`[VidSrc - SRCRCP] Response from ${srcrcpUrl} appears to be an M3U8 playlist directly.`);
|
|
return parseMasterM3U8(responseText, srcrcpUrl);
|
|
}
|
|
|
|
// Attempt 3: Look for sources = [...] or sources: [...] in script tags or in JSON-like structures
|
|
const $ = cheerio.load(responseText);
|
|
let sourcesFound = null;
|
|
$('script').each((i, script) => {
|
|
const scriptContent = $(script).html();
|
|
if (scriptContent) {
|
|
// Regex for various ways sources might be defined
|
|
const sourcesRegexes = [
|
|
/sources\s*[:=]\s*(\[[^\]]*\{(?:\s*|.*?)file\s*:\s*['"]([^'"]+)['"](?:\s*|.*?)\}[^\]]*\])/si, // extracts the URL from sources: [{file: "URL"}]
|
|
/playerInstance\.setup\s*\(\s*\{\s*sources\s*:\s*(\[[^\]]*\{(?:\s*|.*?)file\s*:\s*['"]([^'"]+)['"](?:\s*|.*?)\}[^\]]*\])/si, // for playerInstance.setup({sources: [{file: "URL"}]})
|
|
/file\s*:\s*['"]([^'"]+\.m3u8[^'"]*)['"]/i, // Direct M3U8 link in a var or object e.g. file: "URL.m3u8"
|
|
/src\s*:\s*['"]([^'"]+\.m3u8[^'"]*)['"]/i, // Direct M3U8 link e.g. src: "URL.m3u8"
|
|
/loadSource\(['"]([^'"]+\.m3u8[^'"]*)['"]\)/i, // For .loadSource("URL.m3u8")
|
|
/new\s+Player\([^)]*\{\s*src\s*:\s*['"]([^'"]+)['"]\s*\}\s*\)/i // For new Player({src: "URL"})
|
|
];
|
|
for (const regex of sourcesRegexes) {
|
|
const sourcesMatch = scriptContent.match(regex);
|
|
// For regexes that capture a JSON array-like structure in group 1 and then the URL in group 2 (first two regexes)
|
|
if (regex.source.includes('file') && regex.source.includes('sources')) { // Heuristic to identify complex sources regex capturing group 2
|
|
if (sourcesMatch && sourcesMatch[2]) { // URL is in group 2
|
|
console.log(`[VidSrc - SRCRCP] Found M3U8 URL (script complex): ${sourcesMatch[2]}`);
|
|
sourcesFound = [{ quality: 'default', url: sourcesMatch[2] }];
|
|
return false; // break cheerio loop
|
|
}
|
|
}
|
|
// For simpler regexes where URL is in group 1
|
|
else if (sourcesMatch && sourcesMatch[1]) {
|
|
console.log(`[VidSrc - SRCRCP] Found M3U8 URL (script simple): ${sourcesMatch[1]}`);
|
|
sourcesFound = [{ quality: 'default', url: sourcesMatch[1] }];
|
|
return false; // break cheerio loop
|
|
}
|
|
}
|
|
// Fallback: Look for any absolute .m3u8 URL within the script tag
|
|
if (!sourcesFound) {
|
|
const m3u8GenericMatch = scriptContent.match(/['"](https?:\/\/[^'"\s]+\.m3u8[^'"\s]*)['"]/i);
|
|
if (m3u8GenericMatch && m3u8GenericMatch[1]) {
|
|
console.log(`[VidSrc - SRCRCP] Found M3U8 URL (script generic fallback): ${m3u8GenericMatch[1]}`);
|
|
sourcesFound = [{ quality: 'default', url: m3u8GenericMatch[1] }];
|
|
return false; // break cheerio loop
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
if (sourcesFound && sourcesFound.length > 0) {
|
|
// Process the first valid M3U8 URL found, or return direct links
|
|
const m3u8Source = sourcesFound.find(s => s.url && s.url.includes('.m3u8'));
|
|
if (m3u8Source) {
|
|
console.log(`[VidSrc - SRCRCP] First M3U8 source from script: ${m3u8Source.url}`);
|
|
// Ensure URL is absolute
|
|
const absoluteM3u8Url = m3u8Source.url.startsWith('http') ? m3u8Source.url : new URL(m3u8Source.url, srcrcpUrl).href;
|
|
const m3u8FileFetch = await fetchWrapper(absoluteM3u8Url, {
|
|
headers: { "Referer": srcrcpUrl, "Accept": "*/*" },
|
|
timeout: 10000
|
|
});
|
|
if (!m3u8FileFetch.ok) {
|
|
console.error(`[VidSrc - SRCRCP] Failed to fetch M3U8 from script source: ${absoluteM3u8Url}, status: ${m3u8FileFetch.status}`);
|
|
return null;
|
|
}
|
|
const m3u8Content = await m3u8FileFetch.text();
|
|
return parseMasterM3U8(m3u8Content, absoluteM3u8Url);
|
|
} else {
|
|
// Assuming direct links if no .m3u8 found in the sources array
|
|
console.log(`[VidSrc - SRCRCP] Assuming direct links from script sources:`, sourcesFound);
|
|
return sourcesFound.map(s => ({
|
|
quality: s.quality || s.label || 'auto',
|
|
url: s.url.startsWith('http') ? s.url : new URL(s.url, srcrcpUrl).href
|
|
}));
|
|
}
|
|
}
|
|
|
|
console.warn(`[VidSrc - SRCRCP] No stream extraction method succeeded for ${srcrcpUrl}`);
|
|
return null;
|
|
} catch (error) {
|
|
console.error(`[VidSrc - SRCRCP] Error in SRCRCPhandler for ${srcrcpPath}:`, error);
|
|
return null;
|
|
}
|
|
}
|
|
async function rcpGrabber(html) {
|
|
const regex = /src:\s*'([^']*)'/;
|
|
const match = html.match(regex);
|
|
if (!match || !match[1])
|
|
return null;
|
|
return { metadata: { image: "" }, data: match[1] };
|
|
}
|
|
function getObject(id) {
|
|
const arr = id.split(':');
|
|
return { id: arr[0], season: arr[1], episode: arr[2] };
|
|
}
|
|
function getUrl(id, type) {
|
|
if (type === "movie") {
|
|
return `${SOURCE_URL}/movie/${id}`;
|
|
}
|
|
else {
|
|
const obj = getObject(id);
|
|
return `${SOURCE_URL}/tv/${obj.id}/${obj.season}-${obj.episode}`;
|
|
}
|
|
}
|
|
async function getStreamContent(id, type) {
|
|
const url = getUrl(id, type);
|
|
const embedRes = await fetchWrapper(url, { headers: { "Referer": SOURCE_URL } });
|
|
if (!embedRes.ok) {
|
|
console.error(`Failed to fetch embed page ${url}: ${embedRes.status}`);
|
|
return [];
|
|
}
|
|
const embedResp = await embedRes.text();
|
|
const { servers, title } = await serversLoad(embedResp);
|
|
const apiResponse = [];
|
|
|
|
// MODIFIED: Process servers in parallel
|
|
const serverPromises = servers.map(async (server) => {
|
|
if (!server.dataHash) return null; // Skip servers without dataHash
|
|
|
|
try {
|
|
const rcpUrl = `${BASEDOM}/rcp/${server.dataHash}`;
|
|
const rcpRes = await fetchWrapper(rcpUrl, {
|
|
headers: { 'Sec-Fetch-Dest': 'iframe', "Referer": url }
|
|
});
|
|
if (!rcpRes.ok) {
|
|
console.warn(`RCP fetch failed for server ${server.name}: ${rcpRes.status}`);
|
|
return null; // Failed to fetch RCP
|
|
}
|
|
const rcpHtml = await rcpRes.text();
|
|
const rcpData = await rcpGrabber(rcpHtml);
|
|
|
|
if (!rcpData || !rcpData.data) {
|
|
console.warn(`Skipping server ${server.name} due to missing rcp data.`);
|
|
return null; // Missing RCP data
|
|
}
|
|
|
|
let streamDetails = null;
|
|
if (rcpData.data.startsWith("/prorcp/")) {
|
|
streamDetails = await PRORCPhandler(rcpData.data.replace("/prorcp/", ""));
|
|
} else if (rcpData.data.startsWith("/srcrcp/")) {
|
|
if (server.name === "Superembed" || server.name === "2Embed") {
|
|
console.warn(`[VidSrc] Skipping SRCRCP for known problematic server: ${server.name}`);
|
|
return null;
|
|
}
|
|
streamDetails = await SRCRCPhandler(rcpData.data, rcpUrl); // Pass rcpUrl as referer
|
|
} else {
|
|
console.warn(`Unhandled rcp data type for server ${server.name}: ${rcpData.data.substring(0, 50)}`);
|
|
return null; // Unhandled type
|
|
}
|
|
|
|
if (streamDetails && streamDetails.length > 0) {
|
|
return {
|
|
name: title,
|
|
image: rcpData.metadata.image,
|
|
mediaId: id,
|
|
streams: streamDetails,
|
|
referer: BASEDOM,
|
|
};
|
|
} else {
|
|
console.warn(`No stream details from handler for server ${server.name} (${rcpData.data})`);
|
|
return null; // No stream details found by the handler
|
|
}
|
|
} catch (e) {
|
|
console.error(`Error processing server ${server.name} (${server.dataHash}):`, e);
|
|
return null; // Error during server processing
|
|
}
|
|
});
|
|
|
|
const results = await Promise.all(serverPromises);
|
|
// Filter out null results (failed servers or no streams) and add valid results to apiResponse
|
|
results.forEach(result => {
|
|
if (result) {
|
|
apiResponse.push(result);
|
|
}
|
|
});
|
|
// END MODIFICATION
|
|
|
|
return apiResponse;
|
|
}
|
|
// --- Main execution logic (conditional) ---
|
|
async function main() {
|
|
const args = process.argv.slice(2);
|
|
if (args.length < 2) {
|
|
console.error("Usage: node vidsrcextractor.js <id> <type>");
|
|
console.error("Example (movie): node vidsrcextractor.js tt0111161 movie");
|
|
console.error("Example (series): node vidsrcextractor.js tt0944947:1:1 series"); // Game of Thrones S1E1
|
|
return 1; // error code
|
|
}
|
|
const id = args[0];
|
|
const type = args[1];
|
|
if (type !== "movie" && type !== "series") {
|
|
console.error("Invalid type. Must be 'movie' or 'series'.");
|
|
return 1;
|
|
}
|
|
if (type === "series" && id.split(':').length < 3) {
|
|
console.error("Invalid series ID format. Expected 'ttID:season:episode' (e.g., tt0944947:1:1).");
|
|
return 1;
|
|
}
|
|
console.log(`Fetching streams for ID: ${id}, Type: ${type}`);
|
|
try {
|
|
const results = await getStreamContent(id, type);
|
|
if (results && results.length > 0) {
|
|
console.log("Extracted Data:");
|
|
console.log(JSON.stringify(results, null, 2));
|
|
} else {
|
|
console.log("No streams found or an error occurred.");
|
|
}
|
|
return 0;
|
|
} catch (error) {
|
|
console.error("Error during extraction process:", error);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// Export the function for use in other modules
|
|
module.exports = { getStreamContent };
|
|
|
|
// Run main only if the script is executed directly
|
|
if (require.main === module) {
|
|
main()
|
|
.then(code => {
|
|
if (code !== 0) {
|
|
console.error(`[vidsrcextractor] Finished with non-zero code ${code}`);
|
|
}
|
|
})
|
|
.catch(error => {
|
|
console.error("Unhandled error in main execution:", error);
|
|
});
|
|
}
|