ani-web 2.0.7

package/server/dist/providers/animepahe.provider.js

@@ -0,0 +1,457 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimePaheProvider = void 0;
+const cheerio = __importStar(require("cheerio"));
+const logger_1 = __importDefault(require("../logger"));
+const request_context_1 = require("../utils/request-context");
+class AnimePaheProvider {
+    name = 'AnimePahe';
+    BASE_URL = 'https://animepahe.pw';
+    API_URL = 'https://animepahe.pw/api';
+    cache;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    async getRequestHeaders(isApi = false, customUaOverride, customCookieOverride) {
+        const store = request_context_1.requestContext.getStore();
+        const customUa = customUaOverride || store?.get('ua');
+        const customCookie = customCookieOverride || store?.get('cookie');
+        const userAgent = customUa ||
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36';
+        let cookieStr = '';
+        if (customCookie) {
+            // Sanitize cookie: remove 'cf_clearance' label (with : or =), spaces, and quotes
+            let sanitized = customCookie.trim();
+            // Remove "cf_clearance" prefix case-insensitively
+            sanitized = sanitized.replace(/^cf_clearance/i, '');
+            // Remove leading : or = and any whitespace
+            sanitized = sanitized.replace(/^[:=]\s*/, '');
+            // Remove all quotes and trim again
+            sanitized = sanitized.replace(/["']/g, '').trim();
+            cookieStr = `cf_clearance=${sanitized}`;
+        }
+        const headers = {
+            'User-Agent': userAgent,
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
+            'Accept-Language': 'en-US,en;q=0.9',
+            Referer: `${this.BASE_URL}/`,
+            Origin: this.BASE_URL,
+            Cookie: cookieStr,
+        };
+        if (isApi) {
+            headers['X-Requested-With'] = 'XMLHttpRequest';
+            headers['Accept'] = 'application/json, text/javascript, */*; q=0.01';
+        }
+        return headers;
+    }
+    async fetchText(url, isApi = false, ua, cookie) {
+        try {
+            const headers = await this.getRequestHeaders(isApi, ua, cookie);
+            const response = await fetch(url, {
+                method: 'GET',
+                headers,
+            });
+            const text = await response.text();
+            if (!response.ok) {
+                if (response.status === 403 || text.includes('Cloudflare')) {
+                    const error = new Error(`AUTH_REQUIRED`);
+                    error.status = 403;
+                    throw error;
+                }
+                throw new Error(`HTTP ${response.status}`);
+            }
+            return text;
+        }
+        catch (error) {
+            if (error.message === 'AUTH_REQUIRED')
+                throw error;
+            logger_1.default.error({ url, error: error.message }, 'AnimePahe Fetch failed');
+            throw error;
+        }
+    }
+    async fetchJson(url, ua, cookie) {
+        const data = await this.fetchText(url, true, ua, cookie);
+        try {
+            return JSON.parse(data);
+        }
+        catch {
+            logger_1.default.error({ url }, 'Failed to parse AnimePahe JSON');
+            return null;
+        }
+    }
+    async search(options) {
+        try {
+            const q = options.query || '';
+            const url = `${this.API_URL}?m=search&q=${encodeURIComponent(q)}`;
+            const data = await this.fetchJson(url);
+            if (!data)
+                return [];
+            const items = (data.data || data.results || data.items || []);
+            return items.map((a) => ({
+                _id: a.session,
+                id: a.session,
+                name: a.title || a.name || '',
+                englishName: a.title,
+                thumbnail: a.poster || a.image,
+                type: a.type,
+                year: a.year,
+                session: a.session,
+            }));
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED')
+                throw e;
+            return [];
+        }
+    }
+    async getEpisodes(showId, _mode, ua, cookie) {
+        try {
+            const firstPageUrl = `${this.API_URL}?m=release&id=${showId}&sort=episode_asc&page=1`;
+            const firstPageData = await this.fetchJson(firstPageUrl, ua, cookie);
+            if (!firstPageData)
+                return null;
+            let episodes = (firstPageData.data || firstPageData.results || []);
+            const lastPage = Number(firstPageData.last_page || firstPageData.lastPage || 1);
+            for (let p = 2; p <= lastPage; p++) {
+                const pageUrl = `${this.API_URL}?m=release&id=${showId}&sort=episode_asc&page=${p}`;
+                const pageData = await this.fetchJson(pageUrl, ua, cookie);
+                if (pageData) {
+                    episodes = episodes.concat((pageData.data || pageData.results || []));
+                }
+            }
+            const episodeMap = {};
+            const epDetails = [];
+            episodes.forEach((ep) => {
+                const epNum = (ep.episode ?? ep.number ?? '').toString();
+                if (epNum) {
+                    episodeMap[epNum] = ep.session || ep.release_session || '';
+                    epDetails.push({ number: epNum, title: ep.title });
+                }
+            });
+            this.cache.set(`animepahe_epmap_${showId}`, episodeMap, 86400);
+            return {
+                episodes: epDetails
+                    .sort((a, b) => Number(a.number) - Number(b.number))
+                    .map((e) => e.number),
+                availableEpisodesDetail: epDetails,
+                description: '',
+            };
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED')
+                throw e;
+            return null;
+        }
+    }
+    async getEpisodeSession(showId, episodeNumber) {
+        const cacheKey = `animepahe_epmap_${showId}`;
+        let cachedMap = this.cache.get(cacheKey);
+        if (!cachedMap) {
+            await this.getEpisodes(showId, 'sub');
+            cachedMap = this.cache.get(cacheKey);
+        }
+        if (!cachedMap)
+            return null;
+        if (cachedMap[episodeNumber])
+            return cachedMap[episodeNumber];
+        const target = parseFloat(episodeNumber);
+        const keys = Object.keys(cachedMap);
+        for (const key of keys) {
+            if (parseFloat(key) === target)
+                return cachedMap[key];
+        }
+        const sorted = keys.sort((a, b) => Number(a) - Number(b));
+        const first = Number(sorted[0]);
+        if (target < first) {
+            const idx = Math.floor(target) - 1;
+            if (idx >= 0 && idx < sorted.length)
+                return cachedMap[sorted[idx]];
+        }
+        return null;
+    }
+    async getStreamUrls(showId, episodeNumber, mode) {
+        try {
+            const epSession = await this.getEpisodeSession(showId, episodeNumber);
+            if (!epSession)
+                return null;
+            const sources = await this.getSources(showId, epSession);
+            const results = [];
+            const isDubSource = (audio) => audio.includes('eng') || audio.includes('dub');
+            for (const src of sources) {
+                const audio = (src.audio || '').toLowerCase();
+                const sourceMode = isDubSource(audio) ? 'dub' : 'sub';
+                if (sourceMode !== mode)
+                    continue;
+                const label = src.fansub
+                    ? `${src.quality || 'Auto'} - ${src.fansub} (${sourceMode.toUpperCase()})`
+                    : `${src.quality || 'Auto'} (${sourceMode.toUpperCase()})`;
+                results.push({
+                    sourceName: label,
+                    links: [
+                        {
+                            resolutionStr: src.quality || 'Auto',
+                            link: `/api/embed-proxy?url=${encodeURIComponent(src.url)}`,
+                            hls: false,
+                        },
+                    ],
+                    type: 'iframe',
+                    actualEpisodeNumber: episodeNumber,
+                });
+            }
+            return results.length > 0 ? results : null;
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED')
+                throw e;
+            return null;
+        }
+    }
+    async getSources(animeSession, episodeSession) {
+        try {
+            const playUrl = `${this.BASE_URL}/play/${animeSession}/${episodeSession}`;
+            const html = await this.fetchText(playUrl);
+            const $ = cheerio.load(html);
+            const sources = [];
+            $('[data-src]').each((_, el) => {
+                const src = $(el).attr('data-src')?.trim();
+                if (!src || !/kwik/i.test(src))
+                    return;
+                const res = $(el).attr('data-resolution') || $(el).attr('data-res');
+                sources.push({
+                    url: src,
+                    quality: res ? (res.endsWith('p') ? res : `${res}p`) : null,
+                    fansub: $(el).attr('data-fansub') ?? null,
+                    audio: $(el).attr('data-audio') ?? null,
+                });
+            });
+            const unique = Array.from(new Map(sources.map((s) => [s.url, s])).values());
+            unique.sort((a, b) => {
+                const qa = parseInt(a.quality || '0') || 0;
+                const qb = parseInt(b.quality || '0') || 0;
+                return qb - qa;
+            });
+            return unique;
+        }
+        catch {
+            return [];
+        }
+    }
+    async resolveKwik(_kwikUrl) {
+        return { m3u8: '', referer: '' };
+    }
+    async getShowMeta(showId, ua, cookie) {
+        try {
+            const url = `${this.BASE_URL}/anime/${showId}`;
+            const html = await this.fetchText(url, false, ua, cookie);
+            const $ = cheerio.load(html);
+            const metadata = {
+                _id: showId,
+                id: showId,
+                names: {},
+            };
+            const cleanText = (text) => {
+                if (!text)
+                    return null;
+                return text.replace(/\s+/g, ' ').trim();
+            };
+            const titleText = cleanText($('.anime-header h1 > span').text()) ||
+                cleanText($('.anime-header h1').text()) ||
+                '';
+            metadata.name = titleText;
+            metadata.englishName = titleText;
+            metadata.names.english = titleText;
+            const romaji = cleanText($('.anime-header h2.japanese').text());
+            if (romaji) {
+                metadata.names.romaji = romaji;
+            }
+            const posterDiv = $('.anime-poster');
+            if (posterDiv.length) {
+                const img = posterDiv.find('img');
+                if (img.length) {
+                    metadata.thumbnail = img.attr('data-src') || img.attr('src');
+                }
+            }
+            const synopsisDiv = $('.anime-synopsis');
+            if (synopsisDiv.length) {
+                metadata.description = cleanText(synopsisDiv.text()) || undefined;
+            }
+            const infoBox = {};
+            const infoDiv = $('.anime-info');
+            if (infoDiv.length) {
+                infoDiv.find('p').each((_, el) => {
+                    const p = $(el);
+                    const fullText = cleanText(p.text());
+                    if (!fullText)
+                        return;
+                    const colonIdx = fullText.indexOf(':');
+                    if (colonIdx === -1)
+                        return;
+                    const label = fullText.substring(0, colonIdx).trim();
+                    if (label === 'External Links' || label === 'Themes' || label === 'Demographic') {
+                        const items = [];
+                        p.find('a').each((_, aEl) => {
+                            items.push({
+                                name: cleanText($(aEl).text()) || '',
+                                url: $(aEl).attr('href'),
+                            });
+                        });
+                        infoBox[label] = items;
+                    }
+                    else {
+                        const value = fullText.substring(colonIdx + 1).trim();
+                        infoBox[label] = value;
+                    }
+                });
+            }
+            if (typeof infoBox['Japanese'] === 'string') {
+                metadata.nativeName = infoBox['Japanese'];
+                metadata.names.native = infoBox['Japanese'];
+            }
+            if (typeof infoBox['Synonyms'] === 'string') {
+                metadata.names.synonyms = infoBox['Synonyms'].split(',').map((s) => s.trim());
+            }
+            if (typeof infoBox['Type'] === 'string') {
+                metadata.type = infoBox['Type'];
+            }
+            const epsStr = typeof infoBox['Episodes'] === 'string'
+                ? infoBox['Episodes']
+                : typeof infoBox['Episode'] === 'string'
+                    ? infoBox['Episode']
+                    : undefined;
+            if (epsStr && epsStr !== '?') {
+                const parsedEps = parseInt(epsStr, 10);
+                if (!isNaN(parsedEps)) {
+                    metadata.episodeCount = parsedEps;
+                }
+            }
+            if (typeof infoBox['Duration'] === 'string') {
+                metadata.episodeDuration = infoBox['Duration'];
+            }
+            if (typeof infoBox['Status'] === 'string') {
+                metadata.status = infoBox['Status'];
+            }
+            const parseDateStr = (dateStr) => {
+                if (!dateStr)
+                    return null;
+                const parsed = Date.parse(dateStr);
+                if (isNaN(parsed))
+                    return null;
+                const dateObj = new Date(parsed);
+                return {
+                    year: dateObj.getFullYear(),
+                    month: dateObj.getMonth(),
+                    date: dateObj.getDate(),
+                };
+            };
+            const airedStr = typeof infoBox['Aired'] === 'string' ? infoBox['Aired'] : undefined;
+            if (airedStr) {
+                const dates = airedStr.split(/\s+to\s+/);
+                const start = parseDateStr(dates[0]);
+                if (start) {
+                    metadata.airedStart = start;
+                }
+                if (dates[1] && dates[1] !== '?') {
+                    const end = parseDateStr(dates[1]);
+                    if (end) {
+                        metadata.airedEnd = end;
+                    }
+                }
+            }
+            const seasonStr = typeof infoBox['Season'] === 'string' ? infoBox['Season'] : undefined;
+            if (seasonStr) {
+                const parts = seasonStr.split(' ');
+                const seasonName = parts[0];
+                const yearMatch = seasonStr.match(/\d{4}/);
+                const yearVal = yearMatch ? parseInt(yearMatch[0], 10) : undefined;
+                if (yearVal) {
+                    metadata.year = yearVal;
+                }
+                metadata.season = {
+                    season: seasonName,
+                    year: yearVal,
+                };
+            }
+            else if (typeof infoBox['Aired'] === 'string') {
+                const yearMatch = infoBox['Aired'].match(/\d{4}/);
+                if (yearMatch) {
+                    metadata.year = parseInt(yearMatch[0], 10);
+                }
+            }
+            if (typeof infoBox['Studios'] === 'string') {
+                metadata.studios = infoBox['Studios'].split(',').map((s) => ({ name: s.trim() }));
+            }
+            const themes = infoBox['Themes'] ?? [];
+            const demographic = infoBox['Demographic'] ?? [];
+            metadata.tags = [
+                ...themes.map((t) => ({ name: t.name })),
+                ...demographic.map((d) => ({ name: d.name })),
+            ];
+            const genreDiv = $('.anime-genre');
+            if (genreDiv.length) {
+                metadata.genres = genreDiv
+                    .find('a')
+                    .map((_, el) => ({ name: cleanText($(el).text()) || '' }))
+                    .get();
+            }
+            return metadata;
+        }
+        catch (e) {
+            if (e.message === 'AUTH_REQUIRED')
+                throw e;
+            logger_1.default.error({ showId, error: e.message }, 'Failed to fetch AnimePahe metadata');
+            return null;
+        }
+    }
+    async getPopular(_timeframe, _page, _size) {
+        return [];
+    }
+    async getSchedule(_date) {
+        return [];
+    }
+    async getSeasonal(_page) {
+        return [];
+    }
+    async getLatestReleases(_page, _size) {
+        return [];
+    }
+    async getSkipTimes(_showId, _episodeNumber) {
+        return { found: false, results: [] };
+    }
+}
+exports.AnimePaheProvider = AnimePaheProvider;