nekostream 2026.4.2 → 2026.4.4

package/dist/cli/web-server.js

@@ -0,0 +1,554 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureWebBuilt = ensureWebBuilt;
+exports.openBrowser = openBrowser;
+exports.handleApiRoute = handleApiRoute;
+exports.startWebServer = startWebServer;
+const node_http_1 = __importDefault(require("node:http"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const providers_1 = require("../providers");
+const provider_types_1 = require("../provider-types");
+const storage_1 = require("../storage");
+const logger_1 = require("../logger");
+const anilist_api_1 = require("../scrapers/anilist-api");
+const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.mjs': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+};
+function sendJson(res, statusCode, data) {
+    const json = JSON.stringify(data);
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    });
+    res.end(json);
+}
+function sendError(res, statusCode, message) {
+    sendJson(res, statusCode, { error: message });
+}
+function cleanSynopsis(text) {
+    if (!text)
+        return '';
+    return text
+        .replace(/<br\s*\/?>/gi, ' ')
+        .replace(/<\/p>/gi, ' ')
+        .replace(/<[^>]+>/g, '')
+        .replace(/&quot;/g, '"')
+        .replace(/&#039;/g, "'")
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&nbsp;/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function parseJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk;
+            if (body.length > 1e6) {
+                req.destroy();
+                reject(new Error('Payload too large'));
+            }
+        });
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+function resolveWebDistDir() {
+    const candidates = [
+        node_path_1.default.join(__dirname, '..', 'web', 'dist'),
+        node_path_1.default.join(process.cwd(), 'web', 'dist'),
+        node_path_1.default.join(__dirname, '..', 'dist', 'web'),
+        node_path_1.default.join(process.cwd(), 'dist', 'web'),
+        node_path_1.default.join(__dirname, '..', '..', 'web', 'dist'),
+        node_path_1.default.join(__dirname, '..', '..', 'dist', 'web'),
+    ];
+    for (const dir of candidates) {
+        if (node_fs_1.default.existsSync(dir) && node_fs_1.default.existsSync(node_path_1.default.join(dir, 'index.html'))) {
+            return dir;
+        }
+    }
+    return null;
+}
+function ensureWebBuilt() {
+    if (resolveWebDistDir())
+        return;
+    const webDirCandidates = [
+        node_path_1.default.join(process.cwd(), 'web'),
+        node_path_1.default.join(__dirname, '..', 'web'),
+        node_path_1.default.join(__dirname, '..', '..', 'web'),
+    ];
+    for (const webDir of webDirCandidates) {
+        if (node_fs_1.default.existsSync(node_path_1.default.join(webDir, 'package.json'))) {
+            try {
+                console.log('[NekoStream Web] Chưa tìm thấy bản build giao diện, đang tự động build...');
+                (0, node_child_process_1.execSync)('npm run build', { cwd: webDir, stdio: 'inherit' });
+                break;
+            }
+            catch (e) {
+                (0, logger_1.debugError)('Không thể tự động build web:', e);
+            }
+        }
+    }
+}
+function serveStatic(reqPath, distDir, res) {
+    const safePath = node_path_1.default.normalize(decodeURIComponent(reqPath)).replace(/^(\.\.[/\\])+/, '');
+    let filePath = node_path_1.default.join(distDir, safePath);
+    if (node_fs_1.default.existsSync(filePath) && node_fs_1.default.statSync(filePath).isDirectory()) {
+        filePath = node_path_1.default.join(filePath, 'index.html');
+    }
+    // SPA fallback
+    if (!node_fs_1.default.existsSync(filePath)) {
+        filePath = node_path_1.default.join(distDir, 'index.html');
+    }
+    if (!node_fs_1.default.existsSync(filePath)) {
+        sendError(res, 404, 'Web assets not found. Run npm run web:build first.');
+        return;
+    }
+    const ext = node_path_1.default.extname(filePath).toLowerCase();
+    const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
+    try {
+        const content = node_fs_1.default.readFileSync(filePath);
+        res.writeHead(200, {
+            'Content-Type': mimeType,
+            'Access-Control-Allow-Origin': '*',
+            'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=31536000, immutable',
+        });
+        res.end(content);
+    }
+    catch (err) {
+        (0, logger_1.debugError)('Error serving static file', err);
+        sendError(res, 500, 'Internal Server Error');
+    }
+}
+function openBrowser(url) {
+    const startCmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    (0, node_child_process_1.exec)(`${startCmd} ${url}`, (err) => {
+        if (err) {
+            (0, logger_1.debugLog)('Could not auto-open browser', err.message);
+        }
+    });
+}
+const detailMemoryCache = new Map();
+const DETAIL_CACHE_TTL = 15 * 60 * 1000; // 15 mins
+const scheduleMemoryCache = new Map();
+const SCHEDULE_CACHE_TTL = 30 * 60 * 1000; // 30 mins
+async function handleApiRoute(req, res, urlObj) {
+    const pathname = urlObj.pathname;
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204, {
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        });
+        res.end();
+        return true;
+    }
+    if (!pathname.startsWith('/api/')) {
+        return false;
+    }
+    const providerParam = (urlObj.searchParams.get('provider') || 'animevietsub');
+    const providerId = provider_types_1.PROVIDER_IDS.includes(providerParam) ? providerParam : 'animevietsub';
+    try {
+        if (pathname === '/api/health') {
+            sendJson(res, 200, { status: 'ok', version: '2026.4.4' });
+            return true;
+        }
+        if (pathname === '/api/providers') {
+            const providers = provider_types_1.PROVIDER_IDS.map((id) => ({
+                id,
+                name: id === 'animevietsub' ? 'AnimeVietsub' : id === 'anime47' ? 'Anime47' : 'AnimeHay',
+                isDefault: id === 'animevietsub',
+                isDeprecated: id === 'anime47' || id === 'animehay',
+                warning: id === 'anime47' || id === 'animehay'
+                    ? 'Provider này có thể không còn hoạt động đúng chức năng, khuyên bạn chuyển sang sử dụng AnimeVietsub Provider để có trải nghiệm tốt nhất.'
+                    : undefined,
+            }));
+            sendJson(res, 200, { providers });
+            return true;
+        }
+        if (pathname === '/api/home') {
+            const provider = (0, providers_1.getProvider)(providerId);
+            const [trending, latest, upcoming] = await Promise.all([
+                provider.getHomeCards('trending').catch(() => []),
+                provider.getHomeCards('latest').catch(() => []),
+                provider.getHomeCards('upcoming').catch(() => []),
+            ]);
+            for (const item of upcoming) {
+                if (item.description)
+                    item.description = cleanSynopsis(item.description);
+            }
+            // Enrich top spotlight candidates (top 6 trending items) with AniList HD images and metadata
+            const spotlightCandidates = trending.slice(0, 6);
+            await Promise.allSettled(spotlightCandidates.map(async (card) => {
+                try {
+                    let meta = await anilist_api_1.anilistApi.getEnhancedMetadata(card.title, card.titleAlt || card.originalTitle);
+                    if (!meta?.banner && card.id) {
+                        const detail = await provider.getAnimeDetail(card.id).catch(() => null);
+                        if (detail) {
+                            if (detail.banner)
+                                card.banner = detail.banner;
+                            if (detail.cover && (!card.cover || card.cover.includes('animevietsub'))) {
+                                card.cover = detail.cover;
+                            }
+                            if (detail.description && !card.description)
+                                card.description = detail.description;
+                            if (detail.genres && detail.genres.length > 0)
+                                card.tags = detail.genres;
+                            if (!card.banner && detail.titleAlt) {
+                                meta = await anilist_api_1.anilistApi.getEnhancedMetadata(card.title, detail.titleAlt);
+                                if (meta) {
+                                    if (meta.banner)
+                                        card.banner = meta.banner;
+                                    if (meta.cover)
+                                        card.cover = meta.cover;
+                                    if (meta.synopsis && !card.description)
+                                        card.description = meta.synopsis;
+                                    if (meta.genres)
+                                        card.tags = meta.genres;
+                                }
+                            }
+                        }
+                    }
+                    else if (meta) {
+                        if (meta.banner)
+                            card.banner = meta.banner;
+                        if (meta.cover)
+                            card.cover = meta.cover;
+                        if (meta.synopsis)
+                            card.description = meta.synopsis;
+                        if (meta.genres && meta.genres.length > 0)
+                            card.tags = meta.genres;
+                        if (meta.score && !card.rating)
+                            card.rating = meta.score / 10;
+                    }
+                }
+                catch {
+                    /* non-fatal */
+                }
+            }));
+            const history = (0, storage_1.loadHistory)();
+            const billboard = trending.length > 0 ? trending[0] : latest.length > 0 ? latest[0] : null;
+            sendJson(res, 200, {
+                billboard,
+                trending,
+                latest,
+                upcoming,
+                continueWatching: history.slice(0, 10),
+            });
+            return true;
+        }
+        if (pathname === '/api/cards') {
+            const section = (urlObj.searchParams.get('section') || 'trending');
+            const page = Math.max(1, parseInt(urlObj.searchParams.get('page') || '1', 10));
+            const provider = (0, providers_1.getProvider)(providerId);
+            const results = await provider.getHomeCards(section, page).catch(() => []);
+            for (const item of results) {
+                if (item.description)
+                    item.description = cleanSynopsis(item.description);
+            }
+            sendJson(res, 200, { section, page, results });
+            return true;
+        }
+        if (pathname === '/api/genre') {
+            const genre = urlObj.searchParams.get('genre') || '';
+            const page = Math.max(1, parseInt(urlObj.searchParams.get('page') || '1', 10));
+            if (!genre) {
+                sendError(res, 400, 'Missing genre parameter');
+                return true;
+            }
+            const cacheKey = `${providerId}:genre:${genre}:${page}`;
+            const cached = detailMemoryCache.get(cacheKey);
+            if (cached && Date.now() - cached.timestamp < DETAIL_CACHE_TTL) {
+                sendJson(res, 200, { genre, page, results: cached.detail });
+                return true;
+            }
+            const provider = (0, providers_1.getProvider)(providerId);
+            const results = await provider.getAnimeByGenre(genre, page).catch(() => []);
+            for (const item of results) {
+                if (item.description)
+                    item.description = cleanSynopsis(item.description);
+            }
+            detailMemoryCache.set(cacheKey, { detail: results, episodes: [], timestamp: Date.now() });
+            sendJson(res, 200, { genre, page, results });
+            return true;
+        }
+        if (pathname === '/api/enrich') {
+            const title = urlObj.searchParams.get('title') || '';
+            const alt = urlObj.searchParams.get('alt') || '';
+            if (!title) {
+                sendJson(res, 200, { data: null });
+                return true;
+            }
+            try {
+                const meta = await anilist_api_1.anilistApi.getEnhancedMetadata(title, alt || undefined);
+                if (meta?.synopsis) {
+                    meta.synopsis = cleanSynopsis(meta.synopsis);
+                }
+                sendJson(res, 200, { data: meta });
+            }
+            catch {
+                sendJson(res, 200, { data: null });
+            }
+            return true;
+        }
+        if (pathname === '/api/search') {
+            const q = urlObj.searchParams.get('q') || '';
+            if (!q.trim()) {
+                sendJson(res, 200, { results: [] });
+                return true;
+            }
+            const provider = (0, providers_1.getProvider)(providerId);
+            const results = await provider.search(q.trim());
+            sendJson(res, 200, { results });
+            return true;
+        }
+        if (pathname === '/api/detail') {
+            const id = urlObj.searchParams.get('id') || '';
+            if (!id) {
+                sendError(res, 400, 'Missing anime id');
+                return true;
+            }
+            const cacheKey = `${providerId}:${id}`;
+            const cached = detailMemoryCache.get(cacheKey);
+            if (cached && Date.now() - cached.timestamp < DETAIL_CACHE_TTL) {
+                sendJson(res, 200, { detail: cached.detail, episodes: cached.episodes });
+                return true;
+            }
+            const provider = (0, providers_1.getProvider)(providerId);
+            const [detail, episodes] = await Promise.all([
+                provider.getAnimeDetail(id),
+                provider.getEpisodes(id).catch(() => []),
+            ]);
+            if (detail) {
+                if (detail.description && /kanefusa|fansub|webdescription|vua hải tặc đảo hải tặc/i.test(detail.description)) {
+                    detail.description = undefined;
+                }
+                if (detail.description) {
+                    detail.description = cleanSynopsis(detail.description);
+                }
+                try {
+                    const meta = await anilist_api_1.anilistApi.getEnhancedMetadata(detail.title, detail.titleAlt);
+                    if (meta) {
+                        if (meta.banner && !detail.banner)
+                            detail.banner = meta.banner;
+                        if (meta.cover && (!detail.cover || detail.cover.includes('animevietsub'))) {
+                            detail.cover = meta.cover;
+                        }
+                        if (meta.synopsis && (!detail.description || detail.description.length < 25)) {
+                            detail.description = cleanSynopsis(meta.synopsis);
+                        }
+                        if (meta.score && !detail.rating) {
+                            detail.rating = meta.score / 10;
+                        }
+                    }
+                }
+                catch {
+                    /* non-fatal */
+                }
+            }
+            detailMemoryCache.set(cacheKey, { detail, episodes, timestamp: Date.now() });
+            sendJson(res, 200, { detail, episodes });
+            return true;
+        }
+        if (pathname === '/api/schedule') {
+            const cacheKey = providerId;
+            const cached = scheduleMemoryCache.get(cacheKey);
+            if (cached && Date.now() - cached.timestamp < SCHEDULE_CACHE_TTL) {
+                sendJson(res, 200, { schedule: cached.schedule });
+                return true;
+            }
+            const provider = (0, providers_1.getProvider)(providerId);
+            const schedule = await provider.getSchedule().catch(() => []);
+            scheduleMemoryCache.set(cacheKey, { schedule, timestamp: Date.now() });
+            sendJson(res, 200, { schedule });
+            return true;
+        }
+        if (pathname === '/api/servers') {
+            const episodeId = urlObj.searchParams.get('episodeId') || '';
+            if (!episodeId) {
+                sendError(res, 400, 'Missing episodeId');
+                return true;
+            }
+            const provider = (0, providers_1.getProvider)(providerId);
+            let servers = await provider.getVideoServers(episodeId);
+            servers = servers.sort((a, b) => {
+                const score = (s) => {
+                    const n = (s.name || '').toUpperCase();
+                    if (n.includes('HDX') || n.includes('HYDRAX') || n.includes('ABYSS'))
+                        return 100;
+                    if (n.includes('VIP'))
+                        return 80;
+                    if (n.includes('FB'))
+                        return 70;
+                    if (n.includes('GOOGLE'))
+                        return 60;
+                    if (n.includes('DU'))
+                        return 10;
+                    return 50;
+                };
+                return score(b) - score(a);
+            });
+            sendJson(res, 200, { servers });
+            return true;
+        }
+        if (pathname === '/api/stream') {
+            const embedUrl = urlObj.searchParams.get('serverUrl') || '';
+            const name = urlObj.searchParams.get('serverName') || 'VIP';
+            const type = urlObj.searchParams.get('serverType') || 'hls';
+            const quality = urlObj.searchParams.get('serverQuality') || '1080p';
+            if (!embedUrl) {
+                sendError(res, 400, 'Missing serverUrl');
+                return true;
+            }
+            const server = {
+                name,
+                embedUrl,
+                type,
+                quality,
+                source: providerId,
+            };
+            const provider = (0, providers_1.getProvider)(providerId);
+            const stream = await provider.extractStreamUrl(server);
+            sendJson(res, 200, { stream });
+            return true;
+        }
+        if (pathname === '/api/history') {
+            if (req.method === 'GET') {
+                const history = (0, storage_1.loadHistory)();
+                sendJson(res, 200, { history });
+                return true;
+            }
+            if (req.method === 'POST') {
+                const body = await parseJsonBody(req);
+                if (body.animeId && body.animeTitle) {
+                    (0, storage_1.saveHistoryEntry)({
+                        provider: body.provider || providerId,
+                        animeId: body.animeId,
+                        animeTitle: body.animeTitle,
+                        episodeId: body.episodeId || '1',
+                        episodeTitle: body.episodeTitle || 'Tập 1',
+                    });
+                    sendJson(res, 200, { ok: true });
+                    return true;
+                }
+                sendError(res, 400, 'Invalid history payload');
+                return true;
+            }
+        }
+        if (pathname === '/api/settings') {
+            if (req.method === 'GET') {
+                const settings = (0, storage_1.loadSettings)();
+                sendJson(res, 200, { settings });
+                return true;
+            }
+            if (req.method === 'POST') {
+                const body = await parseJsonBody(req);
+                (0, storage_1.saveSettings)(body);
+                sendJson(res, 200, { ok: true, settings: (0, storage_1.loadSettings)() });
+                return true;
+            }
+        }
+        sendError(res, 404, 'Endpoint not found');
+        return true;
+    }
+    catch (err) {
+        (0, logger_1.debugError)(`API Error on ${pathname}:`, err);
+        sendError(res, 500, err?.message || 'Internal Server Error');
+        return true;
+    }
+}
+function startWebServer(desiredPort = 3000, host = '0.0.0.0') {
+    ensureWebBuilt();
+    return new Promise((resolve, reject) => {
+        const server = node_http_1.default.createServer(async (req, res) => {
+            try {
+                const hostHeader = req.headers.host || `localhost:${desiredPort}`;
+                const urlObj = new URL(req.url || '/', `http://${hostHeader}`);
+                const handled = await handleApiRoute(req, res, urlObj);
+                if (handled)
+                    return;
+                const distDir = resolveWebDistDir();
+                if (distDir) {
+                    serveStatic(urlObj.pathname, distDir, res);
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                    res.end(`<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>NekoStream Web Server</title>
+  <style>
+    body { background: #0f0b13; color: #fff1ea; font-family: sans-serif; display: flex; flex-direction: column; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+    h1 { color: #ff5c93; margin-bottom: 8px; }
+    p { color: #c9b8bf; }
+    code { background: #1a1420; padding: 4px 8px; border-radius: 8px; color: #7be3b8; }
+  </style>
+</head>
+<body>
+  <h1>NekoStream Web Server Online</h1>
+  <p>Backend API đang chạy bình thường tại cổng <code>${desiredPort}</code>.</p>
+  <p>Giao diện Web chưa được build. Vui lòng chạy <code>npm run web:build</code> để kích hoạt frontend.</p>
+</body>
+</html>`);
+                }
+            }
+            catch (err) {
+                (0, logger_1.debugError)('Web server unhandled error:', err);
+                sendError(res, 500, 'Server internal failure');
+            }
+        });
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                (0, logger_1.debugLog)(`Port ${desiredPort} in use, trying ${desiredPort + 1}...`);
+                resolve(startWebServer(desiredPort + 1, host));
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(desiredPort, host, () => {
+            const address = server.address();
+            const actualPort = typeof address === 'object' && address ? address.port : desiredPort;
+            const url = `http://localhost:${actualPort}`;
+            (0, logger_1.debugLog)(`NekoStream Web server listening at ${url}`);
+            resolve({
+                port: actualPort,
+                url,
+                close: () => new Promise((resClose) => {
+                    server.close(() => resClose());
+                }),
+            });
+        });
+    });
+}

