@serifpersia/dango 3.0.3

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

@@ -0,0 +1,388 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KaaProvider = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const base_provider_1 = require("./base-provider");
+const KAA_BASE = 'https://kaa.lt';
+const KAA_HLS_BASE = 'https://hls.krussdomi.com/manifest';
+const KAA_REFERER = 'https://krussdomi.com/';
+const KAA_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+const KAA_HEADERS = {
+    'User-Agent': KAA_UA,
+    Accept: 'application/json',
+};
+class KaaProvider extends base_provider_1.BaseProvider {
+    name = 'kaa';
+    stripSlug(showId) {
+        if (!showId)
+            return null;
+        const s = showId.trim();
+        if (/^\d+$/.test(s))
+            return null;
+        if (s.startsWith('kaa:')) {
+            const rest = s.slice(4);
+            return rest || null;
+        }
+        if (s.length < 3)
+            return null;
+        return s;
+    }
+    async kaaSearch(query) {
+        const res = await fetch(`${KAA_BASE}/api/fsearch`, {
+            method: 'POST',
+            headers: { ...KAA_HEADERS, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ page: 1, query }),
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok)
+            throw new Error(`KAA fsearch HTTP ${res.status} for "${query}"`);
+        const data = (await res.json());
+        return Array.isArray(data?.result) ? data.result : [];
+    }
+    async kaaShowInfo(slug) {
+        const res = await fetch(`${KAA_BASE}/api/show/${encodeURIComponent(slug)}`, {
+            headers: KAA_HEADERS,
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok)
+            throw new Error(`KAA show HTTP ${res.status}: ${slug}`);
+        return (await res.json());
+    }
+    async kaaEpisodePage(slug, ep, lang) {
+        const res = await fetch(`${KAA_BASE}/api/show/${encodeURIComponent(slug)}/episodes?ep=${ep}&lang=${encodeURIComponent(lang)}`, { headers: KAA_HEADERS, signal: AbortSignal.timeout(15000) });
+        if (!res.ok)
+            throw new Error(`KAA episodes HTTP ${res.status}: ${slug}`);
+        return (await res.json());
+    }
+    async kaaAllEpisodes(slug, lang) {
+        const first = await this.kaaEpisodePage(slug, 1, lang);
+        const pages = Array.isArray(first.pages) ? first.pages : [];
+        const all = Array.isArray(first.result) ? [...first.result] : [];
+        if (pages.length > 1) {
+            const rest = await Promise.all(pages.slice(1).map(async (pg) => {
+                const startEp = pg.eps?.[0];
+                if (startEp == null)
+                    return [];
+                try {
+                    const d = await this.kaaEpisodePage(slug, startEp, lang);
+                    return Array.isArray(d.result) ? d.result : [];
+                }
+                catch {
+                    return [];
+                }
+            }));
+            for (const batch of rest)
+                all.push(...batch);
+        }
+        return all;
+    }
+    async kaaEpisodeServers(slug, fullEpSlug) {
+        const res = await fetch(`${KAA_BASE}/api/show/${encodeURIComponent(slug)}/episode/${encodeURIComponent(fullEpSlug)}`, { headers: KAA_HEADERS, signal: AbortSignal.timeout(15000) });
+        if (!res.ok)
+            throw new Error(`KAA episode servers HTTP ${res.status}: ${fullEpSlug}`);
+        return (await res.json());
+    }
+    langFor(mode) {
+        return mode === 'dub' ? 'en-US' : 'ja-JP';
+    }
+    toShow(item) {
+        const name = item.title_en || item.title || 'Unknown';
+        return {
+            _id: item.slug,
+            id: item.slug,
+            name,
+            englishName: item.title_en || item.title,
+            names: {
+                english: item.title_en,
+            },
+            type: item.type,
+            year: item.year ?? null,
+            episodeCount: item.episode_count ?? null,
+        };
+    }
+    async search(options) {
+        try {
+            const query = (options.query || '').trim();
+            if (!query)
+                return [];
+            const results = await this.kaaSearch(query);
+            return results.filter((r) => r.slug).map((r) => this.toShow(r));
+        }
+        catch (error) {
+            logger_1.default.error({ error }, '[KAA] Search failed');
+            return [];
+        }
+    }
+    async buildEpMap(slug, show, lang) {
+        const episodes = await this.kaaAllEpisodes(slug, lang);
+        const map = episodes
+            .filter((e) => Number.isInteger(e.episode_number) && e.episode_number >= 1 && e.slug)
+            .map((e) => ({
+            number: e.episode_number,
+            fullSlug: `ep-${e.episode_number}-${e.slug}`,
+        }));
+        if (map.length > 0)
+            return map;
+        if (show?.type === 'movie' && show?.watch_uri) {
+            const m = show.watch_uri.match(/\/(ep-(\d+)-([a-f0-9]+))$/i);
+            if (m)
+                return [{ number: 1, fullSlug: m[1] }];
+        }
+        return [];
+    }
+    async getEpisodes(showId, mode) {
+        try {
+            const slug = this.stripSlug(showId);
+            if (!slug)
+                return null;
+            const cacheKey = `kaa_eps_${slug}_${mode || 'sub'}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const show = await this.kaaShowInfo(slug);
+            const locales = Array.isArray(show.locales) ? show.locales : [];
+            if (mode === 'dub' && !locales.includes('en-US'))
+                return null;
+            const epMap = await this.buildEpMap(slug, show, this.langFor(mode));
+            if (!epMap.length)
+                return null;
+            const episodes = epMap.map((e) => String(e.number));
+            const result = { episodes, description: '' };
+            this.cache.set(cacheKey, result, 3600);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId, mode }, '[KAA] getEpisodes failed');
+            return null;
+        }
+    }
+    proxyUrl(rawUrl) {
+        return `/api/proxy?url=${encodeURIComponent(rawUrl)}&referer=${encodeURIComponent(KAA_REFERER)}`;
+    }
+    parsePlayerSubtitles(html) {
+        const seen = new Set();
+        const tracks = [];
+        const objRe = /\[0,\{([^}]*)\}\]/g;
+        let obj;
+        while ((obj = objRe.exec(html)) !== null) {
+            const block = obj[1];
+            const langM = block.match(/"language"\s*:\s*\[0\s*,\s*"([^"]+)"/);
+            const nameM = block.match(/"name"\s*:\s*\[0\s*,\s*"([^"]+)"/);
+            const srcM = block.match(/"src"\s*:\s*\[0\s*,\s*"(https?:\/\/[^"]+\.(?:srt|vtt)[^"]*)"/);
+            if (!srcM)
+                continue;
+            const url = srcM[1].replace(/^https:\/\/\//, 'https://');
+            if (seen.has(url))
+                continue;
+            seen.add(url);
+            tracks.push({
+                language: langM?.[1] || 'en',
+                label: nameM?.[1] || langM?.[1] || 'English',
+                url,
+            });
+        }
+        return tracks;
+    }
+    async fetchCatStreamData(playerSrc) {
+        let masterUrl = null;
+        const subtitles = [];
+        try {
+            const res = await fetch(playerSrc, {
+                headers: {
+                    'User-Agent': KAA_UA,
+                    Referer: 'https://kaa.lt/',
+                    Origin: 'https://kaa.lt',
+                    Accept: 'text/html',
+                },
+                signal: AbortSignal.timeout(15000),
+            });
+            if (!res.ok)
+                return { masterUrl, subtitles };
+            const html = (await res.text()).replace(/&quot;/g, '"');
+            const manifestMatch = html.match(/"manifest"\s*:\s*\[0\s*,\s*"(\/\/[^"]+\.m3u8[^"]*)"\]/);
+            if (manifestMatch)
+                masterUrl = manifestMatch[1].replace(/^\/\//, 'https://');
+            subtitles.push(...this.parsePlayerSubtitles(html));
+        }
+        catch {
+            // ignore
+        }
+        return { masterUrl, subtitles };
+    }
+    async getMasterLevels(masterUrl) {
+        try {
+            const res = await fetch(masterUrl, {
+                headers: { Referer: KAA_REFERER, Origin: 'https://krussdomi.com', 'User-Agent': KAA_UA },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok)
+                return [];
+            const text = await res.text();
+            if (!text.includes('#EXT-X-MEDIA') || !text.includes('TYPE=AUDIO')) {
+                logger_1.default.warn('[KAA] master playlist has no audio group');
+            }
+            const levels = [];
+            const lines = text.split('\n');
+            let index = 0;
+            for (const raw of lines) {
+                const line = raw.trim();
+                if (!line.startsWith('#EXT-X-STREAM-INF'))
+                    continue;
+                const nameMatch = line.match(/NAME="([^"]+)"/) || line.match(/RESOLUTION=\d+x(\d+)/);
+                let label = nameMatch ? nameMatch[1] : 'HD';
+                label = label.endsWith('p') ? label : `${label}p`;
+                levels.push({ index: index++, label });
+            }
+            return levels;
+        }
+        catch {
+            return [];
+        }
+    }
+    async fetchSubtitles(playerSrc) {
+        try {
+            const res = await fetch(playerSrc, {
+                headers: {
+                    'User-Agent': KAA_UA,
+                    Referer: 'https://kaa.lt/',
+                    Origin: 'https://kaa.lt',
+                    Accept: 'text/html',
+                },
+                signal: AbortSignal.timeout(15000),
+            });
+            if (!res.ok)
+                return [];
+            const html = (await res.text()).replace(/&quot;/g, '"');
+            return this.parsePlayerSubtitles(html);
+        }
+        catch {
+            return [];
+        }
+    }
+    async getStreamUrls(showId, episodeNumber, mode) {
+        try {
+            const slug = this.stripSlug(showId);
+            if (!slug)
+                return null;
+            const epNum = Number(episodeNumber);
+            if (!Number.isInteger(epNum) || epNum < 1)
+                return null;
+            const cacheKey = `kaa_stream_${slug}_${epNum}_${mode || 'sub'}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const show = await this.kaaShowInfo(slug);
+            const locales = Array.isArray(show.locales) ? show.locales : [];
+            if (mode === 'dub' && !locales.includes('en-US'))
+                return null;
+            const epMap = await this.buildEpMap(slug, show, this.langFor(mode));
+            const ep = epMap.find((e) => e.number === epNum);
+            if (!ep)
+                return null;
+            const episodeData = await this.kaaEpisodeServers(slug, ep.fullSlug);
+            const servers = Array.isArray(episodeData.servers) ? episodeData.servers : [];
+            if (!servers.length)
+                return null;
+            const sources = [];
+            let playerSrc = '';
+            let catStreamData = null;
+            for (const s of servers) {
+                const src = s.src || '';
+                const isVidstream = src.includes('source=vidstream');
+                const isCatstream = src.includes('source=catstream');
+                if (!isVidstream && !isCatstream)
+                    continue;
+                const m = src.match(/[?&]id=([^&]+)/);
+                if (!m)
+                    continue;
+                if (!playerSrc)
+                    playerSrc = src;
+                if (isCatstream) {
+                    if (!catStreamData)
+                        catStreamData = await this.fetchCatStreamData(src);
+                    if (!catStreamData?.masterUrl)
+                        continue;
+                    const masterUrl = catStreamData.masterUrl;
+                    const linkHeaders = { Referer: KAA_REFERER };
+                    const links = [];
+                    for (const level of await this.getMasterLevels(masterUrl)) {
+                        links.push({
+                            resolutionStr: level.label,
+                            link: `/api/proxy?url=${encodeURIComponent(masterUrl)}` +
+                                `&referer=${encodeURIComponent(KAA_REFERER)}&variant=${level.index}`,
+                            hls: true,
+                            headers: linkHeaders,
+                        });
+                    }
+                    links.push({
+                        resolutionStr: 'Auto',
+                        link: this.proxyUrl(masterUrl),
+                        hls: true,
+                        headers: linkHeaders,
+                    });
+                    sources.push({
+                        sourceName: s.name ? `KAA ${s.name}` : 'KAA',
+                        links,
+                        type: 'player',
+                        actualEpisodeNumber: String(epNum),
+                    });
+                    continue;
+                }
+                const masterUrl = `${KAA_HLS_BASE}/${m[1]}/master.m3u8`;
+                const linkHeaders = { Referer: KAA_REFERER };
+                const links = [];
+                for (const level of await this.getMasterLevels(masterUrl)) {
+                    links.push({
+                        resolutionStr: level.label,
+                        link: `/api/proxy?url=${encodeURIComponent(masterUrl)}` +
+                            `&referer=${encodeURIComponent(KAA_REFERER)}&variant=${level.index}`,
+                        hls: true,
+                        headers: linkHeaders,
+                    });
+                }
+                links.push({
+                    resolutionStr: 'Auto',
+                    link: this.proxyUrl(masterUrl),
+                    hls: true,
+                    headers: linkHeaders,
+                });
+                sources.push({
+                    sourceName: s.name ? `KAA ${s.name}` : 'KAA',
+                    links,
+                    type: 'player',
+                    actualEpisodeNumber: String(epNum),
+                });
+            }
+            if (!sources.length)
+                return null;
+            const subtitles = [];
+            const seen = new Set();
+            const push = (list) => {
+                for (const t of list || []) {
+                    if (seen.has(t.url))
+                        continue;
+                    seen.add(t.url);
+                    subtitles.push(t);
+                }
+            };
+            push(catStreamData?.subtitles);
+            if (!subtitles.length && playerSrc) {
+                push(await this.fetchSubtitles(playerSrc));
+            }
+            if (subtitles.length) {
+                for (const src of sources)
+                    src.subtitles = subtitles;
+            }
+            this.cache.set(cacheKey, sources, 3600);
+            return sources;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId, episodeNumber, mode }, '[KAA] getStreamUrls failed');
+            return null;
+        }
+    }
+}
+exports.KaaProvider = KaaProvider;

