nekostream 2026.0.1

package/dist/player.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchPlayer = launchPlayer;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+async function launchPlayer(streamInfo) {
+    return new Promise((resolve, reject) => {
+        // If compiled, __dirname is .../dist. If dev, __dirname is root.
+        const isCompiled = __dirname.endsWith('dist') || __dirname.endsWith('dist\\') || __dirname.endsWith('dist/');
+        const basePath = isCompiled ? path_1.default.join(__dirname, '..') : __dirname;
+        const mainScript = path_1.default.join(basePath, 'player-main.js');
+        const env = {
+            ...process.env,
+            NEKOSTREAM_CLI_STREAM: Buffer.from(JSON.stringify(streamInfo)).toString('base64')
+        };
+        const electronBinary = require('electron');
+        const electronProcess = (0, child_process_1.spawn)(electronBinary, [mainScript], {
+            env,
+            stdio: 'ignore',
+            shell: false
+        });
+        electronProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Player exited with code ${code}`));
+            }
+        });
+        electronProcess.on('error', (err) => {
+            reject(err);
+        });
+    });
+}

package/dist/prompts-wrapper.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Separator = void 0;
+exports.default = prompts;
+const prompts_1 = require("@inquirer/prompts");
+Object.defineProperty(exports, "Separator", { enumerable: true, get: function () { return prompts_1.Separator; } });
+const readline_1 = __importDefault(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+async function prompts(options) {
+    const ac = new AbortController();
+    // Ensure keypress events are emitted on stdin so we can intercept Esc
+    if (process.stdin.isTTY) {
+        readline_1.default.emitKeypressEvents(process.stdin);
+    }
+    const onKeypress = (str, key) => {
+        if (key && key.name === 'escape') {
+            ac.abort(new Error('ESC_PRESSED'));
+        }
+    };
+    process.stdin.on('keypress', onKeypress);
+    try {
+        if (options.type === 'select') {
+            const choices = options.choices.map((c) => {
+                if (c.separator)
+                    return new prompts_1.Separator(chalk_1.default.magenta.bold(`\n [ ${c.separator} ]`));
+                return {
+                    name: c.title,
+                    value: c.value,
+                    description: c.description
+                };
+            });
+            if (options.message.includes('Esc')) {
+                options.message = options.message.replace('(Press Esc to go back)', '(Nhấn Esc để quay lại)').trim();
+                choices.push({ name: '[0] 🔙 Go Back', value: '__GOBACK__' });
+            }
+            const result = await (0, prompts_1.select)({
+                message: options.message,
+                choices: choices,
+                pageSize: 15,
+                loop: false,
+                theme: {
+                    helpMode: 'always',
+                    style: {
+                        keysHelpTip: () => '↑↓: cuộn • ↵: chọn • Esc: quay lại'
+                    }
+                } // Use as any to inject our custom keysHelpTip if supported, otherwise fallback
+            }, { signal: ac.signal });
+            if (result === '__GOBACK__') {
+                return {};
+            }
+            return { [options.name]: result };
+        }
+        if (options.type === 'text') {
+            const result = await (0, prompts_1.input)({
+                message: options.message.replace('(Press Esc to go back)', '(Nhấn Esc để quay lại)').trim(),
+                default: options.initial
+            }, { signal: ac.signal });
+            return { [options.name]: result };
+        }
+        if (options.type === 'confirm') {
+            const result = await (0, prompts_1.confirm)({
+                message: options.message
+            }, { signal: ac.signal });
+            return { [options.name]: result };
+        }
+    }
+    catch (err) {
+        // Catch Inquirer abort errors (Ctrl+C or our custom Esc abort)
+        if (err.name === 'ExitPromptError' || err.name === 'AbortPromptError' || err.message === 'ESC_PRESSED') {
+            return {};
+        }
+        throw err;
+    }
+    finally {
+        process.stdin.off('keypress', onKeypress);
+    }
+    return {};
+}

package/dist/providers.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providers = void 0;
+exports.getProvider = getProvider;
+const animevietsub_1 = require("./scrapers/providers/animevietsub");
+const anime47_1 = require("./scrapers/providers/anime47");
+const animehay_1 = require("./scrapers/providers/animehay");
+exports.providers = {
+    animevietsub: new animevietsub_1.AnimeVietsubProvider(),
+    anime47: new anime47_1.Anime47Provider(),
+    animehay: new animehay_1.AnimehayProvider()
+};
+function getProvider(name) {
+    const providerName = name.toLowerCase();
+    const provider = exports.providers[providerName];
+    if (!provider) {
+        throw new Error(`Provider not found: ${name}`);
+    }
+    // Inject custom domain if configured
+    try {
+        const { loadSettings } = require('./storage');
+        const settings = loadSettings();
+        if (settings.providerDomains && settings.providerDomains[providerName]) {
+            let customDomain = settings.providerDomains[providerName];
+            if (!customDomain.startsWith('http'))
+                customDomain = 'https://' + customDomain;
+            // Remove trailing slash
+            provider.baseUrl = customDomain.replace(/\/$/, '');
+        }
+    }
+    catch (e) {
+        // Ignore storage errors here to avoid breaking provider resolution
+    }
+    return provider;
+}

package/dist/scrapers/anilist-api.js

@@ -0,0 +1,516 @@
+"use strict";
+// AniList API service for fetching anime metadata and images
+// Uses GraphQL API - https://docs.anilist.co/guide/introduction
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anilistApi = exports.AniListApiService = void 0;
+// ============ Cache Implementation ============
+const cache = new Map();
+const CACHE_TTL = 1000 * 60 * 60 * 24; // 24 hours
+function getCached(key) {
+    const cached = cache.get(key);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+        return cached.data;
+    }
+    return null;
+}
+function setCache(key, data) {
+    cache.set(key, { data, timestamp: Date.now() });
+}
+// ============ Session-level Result Cache ============
+// Prevents triple API calls (cover + banner + metadata) for same anime in one session
+const sessionResultCache = new Map();
+// ============ GraphQL Queries ============
+const SEARCH_QUERY = `
+query ($search: String, $page: Int, $perPage: Int) {
+  Page(page: $page, perPage: $perPage) {
+    media(search: $search, type: ANIME, sort: SEARCH_MATCH, isAdult: false) {
+      id
+      idMal
+      title {
+        romaji
+        english
+        native
+      }
+      synonyms
+      coverImage {
+        extraLarge
+        large
+        medium
+      }
+      bannerImage
+      description(asHtml: false)
+      episodes
+      status
+      averageScore
+      genres
+      studios(isMain: true) {
+        nodes {
+          name
+        }
+      }
+    }
+  }
+}
+`;
+const GET_BY_ID_QUERY = `
+query ($id: Int) {
+  Media(id: $id, type: ANIME) {
+    id
+    idMal
+    title {
+      romaji
+      english
+      native
+    }
+    synonyms
+    coverImage {
+      extraLarge
+      large
+      medium
+    }
+    bannerImage
+    description(asHtml: false)
+    episodes
+    status
+    averageScore
+    genres
+    studios(isMain: true) {
+      nodes {
+        name
+      }
+    }
+  }
+}
+`;
+const GET_BY_MAL_ID_QUERY = `
+query ($idMal: Int) {
+  Media(idMal: $idMal, type: ANIME) {
+    id
+    idMal
+    title {
+      romaji
+      english
+      native
+    }
+    synonyms
+    coverImage {
+      extraLarge
+      large
+      medium
+    }
+    bannerImage
+    description(asHtml: false)
+    episodes
+    status
+    averageScore
+    genres
+    studios(isMain: true) {
+      nodes {
+        name
+      }
+    }
+  }
+}
+`;
+// ============ AniList API Service ============
+class AniListApiService {
+    endpoint = 'https://graphql.anilist.co';
+    lastRequestTime = 0;
+    rateLimitRemaining = 90;
+    rateLimitReset = 0;
+    requestQueue = Promise.resolve();
+    transformUrlsInObject(obj) {
+        if (!obj)
+            return obj;
+        if (typeof obj === 'string') {
+            // Transform AniList CDN URLs to go through our image proxy
+            if (obj.startsWith('https://s4.anilist.co') ||
+                obj.startsWith('https://media.anilist.co')) {
+                return `nekostream-image://proxy?url=${encodeURIComponent(obj)}`;
+            }
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this.transformUrlsInObject(item));
+        }
+        if (typeof obj === 'object') {
+            const result = {};
+            for (const key of Object.keys(obj)) {
+                result[key] = this.transformUrlsInObject(obj[key]);
+            }
+            return result;
+        }
+        return obj;
+    }
+    async graphqlRequest(query, variables) {
+        return new Promise((resolve, reject) => {
+            this.requestQueue = this.requestQueue.then(async () => {
+                try {
+                    const now = Date.now();
+                    // Dynamic throttling based on remaining requests
+                    if (this.rateLimitRemaining <= 5 && now < this.rateLimitReset) {
+                        const waitTime = this.rateLimitReset - now;
+                        console.log(`[AniList] Rate limit low (${this.rateLimitRemaining} left). Waiting ${waitTime}ms...`);
+                        await new Promise(r => setTimeout(r, waitTime + 500));
+                    }
+                    else {
+                        // Soft delay to spread out requests sequentially
+                        const timeSinceLastRequest = Date.now() - this.lastRequestTime;
+                        const minDelay = this.rateLimitRemaining < 30 ? 1000 : 350;
+                        if (timeSinceLastRequest < minDelay) {
+                            await new Promise(r => setTimeout(r, minDelay - timeSinceLastRequest));
+                        }
+                    }
+                    this.lastRequestTime = Date.now();
+                    const response = await fetch(this.endpoint, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'Accept': 'application/json',
+                        },
+                        body: JSON.stringify({ query, variables }),
+                    });
+                    // Parse rate limit headers
+                    const remaining = response.headers.get('x-ratelimit-remaining');
+                    const reset = response.headers.get('x-ratelimit-reset');
+                    if (remaining)
+                        this.rateLimitRemaining = parseInt(remaining, 10);
+                    if (reset) {
+                        const resetTime = parseInt(reset, 10);
+                        if (resetTime > 1000000000) {
+                            this.rateLimitReset = resetTime * 1000;
+                        }
+                    }
+                    // Handle rate limiting
+                    if (response.status === 429) {
+                        const retryAfter = response.headers.get('Retry-After');
+                        let waitTime = retryAfter ? parseInt(retryAfter, 10) * 1000 : 60000;
+                        if (this.rateLimitReset && this.rateLimitReset > Date.now()) {
+                            waitTime = Math.max(waitTime, this.rateLimitReset - Date.now());
+                        }
+                        console.warn(`[AniList] Rate limited! Waiting ${waitTime}ms...`);
+                        await new Promise(r => setTimeout(r, waitTime + 1000));
+                        const result = await this.graphqlRequest(query, variables);
+                        resolve(result);
+                        return;
+                    }
+                    if (!response.ok) {
+                        throw new Error(`AniList API error: ${response.status}`);
+                    }
+                    const rawJson = await response.json();
+                    const json = this.transformUrlsInObject(rawJson);
+                    if (json.errors && json.errors.length > 0) {
+                        const error = json.errors[0];
+                        if (error.status === 429) {
+                            await new Promise(r => setTimeout(r, 60000));
+                            const result = await this.graphqlRequest(query, variables);
+                            resolve(result);
+                            return;
+                        }
+                        throw new Error(`AniList GraphQL error: ${error.message}`);
+                    }
+                    resolve(json);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            }).catch(reject);
+        });
+    }
+    /**
+     * Search anime by title
+     */
+    async searchAnime(title, limit = 8) {
+        const cacheKey = `anilist-search:${title.toLowerCase()}`;
+        const cached = getCached(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const cleanTitle = this.cleanTitle(title);
+            const response = await this.graphqlRequest(SEARCH_QUERY, { search: cleanTitle, page: 1, perPage: limit });
+            const results = response.data?.Page?.media || [];
+            if (results.length > 0) {
+                setCache(cacheKey, results);
+            }
+            return results;
+        }
+        catch (error) {
+            console.error(`AniList searchAnime error for "${title}":`, error);
+            return [];
+        }
+    }
+    /**
+     * Get anime by AniList ID
+     */
+    async getAnimeById(anilistId) {
+        const cacheKey = `anilist-by-id:${anilistId}`;
+        const cached = getCached(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const response = await this.graphqlRequest(GET_BY_ID_QUERY, { id: anilistId });
+            const anime = response.data?.Media || null;
+            if (anime)
+                setCache(cacheKey, anime);
+            return anime;
+        }
+        catch (error) {
+            console.error(`AniList getAnimeById error for ID ${anilistId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get anime by MAL ID (cross-reference)
+     */
+    async getAnimeByMalId(malId) {
+        const cacheKey = `anilist-by-mal:${malId}`;
+        const cached = getCached(cacheKey);
+        if (cached)
+            return cached;
+        try {
+            const response = await this.graphqlRequest(GET_BY_MAL_ID_QUERY, { idMal: malId });
+            const anime = response.data?.Media || null;
+            if (anime)
+                setCache(cacheKey, anime);
+            return anime;
+        }
+        catch (error) {
+            console.error(`AniList getAnimeByMalId error for MAL ID ${malId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Core search with session-level caching.
+     * Returns the best matching AniListMedia or null.
+     * This is the single entry point - cover, banner, and metadata all use this.
+     */
+    async findBestAnime(title, titleAlt) {
+        // Build a stable session cache key
+        const sessionKey = `${title.toLowerCase()}|${(titleAlt || '').toLowerCase()}`;
+        if (sessionResultCache.has(sessionKey)) {
+            return sessionResultCache.get(sessionKey);
+        }
+        const match = await this.findByTitleVariants(title, titleAlt);
+        // Store in session cache (null also cached to prevent redundant searches)
+        sessionResultCache.set(sessionKey, match);
+        return match;
+    }
+    /**
+     * Tries title variants in priority order, stops as soon as a confident match is found.
+     * Max 2 API queries in most cases.
+     */
+    async findByTitleVariants(title, titleAlt) {
+        // Split multi-name strings by comma → get individual clean names
+        const altVariants = titleAlt
+            ? titleAlt.split(',').map(s => s.trim()).filter(s => s.length >= 2)
+            : [];
+        const titleVariants = title
+            ? title.split(',').map(s => s.trim()).filter(s => s.length >= 2)
+            : [];
+        // Priority: best alt names first, then main names
+        // Use Set to deduplicate
+        const seen = new Set();
+        const queriesToTry = [];
+        for (const v of [...altVariants, ...titleVariants]) {
+            const lower = v.toLowerCase();
+            if (!seen.has(lower)) {
+                seen.add(lower);
+                queriesToTry.push(v);
+            }
+        }
+        // Filter out bad queries:
+        // - Too short (< 4 chars) - prevents 3-letter acronyms like NGO, SAO, EVA causing false matches
+        // - All uppercase & short (≤ 5 chars) - abbreviations: NGO, SAO, BOT, etc.
+        const isUsableQuery = (q) => {
+            const trimmed = q.trim();
+            if (trimmed.length < 4)
+                return false;
+            if (trimmed.length <= 5 && trimmed === trimmed.toUpperCase() && /^[A-Z]+$/.test(trimmed))
+                return false;
+            return true;
+        };
+        const validQueries = queriesToTry.filter(isUsableQuery);
+        if (validQueries.length === 0) {
+            console.log(`[AniList] All queries filtered out (too short/acronym) for: "${title}" / "${titleAlt}"`);
+            return null;
+        }
+        for (const query of validQueries) {
+            console.log('[AniList] Searching with query:', query);
+            const results = await this.searchAnime(query);
+            if (results.length > 0) {
+                const match = this.findBestMatch(results, title, titleAlt);
+                if (match) {
+                    console.log(`[AniList] ✅ Matched: "${match.title.romaji}" (score threshold passed)`);
+                    return match;
+                }
+                // Got results but no confident match → try next variant
+                console.log(`[AniList] Results found for "${query}" but no confident match, trying next...`);
+            }
+        }
+        console.log(`[AniList] No match found for: "${title}" / "${titleAlt}"`);
+        return null;
+    }
+    /**
+     * Get high-quality cover image (uses session cache)
+     */
+    async getCoverImage(title, titleAlt) {
+        try {
+            const match = await this.findBestAnime(title, titleAlt);
+            if (!match)
+                return null;
+            const cover = match.coverImage.extraLarge || match.coverImage.large || match.coverImage.medium || null;
+            if (cover) {
+                console.log('[AniList] Found cover for', match.title.romaji, ':', cover.substring(0, 50));
+            }
+            return cover;
+        }
+        catch (error) {
+            console.error('AniList getCoverImage error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get banner/background image (1900x400) - uses session cache
+     */
+    async getBannerImage(title, titleAlt) {
+        try {
+            const match = await this.findBestAnime(title, titleAlt);
+            if (!match)
+                return null;
+            const banner = match.bannerImage || null;
+            if (banner) {
+                console.log('[AniList] Found banner for', match.title.romaji);
+            }
+            else {
+                console.log('[AniList] No banner available for:', match.title.romaji);
+            }
+            return banner;
+        }
+        catch (error) {
+            console.error('AniList getBannerImage error:', error);
+            return null;
+        }
+    }
+    /**
+     * Get ALL metadata in one call (cover + banner + synopsis + etc.)
+     * Uses session cache - no extra API calls if findBestAnime already ran.
+     */
+    async getEnhancedMetadata(title, titleAlt) {
+        try {
+            const match = await this.findBestAnime(title, titleAlt);
+            if (!match)
+                return null;
+            return {
+                anilistId: match.id,
+                malId: match.idMal,
+                cover: match.coverImage.extraLarge || match.coverImage.large,
+                banner: match.bannerImage,
+                synopsis: match.description,
+                score: match.averageScore,
+                episodes: match.episodes,
+                status: match.status,
+                studios: match.studios?.nodes.map(s => s.name),
+                genres: match.genres,
+            };
+        }
+        catch (error) {
+            console.error('AniList getEnhancedMetadata error:', error);
+            return null;
+        }
+    }
+    /**
+     * Clean title for better search results
+     */
+    cleanTitle(title) {
+        return title
+            // Remove Vietnamese suffixes
+            .replace(/\s*(vietsub|thuyết minh|lồng tiếng|fhd|hd|full|tập \d+)/gi, '')
+            // Remove season indicators
+            .replace(/\s*(phần|season|ss|mùa)\s*\d+/gi, '')
+            // Remove special characters
+            .replace(/[△▽★☆♪♫]/g, '')
+            // Remove bracketed content
+            .replace(/\s*\([^)]+\)\s*/g, ' ')
+            .replace(/\s*\[[^\]]+\]\s*/g, ' ')
+            // Clean whitespace
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    /**
+     * Find best matching anime from search results.
+     * Uses romaji/english/native/synonyms for matching.
+     * Returns null if no result meets the confidence threshold (score > 15).
+     */
+    findBestMatch(results, title, titleAlt) {
+        if (results.length === 0)
+            return null;
+        const normalizeStr = (s) => s.toLowerCase()
+            .replace(/[△▽★☆♪♫]/g, '')
+            .replace(/[^\w\s]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+        // We compare against all comma-split variants for better matching
+        const searchTitles = title
+            .split(',')
+            .map(s => normalizeStr(this.cleanTitle(s.trim())))
+            .filter(Boolean);
+        const searchAltTitles = titleAlt
+            ? titleAlt.split(',').map(s => normalizeStr(this.cleanTitle(s.trim()))).filter(Boolean)
+            : [];
+        const allSearchTerms = [...new Set([...searchAltTitles, ...searchTitles])];
+        // Threshold score - prevents unrelated matches (like Evangelion from "NGO")
+        let bestScore = 15;
+        let bestMatch = null;
+        for (const anime of results) {
+            let score = 0;
+            const aniTitle = anime.title.romaji ? normalizeStr(anime.title.romaji) : '';
+            const aniTitleEn = anime.title.english ? normalizeStr(anime.title.english) : '';
+            const aniTitleNative = anime.title.native ? normalizeStr(anime.title.native) : '';
+            const aniSynonyms = (anime.synonyms || []).map(s => normalizeStr(s));
+            const allAniNames = [aniTitle, aniTitleEn, aniTitleNative, ...aniSynonyms].filter(Boolean);
+            for (const query of allSearchTerms) {
+                if (!query)
+                    continue;
+                // Exact match: highest score
+                if (allAniNames.some(n => n === query)) {
+                    score += 100;
+                }
+                // Partial match: AniList title contains query or vice versa
+                if (aniTitle && (aniTitle.includes(query) || query.includes(aniTitle))) {
+                    score += 50;
+                }
+                if (aniTitleEn && (aniTitleEn.includes(query) || query.includes(aniTitleEn))) {
+                    score += 40;
+                }
+                // Synonym matching (curated by AniList team - highly reliable)
+                for (const syn of aniSynonyms) {
+                    if (syn === query) {
+                        score += 70; // Exact synonym match
+                    }
+                    else if (syn.includes(query) || query.includes(syn)) {
+                        score += 25; // Partial synonym match
+                    }
+                }
+                // Word-level overlap scoring
+                const queryWords = query.split(' ').filter(w => w.length > 2);
+                const aniWords = aniTitle.split(' ').filter(w => w.length > 2);
+                if (queryWords.length > 0 && aniWords.length > 0) {
+                    const overlap = queryWords.filter(w => aniWords.includes(w)).length;
+                    const overlapRatio = overlap / Math.max(queryWords.length, aniWords.length);
+                    score += Math.round(overlapRatio * 40);
+                }
+            }
+            // Popularity boost for disambiguation (but not dominant)
+            if (anime.averageScore)
+                score += anime.averageScore / 20;
+            if (score > bestScore) {
+                bestScore = score;
+                bestMatch = anime;
+            }
+        }
+        return bestMatch;
+    }
+}
+exports.AniListApiService = AniListApiService;
+// Singleton instance
+exports.anilistApi = new AniListApiService();