@vyla-entertainment/sdk 1.15.0 → 1.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vyla-entertainment/sdk",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "scripts": {
     "test": "node test/index.js"
   },
@@ -29,5 +29,8 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "node-tls-client": "^2.1.0"
   }
 }

package/src/config.js

@@ -1,11 +1,23 @@
-// Currently active sources reported on 6:18:22 PM PST 9/13/2026
-
-// None Anime Tested: 936075
-// Anime Tested: 37854
-
-// Fshare/Fsonic Tested: 155 ( they don't have Michael )
-
 export const SOURCES = [
+    {
+        key: '3eyedraven',
+        label: '3eyedraven',
+        sourceFile: '3eyedraven',
+        proxyParam: '3er',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: false,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /3eyedraven\.watch/i,
+            headers: {
+                Referer: 'https://3eyedraven.watch/',
+                Origin: 'https://3eyedraven.watch',
+            },
+        }],
+    },
+
     {
         key: '123anime',
         label: '123Anime',
@@ -106,6 +118,25 @@ export const SOURCES = [
         }],
     },
 
+    {
+        key: 'cinemaarmy',
+        label: 'CinemaArmy',
+        sourceFile: 'cinemaarmy',
+        proxyParam: 'ca',
+        timeout: 30000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /cinema\.army/i,
+            headers: {
+                Referer: 'https://cinema.army/',
+                Origin: 'https://cinema.army',
+            },
+        }],
+    },
+
     {
         key: 'dulo',
         label: 'Dulo',
@@ -191,6 +222,25 @@ export const SOURCES = [
         },
     },
 
+    {
+        key: 'movenerds',
+        label: 'MoverNerds',
+        sourceFile: 'movenerds',
+        proxyParam: 'mnr',
+        timeout: 30000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /movenerds\.space/i,
+            headers: {
+                Referer: 'https://movenerds.space/',
+                Origin: 'https://movenerds.space',
+            },
+        }],
+    },
+
     {
         key: 'movienight',
         label: 'MovieNight',
@@ -229,6 +279,25 @@ export const SOURCES = [
         }],
     },
 
+    {
+        key: 'peestream',
+        label: 'PeeStream',
+        sourceFile: 'peestream',
+        proxyParam: 'pee',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /peestream\.in/i,
+            headers: {
+                Referer: 'https://peestream.in/',
+                Origin: 'https://peestream.in',
+            },
+        }],
+    },
+
     {
         key: 'pengu',
         label: 'Pengu',
@@ -293,6 +362,26 @@ export const SOURCES = [
             },
         }],
     },