package/dist/player-policy.js

@@ -18,7 +18,13 @@ exports.PROVIDER_LABELS = ['animevietsub', 'anime47', 'animehay'];
 exports.STREAM_HOSTS = [
     'abyss.to',
     'abysscdn.com',
+    'abyssplayer.com',
+    'abysshost.com',
+    'abysscss.com',
     'hydrax.net',
+    'playhydrax.com',
+    'short.ink',
+    'iamcdn.net',
     'googleapiscdn.com',
     'googleapis.com',
     'gstatic.com',

package/dist/scrapers/adblock-policy.js

@@ -13,6 +13,9 @@ exports.isAdUrl = isAdUrl;
  * Matched strictly against hostnames to prevent false positives on URL paths.
  */
 exports.AD_HOST_FRAGMENTS = [
+    'bom88',
+    'bom-88',
+    'bomtan',
     'in88',
     'quayhu',
     'nohu',
@@ -108,7 +111,10 @@ function isAdUrl(urlText) {
     if (!urlText)
         return false;
     const lower = urlText.toLowerCase();
-    return (lower.includes('win88') ||
+    return (lower.includes('bom88') ||
+        lower.includes('bom-88') ||
+        lower.includes('bomtan') ||
+        lower.includes('win88') ||
         lower.includes('i9bet') ||
         lower.includes('yo88') ||
         lower.includes('fb88') ||
@@ -128,14 +134,17 @@ function isAdUrl(urlText) {
  * CSS stylesheet injected into pages to hide ad elements and overlays.
  */
 exports.AD_HIDE_CSS = `
+  a[href*="bom88"], a[href*="bomtan"],
   a[href*="win88"], a[href*="yo88"], a[href*="i9bet"],
   a[href*="sunwin"], a[href*="vsbet"], a[href*="five88"],
   a[href*="hit.club"], a[href*="gemwin"], a[href*="789bet"],
   a[href*="7zwin"], a[href*="rikvip"], a[href*="casino"],
+  img[src*="bom88"], img[src*="bomtan"],
   img[src*="win88"], img[src*="yo88"], img[src*="i9bet"],
   img[src*="sunwin"], img[src*="gemwin"],
   img[src*="vsbet"], img[src*="five88"], img[src*="hit.club"],
   img[src*="7zwin"], img[src*="rikvip"], img[src*="casino"],
+  [class*="bom88"], [id*="bom88"], [class*="bomtan"],
   [class*="quang-cao"], [id*="quang-cao"],
   [class*="advert"], [id*="advert"], [class*="banner-ad"], [id*="banner-ad"],
   [class*="popup-ad"], [class*="ad-overlay"],