package/server/dist/providers/manga/manga.types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MATURE_RATINGS = exports.SAFE_RATINGS = void 0;
+exports.SAFE_RATINGS = ['safe'];
+exports.MATURE_RATINGS = [
+    'safe',
+    'suggestive',
+    'erotica',
+    'pornographic',
+];

package/server/dist/providers/manga/mangadex.provider.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MangaDexProvider = void 0;
+const logger_1 = __importDefault(require("../../logger"));
+const API = 'https://api.mangadex.org';
+const UA = 'Dango/3.0 (+https://github.com/serifpersia/dango)';
+const PER_PAGE = 24;
+function pickTitle(titles) {
+    if (!titles)
+        return 'Unknown';
+    return titles.en || titles['ja-ro'] || Object.values(titles)[0] || 'Unknown';
+}
+function coverFromRelationships(id, rels) {
+    const cover = rels?.find((r) => r.type === 'cover_art');
+    const fileName = cover?.attributes?.fileName;
+    if (!fileName)
+        return '';
+    return `https://uploads.mangadex.org/covers/${id}/${fileName}.256.jpg`;
+}
+async function getJson(url) {
+    const res = await fetch(url, {
+        headers: { 'User-Agent': UA, Accept: 'application/json' },
+        signal: AbortSignal.timeout(20000),
+    });
+    if (!res.ok)
+        throw new Error(`MangaDex HTTP ${res.status}: ${url}`);
+    return res.json();
+}
+function cleanDescription(raw) {
+    return raw
+        .replace(/!?\[[^\]]*\]\([^)]*\)/g, (m) => {
+        const text = m.slice(m.indexOf('[') + 1, m.indexOf(']'));
+        return text || '';
+    })
+        .split('\n')
+        .filter((line) => {
+        const t = line.trim();
+        return t && !t.startsWith('|') && !/^\|\s*:?-+/.test(t) && t !== '---';
+    })
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/\s+/g, (s) => (s.includes('\n') ? s : ' '))
+        .trim()
+        .slice(0, 2000);
+}
+function toCard(m) {
+    const a = m.attributes;
+    const alt = a.altTitles?.[0] ? Object.values(a.altTitles[0])[0] : undefined;
+    return {
+        id: m.id,
+        provider: 'mangadex',
+        title: pickTitle(a.title),
+        altTitle: alt,
+        cover: coverFromRelationships(m.id, m.relationships || []),
+        status: a.status,
+        year: a.year ?? null,
+        genres: a.tags
+            ?.filter((t) => t.attributes?.group === 'genre')
+            .map((t) => t.attributes?.name?.en || '')
+            .filter(Boolean)
+            .slice(0, 6) || [],
+        contentRating: a.contentRating,
+    };
+}
+class MangaDexProvider {
+    name = 'mangadex';
+    cache;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    async search(options) {
+        const { query = '', page = 1, limit = PER_PAGE, sort = 'popular', ratings = ['safe'] } = options;
+        const offset = (Math.max(1, page) - 1) * limit;
+        const params = new URLSearchParams({
+            limit: String(Math.min(limit, 50)),
+            offset: String(offset),
+            'includes[]': 'cover_art',
+            hasAvailableChapters: 'true',
+        });
+        if (query.trim())
+            params.set('title', query.trim());
+        for (const r of ratings)
+            params.append('contentRating[]', r);
+        if (options.status)
+            params.append('status[]', options.status);
+        switch (sort) {
+            case 'latest':
+                params.set('order[latestUploadedChapter]', 'desc');
+                break;
+            case 'rating':
+                params.set('order[rating]', 'desc');
+                break;
+            case 'followed':
+                params.set('order[followedCount]', 'desc');
+                break;
+            default:
+                params.set('order[relevance]', 'desc');
+        }
+        const cacheKey = `manga-md-search-${params.toString()}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const data = await getJson(`${API}/manga?${params.toString()}`);
+            const items = (data.data || []).map(toCard);
+            const total = data.total ?? 0;
+            const result = { items, hasNext: offset + items.length < total, total };
+            this.cache.set(cacheKey, result, 300);
+            return result;
+        }
+        catch (err) {
+            logger_1.default.error({ err }, '[MangaDex] search failed');
+            return { items: [], hasNext: false };
+        }
+    }
+    async getDetail(id, ratings = ['safe']) {
+        const cacheKey = `manga-md-detail-${id}-${ratings.join(',')}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const data = await getJson(`${API}/manga/${id}?includes[]=cover_art&includes[]=author&includes[]=artist`);
+            const m = data.data;
+            if (!m)
+                return null;
+            const card = toCard(m);
+            const rels = m.relationships || [];
+            const author = rels.find((r) => r.type === 'author')?.attributes?.name;
+            const artist = rels.find((r) => r.type === 'artist')?.attributes?.name;
+            const chapters = await this.getChapters(id, ratings);
+            const detail = {
+                ...card,
+                description: cleanDescription(m.attributes.description?.en || ''),
+                author,
+                artist,
+                chapters,
+            };
+            this.cache.set(cacheKey, detail, 600);
+            return detail;
+        }
+        catch (err) {
+            logger_1.default.error({ err, id }, '[MangaDex] detail failed');
+            return null;
+        }
+    }
+    async getChapters(id, ratings = ['safe']) {
+        const cacheKey = `manga-md-chapters-${id}-${ratings.join(',')}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const params = new URLSearchParams({
+                limit: '100',
+                offset: '0',
+                'translatedLanguage[]': 'en',
+                'order[chapter]': 'asc',
+                'includes[]': 'scanlation_group',
+            });
+            for (const r of ratings)
+                params.append('contentRating[]', r);
+            const all = [];
+            const fetchFeed = async (withLang) => {
+                const out = [];
+                for (let page = 0; page < 5; page++) {
+                    const p = new URLSearchParams(params);
+                    if (!withLang)
+                        p.delete('translatedLanguage[]');
+                    p.set('offset', String(page * 100));
+                    const data = await getJson(`${API}/manga/${id}/feed?${p.toString()}`);
+                    for (const c of data.data || []) {
+                        const group = c.relationships?.find((r) => r.type === 'scanlation_group')?.attributes
+                            ?.name;
+                        out.push({
+                            id: c.id,
+                            provider: 'mangadex',
+                            mangaId: id,
+                            number: c.attributes.chapter || '?',
+                            title: c.attributes.title || undefined,
+                            volume: c.attributes.volume || undefined,
+                            language: c.attributes.translatedLanguage,
+                            pages: c.attributes.pages,
+                            group,
+                            externalUrl: c.attributes.externalUrl || undefined,
+                            publishedAt: c.attributes.publishAt,
+                        });
+                    }
+                    if ((data.data || []).length < 100)
+                        break;
+                }
+                return out;
+            };
+            const enChapters = await fetchFeed(true);
+            for (const c of enChapters)
+                all.push(c);
+            if (all.length === 0) {
+                for (const c of await fetchFeed(false))
+                    all.push(c);
+            }
+            this.cache.set(cacheKey, all, 600);
+            return all;
+        }
+        catch (err) {
+            logger_1.default.error({ err, id }, '[MangaDex] chapters failed');
+            return [];
+        }
+    }
+    async getPages(chapterId) {
+        const cacheKey = `manga-md-pages-${chapterId}`;
+        const cached = this.cache.get(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const data = await getJson(`${API}/at-home/server/${chapterId}`);
+            const pages = (data.chapter?.data || []).map((f) => `${data.baseUrl}/data/${data.chapter.hash}/${f}`);
+            this.cache.set(cacheKey, pages, 300);
+            return pages;
+        }
+        catch (err) {
+            logger_1.default.error({ err, chapterId }, '[MangaDex] pages failed');
+            return [];
+        }
+    }
+}
+exports.MangaDexProvider = MangaDexProvider;