+
+    {
+        key: 'thugtv',
+        label: 'ThugTV',
+        sourceFile: 'thugtv',
+        proxyParam: 'tv',
+        timeout: 30000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /thugtv\.online|thuktv\.onrender\.com/i,
+            headers: {
+                Referer: 'https://thugtv.online/',
+                Origin: 'https://thugtv.online',
+            },
+        }],
+    },
+
     {
         key: 'vidapi',
         label: 'VidAPI',
@@ -426,6 +515,25 @@ export const SOURCES = [
         multiUrl: true,
     },
 
+    {
+        key: 'vidy',
+        label: 'Vidy',
+        sourceFile: 'vidy',
+        proxyParam: 'vy',
+        timeout: 25000,
+        jitter: 500,
+        retries: 2,
+        multiUrl: true,
+        skipProxy: true,
+        cdnHeaders: [{
+            pattern: /wecollege\.net|vidy\.st/i,
+            headers: {
+                Referer: 'https://www.vidy.st/',
+                Origin: 'https://www.vidy.st',
+            },
+        }],
+    },
+
     {
         key: 'vidzee',
         label: 'VidZee',

package/src/manga/atsu.js

@@ -0,0 +1,168 @@
+import { Session, ClientIdentifier, initTLS, destroyTLS } from "node-tls-client";
+
+const BASE_URL = "https://atsu.moe";
+const CDN_URL = "https://cdn.atsu.moe";
+
+const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+
+const HEADERS = {
+    "User-Agent": UA,
+    "Accept": "*/*",
+    "Accept-Language": "en-US,en;q=0.9",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Cache-Control": "no-cache",
+    "Pragma": "no-cache",
+    "Referer": `${BASE_URL}/`,
+    "Origin": BASE_URL,
+    "Sec-Ch-Ua": '"Chromium";v="131", "Not_A Brand";v="24"',
+    "Sec-Ch-Ua-Mobile": "?0",
+    "Sec-Ch-Ua-Platform": '"Windows"',
+    "Sec-Fetch-Dest": "empty",
+    "Sec-Fetch-Mode": "cors",
+    "Sec-Fetch-Site": "same-origin",
+    "Priority": "u=1, i"
+};
+
+let tlsInitialized = false;
+let session = null;
+
+async function ensureSession() {
+    if (!tlsInitialized) {
+        await initTLS();
+        tlsInitialized = true;
+    }
+    if (!session) {
+        session = new Session({
+            clientIdentifier: ClientIdentifier.chrome_131,
+            timeout: 15000,
+            insecureSkipVerify: false,
+        });
+    }
+    return session;
+}
+
+const formatAssetUrl = (url) => {
+    if (!url) return null;
+    if (url.startsWith("http://") || url.startsWith("https://")) return url;
+    if (url.startsWith("/static/")) return `${CDN_URL}${url}`;
+    if (url.startsWith("/")) return `${CDN_URL}${url}`;
+    return `${CDN_URL}/static/${url}`;
+};
+
+async function atsuFetch(url) {
+    const sess = await ensureSession();
+    const res = await sess.get(url, { headers: HEADERS });
+    if (res.status !== 200) {
+        throw new Error(`Atsu request failed: ${res.status}`);
+    }
+    const text = await res.text();
+    return JSON.parse(text);
+}
+
+export async function searchManga(query, page = 1, perPage = 12) {
+    const params = new URLSearchParams({
+        q: query,
+        query_by: "title,englishTitle,otherNames,authors,acronyms",
+        query_by_weights: "4,3,2,2,1",
+        num_typos: "4,3,2,1,0",
+        prefix: "true,true,true,true,false",
+        include_fields: "id,title,englishTitle,authors,poster,posterSmall,posterMedium,type,medium,isAdult,status,year,mbRating,popularity,dateAdded",
+        filter_by: "isAdult:=false && views:>0 && hidden:!=true",
+        page: String(page),
+        per_page: String(perPage),
+        infix: "off,off,fallback,off,off"
+    });
+
+    const data = await atsuFetch(`${BASE_URL}/collections/manga/documents/search?${params.toString()}`);
+    const results = (data?.hits || []).map(hit => {
+        const doc = hit.document || {};
+        return {
+            id: doc.id,
+            title: doc.title,
+            englishTitle: doc.englishTitle || null,
+            authors: Array.isArray(doc.authors) ? doc.authors : [],
+            type: doc.type,
+            medium: doc.medium,
+            status: doc.status,
+            year: doc.year,
+            rating: doc.mbRating ?? null,
+            popularity: doc.popularity ?? null,
+            poster: formatAssetUrl(doc.poster),
+            posterSmall: formatAssetUrl(doc.posterSmall),
+            posterMedium: formatAssetUrl(doc.posterMedium)
+        };
+    });
+
+    return {
+        page: data.page,
+        total: data.found,
+        results
+    };
+}
+
+export async function getMangaDetails(id) {
+    const data = await atsuFetch(`${BASE_URL}/api/manga/page?id=${encodeURIComponent(id)}`);
+    const page = data?.mangaPage;
+    if (!page) throw new Error(`Manga with ID "${id}" not found`);
+
+    return {
+        id: page.id,
+        title: page.title,
+        englishTitle: page.englishTitle || null,
+        synopsis: page.synopsis || null,
+        status: page.status,
+        type: page.type,
+        medium: page.medium,
+        rating: page.avgRating ?? null,
+        views: page.views ?? null,
+        authors: Array.isArray(page.authors) ? page.authors.map(a => a.name) : [],
+        genres: Array.isArray(page.genres) ? page.genres.map(g => g.name) : [],
+        tags: Array.isArray(page.tags) ? page.tags.map(t => t.name) : [],
+        poster: formatAssetUrl(page.poster?.largeImage || page.poster?.image),
+        totalChapters: page.totalChapterCount || page.chapters?.length || 0,
+        chapters: (page.chapters || []).map(ch => ({
+            id: ch.id,
+            number: ch.number,
+            title: ch.title,
+            pageCount: ch.pageCount,
+            createdAt: ch.createdAt ? new Date(ch.createdAt).toISOString() : null
+        }))
+    };
+}
+
+export async function getChapterPages(mangaId, chapterId) {
+    const data = await atsuFetch(
+        `${BASE_URL}/api/read/chapter?mangaId=${encodeURIComponent(mangaId)}&chapterId=${encodeURIComponent(chapterId)}`
+    );
+    const chapter = data?.readChapter;
+    if (!chapter) throw new Error(`Chapter "${chapterId}" not found for manga "${mangaId}"`);
+
+    return {
+        id: chapter.id,
+        number: chapter.number,
+        title: chapter.title,
+        scanlatorId: chapter.scanlationMangaId || null,
+        pages: (chapter.pages || []).map(p => ({
+            number: p.number,
+            url: formatAssetUrl(p.image),
+            width: p.width,
+            height: p.height,
+            aspectRatio: p.aspectRatio
+        }))
+    };
+}
+
+export async function cleanup() {
+    if (session) {
+        try {
+            await session.close();
+        } catch { }
+        session = null;
+    }
+    if (tlsInitialized) {
+        try {
+            await destroyTLS();
+        } catch { }
+        tlsInitialized = false;
+    }
+}

package/src/sdk.js

@@ -1,6 +1,7 @@
 import SOURCES, { SOURCE_MAP } from "./config.js";
 import { fetchDownloads } from "./downloads/downloads.js";
 import { probeSource } from "./health.js";
+import { getChapterPages, getMangaDetails, searchManga } from "./manga/atsu.js";
 import { fetchSubtitles, getSubPathsMovie, getSubPathsTv } from "./subtitles.js";
 import { createStreamArgs } from "./utils/helpers.js";
 
@@ -65,4 +66,13 @@ export default class VylaSDK {
     async getDownloads(id, s = null, e = null) {
         return await fetchDownloads(this, id, s, e);
     }
+    async searchManga(query, page = 1, perPage = 12) {
+        return await searchManga(query, page, perPage);
+    }
+    async getManga(id) {
+        return await getMangaDetails(id);
+    }
+    async getMangaChapter(mangaId, chapterId) {
+        return await getChapterPages(mangaId, chapterId);
+    }
 }

package/src/sources/3eyedraven.js

@@ -0,0 +1,136 @@
+import { getUA } from "../utils/helpers.js";
+
+const BASE_URL = "https://3eyedraven.watch";
+const API_BASE = "https://3eyedraven.watch/api";
+
+function getHeaders() {
+    return {
+        "User-Agent": getUA(),
+        Accept: "application/json",
+        Referer: `${BASE_URL}/`,
+        Origin: BASE_URL,
+    };
+}
+
+function resolveApiKey(args) {
+    return (
+        args?.tmdbApiKey ||
+        args?.sdk?.tmdbApiKey ||
+        process.env.TMDB_API_KEY ||
+        null
+    );
+}
+
+async function getTitle(id, isTv, apiKey) {
+    if (!apiKey) return null;
+    const type = isTv ? "tv" : "movie";
+    try {
+        const res = await fetch(
+            `https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`,
+            { signal: AbortSignal.timeout(5000) }
+        );
+        if (!res.ok) return null;
+        const data = await res.json();
+        return isTv ? data.name : data.title;
+    } catch {
+        return null;
+    }
+}
+
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
+
+function absolute(url) {
+    if (!url) return "";
+    if (/^https?:\/\//.test(url)) return url;
+    return `${BASE_URL}${url.startsWith("/") ? "" : "/"}${url}`;
+}
+
+export async function getStream(args) {
+    const { id, s = null, e = null } = args;
+    const isTv = s != null && e != null;
+
+    const apiKey = resolveApiKey(args);
+    const title = await getTitle(id, isTv, apiKey);
+
+    if (!title) {
+        if (process.env.DEBUG_CAUSE) {
+            console.error(
+                `[3eyedraven] Could not resolve title for ${isTv ? "tv" : "movie"} ${id} ` +
+                `(tmdbApiKey ${apiKey ? "present" : "MISSING"})`
+            );
+        }
+        return null;
+    }
+
+    const identifier = `${slugify(title)}-${id}`;
+
+    const url = isTv
+        ? `${API_BASE}/stream/${identifier}?season=${s}&episode=${e}`
+        : `${API_BASE}/stream/${identifier}`;
+
+    try {
+        const res = await fetch(url, {
+            headers: getHeaders(),
+            signal: AbortSignal.timeout(15000),
+        });
+
+        if (!res.ok) {
+            if (process.env.DEBUG_CAUSE) {
+                console.error(`[3eyedraven] HTTP ${res.status} for ${url}`);
+            }
+            return null;
+        }
+
+        const data = await res.json();
+        const stream = data?.stream;
+        if (!stream?.url) {
+            if (process.env.DEBUG_CAUSE) {
+                console.error(`[3eyedraven] No stream.url in response for ${url}`);
+            }
+            return null;
+        }
+
+        const streamUrl = absolute(stream.url);
+        if (!/^https?:\/\//.test(streamUrl)) return null;
+
+        const subtitles = (stream.subtitles || [])
+            .map(sub => {
+                const subUrl = absolute(sub.url);
+                if (!subUrl) return null;
+                return {
+                    label: sub.label || sub.language || "Subtitle",
+                    file: subUrl,
+                    type: "vtt",
+                    source: "3eyedraven",
+                };
+            })
+            .filter(Boolean);
+
+        return {
+            url: streamUrl,
+            headers: {
+                "User-Agent": getUA(),
+                Referer: `${BASE_URL}/`,
+                Origin: BASE_URL,
+            },
+            server: "3eyedraven",
+            quality: "1080p",
+            type: stream.format === "hls" ? "hls" : "mp4",
+            subtitles,
+            skipProxy: true,
+        };
+    } catch (err) {
+        if (process.env.DEBUG_CAUSE) {
+            console.error(`[3eyedraven] fetch error for ${url}:`, err.message);
+            if (err.cause) console.error("  cause:", err.cause.code, err.cause.message);
+        }
+        return null;
+    }
+}

package/src/sources/cinemaarmy.js

@@ -0,0 +1,181 @@
+import crypto from "crypto";
+import { Session, ClientIdentifier, initTLS, destroyTLS } from "node-tls-client";
+
+const BASE_URL = "https://cinema.army";
+const API_BASE = "https://cinema.army/api";
+
+const XOR_KEY = "f16a6b92fcd6eed3e9476297f893f2505c32f79bc6efef9b6c95496aa5914548";
+const HMAC_KEY = "a2cfc9eaa2a3690b5d4f6b5f958dbdeae52a097283d375bd253ee7c7062524f5";
+
+const UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+
+const SERVERS = [
+    { key: "cookiebakers", method: "POST", label: "CookieBakers" },
+    { key: "tcloud", method: "GET", label: "TCloud" },
+    { key: "ipcloud", method: "GET", label: "IPcloud" },
+    { key: "dcloud", method: "GET", label: "Dcloud" },
+];
+
+let tlsInitialized = false;
+let session = null;
+
+async function ensureSession() {
+    if (!tlsInitialized) {
+        await initTLS();
+        tlsInitialized = true;
+    }
+    if (!session) {
+        session = new Session({
+            clientIdentifier: ClientIdentifier.chrome_131,
+            timeout: 15000,
+            insecureSkipVerify: false,
+        });
+    }
+    return session;
+}
+
+function getHeaders(token, id, isTv, s, e) {
+    const referer = isTv
+        ? `${BASE_URL}/watch?id=${id}&type=tv&season=${s}&episode=${e}`
+        : `${BASE_URL}/watch?id=${id}&type=movie`;
+
+    return {
+        "User-Agent": UA,
+        "Accept": "application/json",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Accept-Encoding": "gzip, deflate, br",
+        "Cache-Control": "no-cache",
+        "Pragma": "no-cache",
+        "Referer": referer,
+        "Origin": BASE_URL,
+        "Sec-Ch-Ua": '"Chromium";v="131", "Not_A Brand";v="24"',
+        "Sec-Ch-Ua-Mobile": "?0",
+        "Sec-Ch-Ua-Platform": '"Windows"',
+        "Sec-Fetch-Dest": "empty",
+        "Sec-Fetch-Mode": "cors",
+        "Sec-Fetch-Site": "same-origin",
+        "Priority": "u=1, i",
+        "X-Stream-Token": token,
+    };
+}
+
+function generateToken(id) {
+    try {
+        const minute = Math.floor(Date.now() / 1000 / 60);
+        return crypto
+            .createHmac("sha256", HMAC_KEY)
+            .update(`${id}:${minute}`)
+            .digest("hex");
+    } catch {
+        return "";
+    }
+}
+
+function decryptStreamUrl(encoded) {
+    if (!encoded) return "";
+    if (encoded.startsWith("http://") || encoded.startsWith("https://")) return encoded;
+    try {
+        const decoded = Buffer.from(encoded, "base64").toString("binary");
+        let out = "";
+        for (let i = 0; i < decoded.length; i++) {
+            out += String.fromCharCode(
+                decoded.charCodeAt(i) ^ XOR_KEY.charCodeAt(i % XOR_KEY.length)
+            );
+        }
+        return out;
+    } catch {
+        return encoded;
+    }
+}
+
+export async function getStream(args) {
+    const { id, s = null, e = null } = args;
+    const isTv = s != null && e != null;
+
+    const token = generateToken(id);
+    const headers = getHeaders(token, id, isTv, s, e);
+
+    const sess = await ensureSession();
+
+    const requests = SERVERS.map(server => {
+        const path = isTv
+            ? `/${server.key}/tv/${id}/${s}/${e}`
+            : `/${server.key}/movie/${id}`;
+        return { url: `${API_BASE}${path}`, server };
+    });
+
+    const results = await Promise.allSettled(
+        requests.map(async ({ url, server }) => {
+            try {
+                const res = server.method === "POST"
+                    ? await sess.post(url, { headers })
+                    : await sess.get(url, { headers });
+
+                if (res.status !== 200) {
+                    if (process.env.DEBUG_CAUSE) {
+                        console.error(`[CinemaArmy ${server.key}] HTTP ${res.status}`);
+                    }
+                    return null;
+                }
+
+                const text = await res.text();
+                let data;
+                try {
+                    data = JSON.parse(text);
+                } catch {
+                    return null;
+                }
+
+                const encrypted = data?.stream?.url;
+                if (!encrypted) return null;
+
+                const streamUrl = decryptStreamUrl(encrypted);
+                if (!streamUrl || !/^https?:\/\//.test(streamUrl)) return null;
+
+                return {
+                    url: streamUrl,
+                    headers: {
+                        "User-Agent": UA,
+                        Referer: `${BASE_URL}/`,
+                        Origin: BASE_URL,
+                    },
+                    server: `CinemaArmy (${server.label})`,
+                    quality: "1080p",
+                    type: streamUrl.includes(".m3u8") ? "hls" : "mp4",
+                };
+            } catch (err) {
+                if (process.env.DEBUG_CAUSE) {
+                    console.error(`[CinemaArmy ${server.key}] ${err.message}`);
+                    if (err.cause) {
+                        console.error(`  cause.code:    ${err.cause.code || "n/a"}`);
+                        console.error(`  cause.message: ${err.cause.message || err.cause}`);
+                    }
+                }
+                return null;
+            }
+        })
+    );
+
+    const allUrls = results
+        .filter(r => r.status === "fulfilled" && r.value)
+        .map(r => r.value);
+
+    if (!allUrls.length) return null;
+
+    return { allUrls };
+}
+
+export async function cleanup() {
+    if (session) {
+        try {
+            await session.close();
+        } catch { }
+        session = null;
+    }
+    if (tlsInitialized) {
+        try {
+            await destroyTLS();
+        } catch { }
+        tlsInitialized = false;
+    }
+}

package/src/sources/movenerds.js

@@ -0,0 +1,125 @@
+import { getUA } from "../utils/helpers.js";
+
+const API_BASE = "https://api.movenerds.space/api";
+
+function getHeaders() {
+    return {
+        "User-Agent": getUA(),
+        Accept: "application/json",
+        Referer: "https://movenerds.space/",
+        Origin: "https://movenerds.space",
+    };
+}
+
+function resolveApiKey(args) {
+    return (
+        args?.tmdbApiKey ||
+        args?.sdk?.tmdbApiKey ||
+        process.env.TMDB_API_KEY ||
+        null
+    );
+}
+
+async function getMeta(id, isTv, apiKey) {
+    if (!apiKey) return null;
+    const type = isTv ? "tv" : "movie";
+    try {
+        const res = await fetch(
+            `https://api.themoviedb.org/3/${type}/${id}?api_key=${apiKey}`,
+            { signal: AbortSignal.timeout(5000) }
+        );
+        if (!res.ok) return null;
+        const data = await res.json();
+        const title = isTv ? data.name : data.title;
+        const date = isTv ? data.first_air_date : data.release_date;
+        const year = date ? parseInt(date.slice(0, 4), 10) : null;
+        return { title, year };
+    } catch {
+        return null;
+    }
+}
+
+function mapSource(source) {
+    if (!source || !source.url) return null;
+    if (source.type !== "hls" && source.type !== "mp4") return null;
+    if (!/^https?:\/\//.test(source.url)) return null;
+
+    return {
+        url: source.url,
+        headers: {
+            "User-Agent": source.headers?.["User-Agent"] || getUA(),
+            Referer: source.headers?.Referer || "https://movenerds.space/",
+            Origin: source.headers?.Origin || "https://movenerds.space",
+        },
+        server: source.name || source.providerName || "MoverNerds",
+        quality: source.quality || "1080p",
+        type: source.type,
+        skipProxy: true,
+    };
+}
+
+export async function getStream(args) {
+    const { id, s = null, e = null } = args;
+    const isTv = s != null && e != null;
+
+    const apiKey = resolveApiKey(args);
+    const meta = await getMeta(id, isTv, apiKey);
+
+    if (!meta?.title) {
+        if (process.env.DEBUG_CAUSE) {
+            console.error(
+                `[movenerds] Could not resolve title for ${isTv ? "tv" : "movie"} ${id} ` +
+                `(tmdbApiKey ${apiKey ? "present" : "MISSING"})`
+            );
+        }
+        return null;
+    }
+
+    const params = new URLSearchParams({
+        tmdbId: String(id),
+        type: isTv ? "tv" : "movie",
+        title: meta.title,
+    });
+    if (meta.year) params.set("year", String(meta.year));
+    if (isTv) {
+        params.set("season", String(s));
+        params.set("episode", String(e));
+        params.set("language", "en");
+    }
+
+    const url = `${API_BASE}/stream?${params.toString()}`;
+
+    try {
+        const res = await fetch(url, {
+            headers: getHeaders(),
+            signal: AbortSignal.timeout(20000),
+        });
+
+        if (!res.ok) {
+            if (process.env.DEBUG_CAUSE) {
+                console.error(`[movenerds] HTTP ${res.status} for ${url}`);
+            }
+            return null;
+        }
+
+        const data = await res.json();
+        const primary = Array.isArray(data?.primarySources) ? data.primarySources : [];
+        if (!primary.length) {
+            if (process.env.DEBUG_CAUSE) {
+                console.error(`[movenerds] No primarySources in response for ${url}`);
+            }
+            return null;
+        }
+
+        const allUrls = primary.map(mapSource).filter(Boolean);
+        if (!allUrls.length) return null;
+
+        return { allUrls };
+    } catch (err) {
+        if (process.env.DEBUG_CAUSE) {
+            console.error(`[movenerds] fetch error for ${url}:`, err.message);
+            if (err.cause) console.error("  cause:", err.cause.code, err.cause.message);
+        }
+        return null;
+    }
+}

package/src/sources/peestream.js

@@ -0,0 +1,139 @@
+import { USER_AGENT, fetchJson, getTmdbInfo } from '../utils/helpers.js';
+
+const BASE_URL = 'https://providers.peestream.in';
+
+const PROVIDERS = {
+    purstream: 'Athena',
+    vidrock: 'Thor',
+    vaplayer: 'Poseidon',
+    netmirror: 'Ra'
+};
+
+export async function getStream(args) {
+    const { id, s, e, server, tmdbApiKey } = args;
+    const isTv = s != null && e != null;
+    const type = isTv ? 'tv' : 'movie';
+
+    let title = args.title || '';
+    let releaseYear = args.year || '';
+    let imdbId = args.imdbId || '';
+    let seasonTmdbId = args.seasonTmdbId || '';
+    let episodeTmdbId = args.episodeTmdbId || '';
+
+    try {
+        const info = await getTmdbInfo(id, type, s, tmdbApiKey);
+        if (info) {
+            title = title || info.name || info.title || '';
+
+            if (!releaseYear) {
+                const date = info.release_date || info.first_air_date || '';
+                releaseYear = date ? date.split('-')[0] : (info.year || '');
+            }
+
+            if (!imdbId && info.external_ids?.imdb_id) {
+                imdbId = info.external_ids.imdb_id;
+            } else if (!imdbId && info.imdb_id) {
+                imdbId = info.imdb_id;
+            }
+
+            if (isTv) {
+                if (!seasonTmdbId && Array.isArray(info.seasons)) {
+                    const matchedSeason = info.seasons.find(
+                        item => item.season_number === Number(s)
+                    );
+                    if (matchedSeason) {
+                        seasonTmdbId = String(matchedSeason.id);
+                    }
+                }
+
+                if (!episodeTmdbId && tmdbApiKey) {
+                    try {
+                        const seasonData = await fetchJson(
+                            `https://api.themoviedb.org/3/tv/${id}/season/${s}?api_key=${tmdbApiKey}`
+                        );
+                        if (seasonData?.episodes) {
+                            const matchedEp = seasonData.episodes.find(
+                                ep => ep.episode_number === Number(e)
+                            );
+                            if (matchedEp) {
+                                episodeTmdbId = String(matchedEp.id);
+                            }
+                        }
+                    } catch { }
+                }
+            }
+        }
+    } catch { }
+
+    const queryParams = new URLSearchParams({
+        type,
+        tmdbId: String(id),
+        title: title || String(id)
+    });
+
+    if (releaseYear) queryParams.set('releaseYear', String(releaseYear));
+    if (imdbId) queryParams.set('imdbId', String(imdbId));
+
+    if (isTv) {
+        queryParams.set('seasonNumber', String(s));
+        queryParams.set('episodeNumber', String(e));
+        if (seasonTmdbId) queryParams.set('seasonTmdbId', String(seasonTmdbId));
+        if (episodeTmdbId) queryParams.set('episodeTmdbId', String(episodeTmdbId));
+    }
+
+    const allUrls = [];
+
+    try {
+        const scrapeUrl = `${BASE_URL}/scrape?${queryParams.toString()}`;
+        const res = await fetch(scrapeUrl, {
+            headers: {
+                'User-Agent': USER_AGENT,
+                'Accept': 'text/event-stream',
+                'Referer': `${BASE_URL}/`
+            },
+            signal: AbortSignal.timeout(20000)
+        });
+
+        if (res.ok) {
+            const text = await res.text();
+            const events = text.split('\n\n');
+
+            for (const ev of events) {
+                if (ev.includes('event: completed')) {
+                    const dataMatch = ev.match(/data:\s*(.+)/);
+                    if (dataMatch) {
+                        try {
+                            const parsed = JSON.parse(dataMatch[1].trim());
+                            const stream = parsed.stream;
+                            const streamUrl = stream?.playlist || stream?.url || stream?.file;
+                            if (streamUrl) {
+                                const sourceName = PROVIDERS[parsed.sourceId] || parsed.sourceId || 'Poseidon';
+                                allUrls.push({
+                                    url: streamUrl,
+                                    server: `PeeStream - ${sourceName}`,
+                                    quality: 'Auto',
+                                    type: stream.type === 'hls' || streamUrl.includes('.m3u8') ? 'hls' : 'mp4',
+                                    headers: stream.headers || {
+                                        'User-Agent': USER_AGENT
+                                    }
+                                });
+                            }
+                        } catch { }
+                    }
+                }
+            }
+        }
+    } catch { }
+
+    if (server && server !== 'all') {
+        const clean = server.toLowerCase().replace('peestream - ', '').trim();
+        const filtered = allUrls.filter(u => u.server.toLowerCase().includes(clean));
+        if (filtered.length) return { allUrls: filtered };
+    }
+
+    return allUrls.length ? { allUrls } : null;
+}
+
+export async function getSources() {
+    return Object.values(PROVIDERS).map(name => `PeeStream - ${name}`);
+}

package/src/sources/rivestream.js

@@ -1,5 +1,3 @@
-// im being salty
-
 import { USER_AGENT, fetchJson } from '../utils/helpers.js';
 
 const C_ARRAY = [

package/src/sources/thugtv.js

@@ -0,0 +1,62 @@
+import { getUA } from "../utils/helpers.js";
+
+const API_BASE = "https://thuktv.onrender.com/api";
+
+function getHeaders() {
+    return {
+        "User-Agent": getUA(),
+        Accept: "application/json",
+        Referer: "https://thugtv.online/",
+        Origin: "https://thugtv.online",
+    };
+}
+
+function mapSource(source) {
+    if (!source || !source.url) return null;
+    if (source.type !== "hls" && source.type !== "mp4") return null;
+    if (!/^https?:\/\//.test(source.url)) return null;
+
+    return {
+        url: source.url,
+        headers: {
+            "User-Agent": getUA(),
+            Referer: "https://thugtv.online/",
+            Origin: "https://thugtv.online",
+        },
+        server: source.name || source.label || "ThugTV",
+        quality: source.quality || "1080p",
+        type: source.type,
+        skipProxy: true,
+    };
+}
+
+export async function getStream(args) {
+    const { id, s = null, e = null } = args;
+    const isTv = s != null && e != null;
+
+    const url = isTv
+        ? `${API_BASE}/stream/tv/${id}/${s}/${e}`
+        : `${API_BASE}/stream/movie/${id}`;
+
+    try {
+        const res = await fetch(url, {
+            headers: getHeaders(),
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok) return null;
+
+        const data = await res.json();
+        const sources = Array.isArray(data?.sources) ? data.sources : [];
+        if (!sources.length) return null;
+
+        const allUrls = sources
+            .map(mapSource)
+            .filter(Boolean);
+
+        if (!allUrls.length) return null;
+
+        return { allUrls };
+    } catch {
+        return null;
+    }
+}

package/src/sources/vidy.js

@@ -0,0 +1,187 @@
+import { getUA } from "../utils/helpers.js";
+
+const API_URL = "https://api.wecollege.net";
+const SERVERS = ["miami", "atlanta", "seattle", "denver", "dallas", "tampa"];
+const MAGIC = [109, 118, 109, 49];
+
+function imul(a, b) {
+    return Math.imul(a | 0, b | 0) >>> 0;
+}
+
+function pFn(e) {
+    e = e >>> 0;
+    e = (e ^ (e >>> 16)) >>> 0;
+    e = imul(e, 2246822507);
+    e = (e ^ (e >>> 13)) >>> 0;
+    e = imul(e, 3266489909);
+    e = (e ^ (e >>> 16)) >>> 0;
+    return e;
+}
+
+function gFn(e, t) {
+    e = e >>> 0;
+    t = t & 31;
+    if (t === 0) return e;
+    return ((e << t) | (e >>> (32 - t))) >>> 0;
+}
+
+function decryptVidy(ciphertext, seedStr, mediaId) {
+    let padded = ciphertext.replace(/-/g, "+").replace(/_/g, "/");
+    while (padded.length % 4) padded += "=";
+
+    const raw = new Uint8Array(Buffer.from(padded, "base64"));
+    const length = raw.length;
+
+    let tFnv = 2166136261;
+    for (let i = 0; i < seedStr.length; i++) {
+        tFnv = imul((tFnv ^ seedStr.charCodeAt(i)) >>> 0, 16777619);
+    }
+    const fnvRes = pFn(tFnv);
+
+    const innerArg = (((mediaId >>> 0) ^ 2654435769) >>> 0);
+    const inner = pFn(innerArg);
+    let n = pFn(((fnvRes ^ inner) >>> 0));
+
+    const S = {};
+    for (let e = 0; e < 8; e++) {
+        const t = n % 61;
+        n = gFn((n + 2654435769) >>> 0, 7 + (7 & e));
+        S[t] = ((n ^ pFn(n)) >>> 0);
+        n = pFn((n + t) >>> 0);
+    }
+
+    let acc = pFn(((2779096485 ^ n) >>> 0));
+    const keystream = new Uint8Array(length);
+    let sCnt = 0;
+    let idx = 0;
+
+    while (idx < length) {
+        const sVal = acc;
+        const o = sVal % 61;
+        const hasO = Object.prototype.hasOwnProperty.call(S, o);
+        const iVal = hasO ? -1 : 0;
+        const d = hasO ? S[o] : 0;
+        const nTerm = ((d ^ imul(2654435769, sCnt + 1)) >>> 0);
+        sCnt += 1;
+        const aTerm = sVal;
+        let lVal = (((aTerm ^ nTerm) | (aTerm & nTerm & iVal)) >>> 0);
+        const term1 = gFn((lVal + sVal) >>> 0, 31 & o);
+        const term2 = gFn(sVal, (31 & imul(o, 7)) >>> 0);
+        lVal = ((term1 ^ term2) >>> 0);
+        const newS = pFn((lVal + 2654435769) >>> 0);
+        S[o] = newS;
+        acc = newS;
+        const tVal = newS;
+
+        keystream[idx++] = tVal & 0xFF;
+        if (idx < length) keystream[idx++] = (tVal >>> 8) & 0xFF;
+        if (idx < length) keystream[idx++] = (tVal >>> 16) & 0xFF;
+        if (idx < length) keystream[idx++] = (tVal >>> 24) & 0xFF;
+    }
+
+    for (let i = 0; i < length; i++) {
+        raw[i] ^= keystream[i];
+    }
+
+    for (let i = 0; i < MAGIC.length; i++) {
+        if (raw[i] !== MAGIC[i]) {
+            throw new Error("Vidy decrypt failed: magic header mismatch");
+        }
+    }
+
+    return new TextDecoder().decode(raw.slice(MAGIC.length));
+}
+
+export async function getStream(args) {
+    const { id, s = null, e = null } = args;
+    const isTv = s != null && e != null;
+    const mediaId = Number(id);
+
+    const headers = {
+        "User-Agent": getUA(),
+        Referer: "https://www.vidy.st/",
+        Origin: "https://www.vidy.st",
+    };
+
+    try {
+        const seedUrl = new URL(`${API_URL}/seed`);
+        seedUrl.searchParams.set("mediaId", String(id));
+
+        const seedRes = await fetch(seedUrl.toString(), {
+            headers,
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!seedRes.ok) return null;
+
+        const seedData = await seedRes.json();
+        const seed = seedData?.seed;
+        if (!seed) return null;
+
+        for (const server of SERVERS) {
+            try {
+                const srcUrl = new URL(`${API_URL}/${server}/sources`);
+                srcUrl.searchParams.set("mediaType", isTv ? "tv" : "movie");
+                srcUrl.searchParams.set("tmdbId", String(id));
+                srcUrl.searchParams.set("enc", "2");
+                srcUrl.searchParams.set("seed", seed);
+                if (isTv) {
+                    srcUrl.searchParams.set("seasonId", String(s));
+                    srcUrl.searchParams.set("episodeId", String(e));
+                }
+
+                const res = await fetch(srcUrl.toString(), {
+                    headers,
+                    signal: AbortSignal.timeout(6000),
+                });
+                if (!res.ok) continue;
+
+                const text = await res.text();
+
+                let data;
+                try {
+                    data = JSON.parse(decryptVidy(text, seed, mediaId));
+                } catch {
+                    continue;
+                }
+
+                const sources = data?.sources || [];
+                const playlist = data?.playlist || "";
+                if (!sources.length && !playlist) continue;
+
+                let streamUrl = playlist;
+                let quality = "1080p";
+
+                for (const src of sources) {
+                    if (src?.quality === "1080p" && src?.url) {
+                        streamUrl = src.url;
+                        quality = "1080p";
+                        break;
+                    }
+                }
+                if (!streamUrl && sources.length) {
+                    streamUrl = sources[0]?.url || "";
+                    quality = sources[0]?.quality || "";
+                }
+                if (!streamUrl) continue;
+
+                return {
+                    url: streamUrl,
+                    headers: {
+                        "User-Agent": getUA(),
+                        Referer: "https://www.vidy.st/",
+                        Origin: "https://www.vidy.st",
+                    },
+                    server: "Vidy",
+                    quality,
+                    type: streamUrl.includes(".m3u8") ? "hls" : "mp4",
+                };
+            } catch {
+                continue;
+            }
+        }
+
+        return null;
+    } catch {
+        return null;
+    }
+}