nekostream 2026.0.1

package/dist/scrapers/interceptor.js

@@ -0,0 +1,288 @@
+"use strict";
+// Video stream interceptor and parser
+// Captures HLS/DASH/MP4 streams from video players
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3U8 = parseM3U8;
+exports.fetchM3U8 = fetchM3U8;
+exports.extractVideoFromJS = extractVideoFromJS;
+exports.waitForVideoSource = waitForVideoSource;
+/**
+ * Parse M3U8 master playlist to extract quality options
+ */
+function parseM3U8(content, baseUrl) {
+    const lines = content.split('\n').map(l => l.trim()).filter(l => l);
+    const qualities = [];
+    let isMaster = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Check if master playlist
+        if (line.includes('#EXT-X-STREAM-INF')) {
+            isMaster = true;
+            // Parse attributes
+            const bandwidthMatch = line.match(/BANDWIDTH=(\d+)/);
+            const resolutionMatch = line.match(/RESOLUTION=(\d+x\d+)/);
+            const bandwidth = bandwidthMatch ? parseInt(bandwidthMatch[1]) : undefined;
+            const resolution = resolutionMatch ? resolutionMatch[1] : undefined;
+            // Get quality from resolution or bandwidth
+            let quality = 'unknown';
+            if (resolution) {
+                const height = parseInt(resolution.split('x')[1]);
+                quality = `${height}p`;
+            }
+            else if (bandwidth) {
+                if (bandwidth > 4000000)
+                    quality = '1080p';
+                else if (bandwidth > 2000000)
+                    quality = '720p';
+                else if (bandwidth > 1000000)
+                    quality = '480p';
+                else
+                    quality = '360p';
+            }
+            // Next line should be the URL
+            const urlLine = lines[i + 1];
+            if (urlLine && !urlLine.startsWith('#')) {
+                const url = urlLine.startsWith('http')
+                    ? urlLine
+                    : new URL(urlLine, baseUrl).href;
+                qualities.push({
+                    quality,
+                    bandwidth,
+                    resolution,
+                    url
+                });
+                i++; // Skip URL line
+            }
+        }
+    }
+    // Sort by quality (highest first)
+    qualities.sort((a, b) => {
+        const getHeight = (q) => parseInt(q.replace('p', '')) || 0;
+        return getHeight(b.quality) - getHeight(a.quality);
+    });
+    return {
+        type: isMaster ? 'master' : 'media',
+        qualities,
+        defaultUrl: qualities[0]?.url
+    };
+}
+/**
+ * Fetch and parse M3U8 playlist
+ */
+async function fetchM3U8(url, headers = {}) {
+    try {
+        const response = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+                ...headers
+            }
+        });
+        if (!response.ok)
+            return null;
+        const content = await response.text();
+        const baseUrl = url.substring(0, url.lastIndexOf('/') + 1);
+        return parseM3U8(content, baseUrl);
+    }
+    catch (error) {
+        console.error('Error fetching M3U8:', error);
+        return null;
+    }
+}
+/**
+ * Try to find video sources from page JavaScript
+ */
+async function extractVideoFromJS(page) {
+    const videos = [];
+    try {
+        // Try to get video sources from various player implementations
+        const sources = await page.evaluate(() => {
+            const urls = [];
+            // Check video elements
+            document.querySelectorAll('video').forEach(video => {
+                if (video.src)
+                    urls.push(video.src);
+                if (video.currentSrc)
+                    urls.push(video.currentSrc);
+                video.querySelectorAll('source').forEach(source => {
+                    if (source.src)
+                        urls.push(source.src);
+                });
+            });
+            // Check for ArtPlayer
+            if (window.art?.option?.url) {
+                urls.push(window.art.option.url);
+            }
+            // Check for Plyr
+            if (window.player?.source?.sources) {
+                window.player.source.sources.forEach((s) => {
+                    if (s.src)
+                        urls.push(s.src);
+                });
+            }
+            // Check for Video.js
+            if (window.videojs) {
+                try {
+                    const players = window.videojs.getPlayers();
+                    Object.values(players).forEach((p) => {
+                        if (p?.currentSrc)
+                            urls.push(p.currentSrc());
+                        if (p?.src)
+                            urls.push(typeof p.src === 'function' ? p.src() : p.src);
+                    });
+                }
+                catch (e) { }
+            }
+            // Check for JWPlayer - multiple detection methods
+            if (window.jwplayer) {
+                try {
+                    // Try default instance
+                    const jw = window.jwplayer();
+                    if (jw?.getPlaylistItem) {
+                        const item = jw.getPlaylistItem();
+                        if (item?.file)
+                            urls.push(item.file);
+                        if (item?.sources) {
+                            item.sources.forEach((s) => {
+                                if (s.file)
+                                    urls.push(s.file);
+                            });
+                        }
+                    }
+                    if (jw?.getConfig) {
+                        const config = jw.getConfig();
+                        if (config?.file)
+                            urls.push(config.file);
+                        if (config?.playlist) {
+                            config.playlist.forEach((p) => {
+                                if (p.file)
+                                    urls.push(p.file);
+                                if (p.sources)
+                                    p.sources.forEach((s) => s.file && urls.push(s.file));
+                            });
+                        }
+                    }
+                }
+                catch (e) { }
+                // Try all JWPlayer instances
+                try {
+                    const allJw = window.jwplayer?.instances || [];
+                    allJw.forEach((inst) => {
+                        try {
+                            const item = inst?.getPlaylistItem?.();
+                            if (item?.file)
+                                urls.push(item.file);
+                            if (item?.sources)
+                                item.sources.forEach((s) => s.file && urls.push(s.file));
+                        }
+                        catch (e) { }
+                    });
+                }
+                catch (e) { }
+            }
+            // Check global variables commonly used by anime sites
+            const globals = ['source', 'video_url', 'videoUrl', 'fileUrl', 'file', 'streamUrl', 'hlsUrl', 'mp4Url', 'playUrl'];
+            globals.forEach(g => {
+                const val = window[g];
+                if (typeof val === 'string' && val.includes('http'))
+                    urls.push(val);
+            });
+            // Search in page scripts for video URLs
+            const scripts = document.querySelectorAll('script');
+            scripts.forEach(script => {
+                const content = script.textContent || '';
+                // Find m3u8 URLs
+                const m3u8Matches = content.match(/https?:\/\/[^\s"'<>]+\.m3u8[^\s"'<>]*/g);
+                if (m3u8Matches)
+                    urls.push(...m3u8Matches);
+                // Find mp4 URLs - more aggressive pattern
+                const mp4Matches = content.match(/https?:\/\/[^\s"'<>]+\.mp4[^\s"'<>]*/g);
+                if (mp4Matches)
+                    urls.push(...mp4Matches);
+                // Find file: "url" patterns (common in player configs)
+                const fileMatches = content.match(/["']file["']\s*:\s*["']([^"']+)["']/gi);
+                fileMatches?.forEach(m => {
+                    const urlMatch = m.match(/["']([^"']+)["']$/i);
+                    if (urlMatch?.[1]?.startsWith('http'))
+                        urls.push(urlMatch[1]);
+                });
+                // Find sources array patterns
+                const sourcesMatch = content.match(/["']?sources["']?\s*:\s*\[([^\]]+)\]/gi);
+                sourcesMatch?.forEach(m => {
+                    const urlMatches = m.match(/https?:\/\/[^\s"'<>\]]+/g);
+                    if (urlMatches)
+                        urls.push(...urlMatches);
+                });
+            });
+            // Check iframes for potential embed URLs (for logging/fallback)
+            document.querySelectorAll('iframe[src]').forEach(iframe => {
+                const src = iframe.getAttribute('src');
+                if (src && (src.includes('player') || src.includes('embed') || src.includes('video'))) {
+                    // Don't add iframe URLs as direct streams, but log them
+                    console.log('[extractVideoFromJS] Found player iframe:', src);
+                }
+            });
+            return urls;
+        });
+        // Deduplicate and filter
+        const unique = [...new Set(sources)].filter(url => {
+            if (!url.startsWith('http'))
+                return false;
+            // Must contain video extension or streaming patterns
+            return (url.includes('.m3u8') ||
+                url.includes('.mp4') ||
+                url.includes('.mpd') ||
+                url.includes('.webm') ||
+                url.includes('/hls/') ||
+                url.includes('/video/'));
+        });
+        console.log('[extractVideoFromJS] Found', unique.length, 'video URLs');
+        videos.push(...unique);
+    }
+    catch (error) {
+        console.error('Error extracting video from JS:', error);
+    }
+    return videos;
+}
+/**
+ * Wait for video element to have a source
+ */
+async function waitForVideoSource(page, timeout = 10000) {
+    try {
+        const source = await page.evaluate(() => {
+            return new Promise((resolve) => {
+                const checkVideo = () => {
+                    const video = document.querySelector('video');
+                    if (video?.src && video.src !== '') {
+                        resolve(video.src);
+                        return true;
+                    }
+                    return false;
+                };
+                // Check immediately
+                if (checkVideo())
+                    return;
+                // Watch for changes
+                const observer = new MutationObserver(() => {
+                    if (checkVideo()) {
+                        observer.disconnect();
+                    }
+                });
+                observer.observe(document.body, {
+                    childList: true,
+                    subtree: true,
+                    attributes: true,
+                    attributeFilter: ['src']
+                });
+                // Timeout
+                setTimeout(() => {
+                    observer.disconnect();
+                    resolve(null);
+                }, 10000);
+            });
+        });
+        return source;
+    }
+    catch (error) {
+        return null;
+    }
+}

package/dist/scrapers/jikan-api.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jikanApi = void 0;
+const undici_1 = require("undici");
+class JikanApiService {
+    CACHE_DURATION_MS = 1000 * 60 * 60 * 24; // 24 hours caching
+    cache = new Map();
+    // Rate limiting properties (Jikan applies strict limits, spacing out by 1000ms is perfectly safe)
+    lastRequestTime = 0;
+    RATE_LIMIT_DELAY_MS = 1100;
+    async getAnimeCover(title, titleAlt) {
+        const rawTitle = titleAlt ? titleAlt.split(',')[0].trim() : title.trim();
+        if (!rawTitle)
+            return null;
+        const cacheKey = rawTitle.toLowerCase();
+        // Check in-memory session cache first
+        const cached = this.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION_MS) {
+            return cached.data.cover;
+        }
+        // Apply strict rate limiting before fetch
+        const now = Date.now();
+        const timeSinceLastRequest = now - this.lastRequestTime;
+        if (timeSinceLastRequest < this.RATE_LIMIT_DELAY_MS) {
+            await new Promise(resolve => setTimeout(resolve, this.RATE_LIMIT_DELAY_MS - timeSinceLastRequest));
+        }
+        try {
+            this.lastRequestTime = Date.now();
+            const searchUrl = `https://api.jikan.moe/v4/anime?q=${encodeURIComponent(rawTitle)}&limit=1`;
+            const { statusCode, body } = await (0, undici_1.request)(searchUrl, {
+                headers: {
+                    'User-Agent': 'NekoStream-Desktop-App/1.0'
+                }
+            });
+            if (statusCode !== 200) {
+                console.warn(`[JikanAPI] API returned status ${statusCode} for "${rawTitle}"`);
+                return null;
+            }
+            const rawBody = await body.text();
+            const json = JSON.parse(rawBody);
+            if (json.data && json.data.length > 0) {
+                // Prefer large webp, fallback to large jpg
+                const cover = json.data[0].images?.webp?.large_image_url || json.data[0].images?.jpg?.large_image_url || null;
+                const result = { cover };
+                this.cache.set(cacheKey, { data: result, timestamp: Date.now() });
+                console.log(`[JikanAPI] Cached cover for "${rawTitle}": ${cover}`);
+                return cover;
+            }
+            console.warn(`[JikanAPI] No anime found matching "${rawTitle}"`);
+            // Cache empty result to avoid hitting limit for unknowns
+            this.cache.set(cacheKey, { data: { cover: null }, timestamp: Date.now() });
+            return null;
+        }
+        catch (error) {
+            console.error('[JikanAPI] Error fetching anime cover:', error);
+            return null;
+        }
+    }
+}
+exports.jikanApi = new JikanApiService();