npm - ani-auto - Versions diffs - 1.4.3 → 2.0.0 - Mend

ani-auto 1.4.3 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (90) hide show

package/anime/LICENSE +21 -0
package/anime/api/index.js +110 -0
package/anime/app.js +79 -0
package/anime/controllers/animeInfoController.js +48 -0
package/anime/controllers/animeListController.js +21 -0
package/anime/controllers/homeController.js +42 -0
package/anime/controllers/playController.js +140 -0
package/anime/controllers/queueController.js +20 -0
package/anime/controllers/testController.js +667 -0
package/anime/index.js +139 -0
package/anime/middleware/cache.js +64 -0
package/anime/middleware/errorHandler.js +33 -0
package/anime/middleware/rateLimiter.js +73 -0
package/anime/models/animeInfoModel.js +193 -0
package/anime/models/animeListModel.js +69 -0
package/anime/models/homeModel.js +33 -0
package/anime/models/playModel.js +528 -0
package/anime/models/queueModel.js +22 -0
package/anime/package.json +27 -0
package/anime/pnpm-lock.yaml +1774 -0
package/anime/readme.md +236 -0
package/anime/routes/animeInfoRoutes.js +9 -0
package/anime/routes/animeListRoutes.js +9 -0
package/anime/routes/homeRoutes.js +10 -0
package/anime/routes/playRoutes.js +11 -0
package/anime/routes/queueRoutes.js +8 -0
package/anime/routes/testRoutes.js +325 -0
package/anime/routes/webhookRoutes.js +23 -0
package/anime/scrapers/animepahe.js +1053 -0
package/anime/test-server.js +10 -0
package/anime/test.sh +275 -0
package/anime/utils/browser.js +172 -0
package/anime/utils/config.js +209 -0
package/anime/utils/dataProcessor.js +172 -0
package/anime/utils/diskCache.js +228 -0
package/anime/utils/flaresolverr.js +361 -0
package/anime/utils/jsParser.js +19 -0
package/anime/utils/redis.js +64 -0
package/anime/utils/requestManager.js +706 -0
package/anime/utils/urlConverter.js +88 -0
package/anime/utils/webhookNotifier.js +190 -0
package/cookiereader.py +291 -0
package/package.json +14 -6
package/src/anilist.js +19 -2
package/src/api/anilist.js +32 -0
package/src/api/anime.js +181 -0
package/src/api/cf-bypass.js +131 -0
package/src/api/config.js +134 -0
package/src/api/daemon.js +62 -0
package/src/api/download.js +98 -0
package/src/api/match.js +58 -0
package/src/api/runs.js +15 -0
package/src/api/update.js +96 -0
package/src/cli.js +18 -2
package/src/config.js +14 -2
package/src/daemon.js +1 -1
package/src/db.js +38 -11
package/src/engine.js +66 -13
package/src/notify.js +82 -7
package/src/scraper.js +2 -2
package/src/server.js +108 -0
package/utils.js +21 -21
package/web/index.html +13 -0
package/web/package-lock.json +1420 -0
package/web/package.json +24 -0
package/web/src/App.vue +200 -0
package/web/src/api/client.js +75 -0
package/web/src/assets/styles/base.css +961 -0
package/web/src/components/UpdateModal.vue +157 -0
package/web/src/components/sidebar/SidebarResizable.vue +170 -0
package/web/src/components/sidebar/sidebarConfig.js +24 -0
package/web/src/main.js +104 -0
package/web/src/router/index.js +44 -0
package/web/src/stores/config.js +27 -0
package/web/src/stores/download.js +107 -0
package/web/src/stores/update.js +73 -0
package/web/src/views/About.vue +42 -0
package/web/src/views/AniListSync.vue +122 -0
package/web/src/views/AnimeDetail.vue +202 -0
package/web/src/views/AnimeList.vue +110 -0
package/web/src/views/CFResult.vue +312 -0
package/web/src/views/DaemonControl.vue +83 -0
package/web/src/views/Dashboard.vue +187 -0
package/web/src/views/DownloadCenter.vue +153 -0
package/web/src/views/MatchFinder.vue +131 -0
package/web/src/views/OAuthCallback.vue +44 -0
package/web/src/views/Onboarding.vue +93 -0
package/web/src/views/RunHistory.vue +122 -0
package/web/src/views/Settings.vue +410 -0
package/web/vite.config.js +23 -0

package/anime/models/playModel.js ADDED Viewed

@@ -0,0 +1,528 @@
+const cheerio = require('cheerio');
+const vm = require('vm');
+const { JSDOM } = require('jsdom');
+const Config = require('../utils/config');
+const DataProcessor = require('../utils/dataProcessor');
+const Animepahe = require('../scrapers/animepahe');
+const { getJsVariable } = require('../utils/jsParser');
+const { CustomError } = require('../middleware/errorHandler');
+const UrlConverter = require('../utils/urlConverter');
+class PlayModel {
+    static async getStreamingLinks(id, episodeId, includeDownloads = true) {
+        const results = await Animepahe.getData('play', { id, episodeId }, false);
+        if (!results) throw new CustomError('Failed to fetch streaming data', 503);
+        if (typeof results === 'object' && !results.data) results.data = [];
+        if (results.data) return DataProcessor.processApiData(results);
+        return this.scrapePlayPage(id, episodeId, results, includeDownloads);
+    }
+    static async scrapeIframe(id, episodeId, url) {
+        const html = await Animepahe.fetchIframeHtml(id, episodeId, url);
+        if (!html) throw new CustomError('Failed to fetch iframe data', 503);
+        return this.extractSources(html, url);
+    }
+    static async extractSources(html, url = '') {
+        const scriptMatches = [...html.matchAll(/<script[^>]*>([\s\S]*?)<\/script>/gi)].map(m => m[1]);
+        if (!scriptMatches.length) {
+            console.log('No inline <script> blocks found.');
+            return null;
+        }
+        console.log(`Found ${scriptMatches.length} script tags.`);
+        const findM3u8 = (s) => {
+            if (!s) return null;
+            const m = s.match(/https?:\/\/[^"'<> \n\r]+\.m3u8[^\s"'<>]*/i);
+            return m ? m[0] : null;
+        };
+        for (const script of scriptMatches) {
+            // Optimization: fast regex check before heavy VM execution
+            const fromScript = findM3u8(script);
+            if (fromScript) {
+                return [{ url: fromScript, isM3U8: fromScript.includes('.m3u8') || false }];
+            }
+            if (!script.includes('eval(')) continue;
+            const dom = new JSDOM(`<!DOCTYPE html><video id="player"></video>`);
+            const document = dom.window.document;
+            const videoEl = document.querySelector('video');
+            const captured = new Set();
+            const Plyr = function (el, opts) {
+                try {
+                if (opts && opts.sources && Array.isArray(opts.sources)) {
+                    for (const s of opts.sources) {
+                    if (s && typeof s.src === 'string' && s.src.includes('.m3u8')) captured.add(s.src);
+                    }
+                }
+                } catch (e) { /* ignore */ }
+                return { on: () => {}, };
+            };
+            const Hls = function (cfg) {
+                return {
+                loadSource: (src) => {
+                    try { if (typeof src === 'string' && src.includes('.m3u8')) captured.add(src); } catch (e) {}
+                },
+                attachMedia: (m) => {
+                    try {
+                    if (m && m.src && typeof m.src === 'string' && m.src.includes('.m3u8')) captured.add(m.src);
+                    } catch (e) {}
+                },
+                on: () => {},
+                };
+            };
+            Hls.isSupported = () => true;
+            const sandbox = {
+                console,
+                window: dom.window,
+                document: dom.window.document,
+                navigator: { userAgent: Config.userAgent },
+                location: { href: url },
+                Plyr,
+                Hls,
+                setTimeout,
+                clearTimeout,
+            };
+            vm.createContext(sandbox);
+            try {
+                vm.runInContext(script, sandbox, { timeout: 2000 });
+            } catch (err) {
+                // ignore eval errors
+            }
+            const innerEvalBodies = [];
+            const packedMatch = script.match(/eval\((function[\s\S]*?)\)\s*;?/i);
+            if (packedMatch && packedMatch[1]) innerEvalBodies.push(packedMatch[1]);
+            const genericMatches = [...script.matchAll(/eval\(([\s\S]*?)\)\s*;?/gi)];
+            for (const gm of genericMatches) {
+                if (gm[1] && !innerEvalBodies.includes(gm[1])) innerEvalBodies.push(gm[1]);
+            }
+            for (const body of innerEvalBodies) {
+                try {
+                vm.runInContext(body, sandbox, { timeout: 1500 });
+                } catch (err) {}
+            }
+            if (captured.size) {
+                const arr = Array.from(captured);
+                return [{ url: arr[0] || null, isM3U8: arr[0].includes('.m3u8') || false }];
+            }
+            try {
+                const vsrc = videoEl && videoEl.src;
+                const found = findM3u8(vsrc);
+                if (found) {
+                return [{ url: found, isM3U8: found.includes('.m3u8') || false }];
+                }
+            } catch (e) {}
+            try {
+                const pkg = JSON.stringify(sandbox);
+                const found = findM3u8(pkg);
+                if (found) {
+                return [{ url: found, isM3U8: found.includes('.m3u8') || false }];
+                }
+            } catch (e) {}
+        }
+        // fallback: try data-src attribute in html (in case)
+        const fallback = html.match(/data-src="([^"]+\.m3u8[^"]*)"/i);
+        if (fallback) {
+            console.log('FOUND data-src m3u8 (fallback):', fallback[1]);
+            return [{ url: fallback[1], isM3U8: fallback[1].includes('.m3u8') || false }];
+        }
+        console.log('Could not resolve m3u8 from any Kwik script.');
+        return null;
+    }
+    static async getDownloadLinkList($, resolveLinks = true) {
+        const elements = $('#pickDownload a').get();
+        const BATCH_SIZE = 4;
+        const BATCH_DELAY = 800;
+        const processElement = async (element) => {
+            const $element = $(element);
+            const link = $element.attr('href');
+            if (!link) return null;
+            const fullText = $element.text().trim();
+            const normalized = fullText
+                .replace(/\u00A0/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            const parts = normalized.split('·').map(p => p.trim()).filter(Boolean);
+            let fansub = null;
+            let filesize = null;
+            let isDub = false;
+            let resolution = null;
+            const quality = fullText;
+            let isBD = false;
+            const parseSizeAndEng = (text) => {
+                // Extract resolution
+                const resMatch = text.match(/(\d+)p/i);
+                if (resMatch) resolution = resMatch[1];
+                // Extract size
+                const sizeMatch = text.match(/\((\d+(?:\.\d+)?(?:MB|GB))\)/i);
+                if (sizeMatch) filesize = sizeMatch[1];
+                else filesize = "Unknown"; // if not found
+                // Extract dubbed status
+                if (/\beng\b/i.test(text)) {
+                    isDub = true;
+                }
+                // Extract BD status
+                if (/\bBD\b/.test(text)) {
+                    isBD = true;
+                }
+            };
+            if (parts.length === 1) {
+                parseSizeAndEng(parts[0]);
+            } else if (parts.length >= 2) {
+                fansub = parts[0];
+                parseSizeAndEng(parts.slice(1).join(' · '));
+            }
+            const item = {
+                fansub,
+                quality,
+                resolution,
+                filesize,
+                isDub,
+                isBD,
+                pahe: link,
+                download: null
+            };
+            if (!resolveLinks) {
+                return item;
+            }
+            try {
+                const directDownloadLink = await this.getDownloadLinks(link);
+                item.download = directDownloadLink.downloadUrl;
+                return item;
+            } catch (error) {
+                console.error(`Failed to get direct download for ${link}: ${error.message}`);
+                return item;
+            }
+        };
+        // If not resolving links, we don't need batching or delays
+        if (!resolveLinks) {
+             const results = await Promise.all(elements.map(processElement));
+             return results.filter(r => r);
+        }
+        const results = [];
+        for (let i = 0; i < elements.length; i += BATCH_SIZE) {
+            const batch = elements.slice(i, i + BATCH_SIZE);
+            const batchResults = await Promise.allSettled(batch.map(processElement));
+            results.push(...batchResults
+                .filter(r => r.status === 'fulfilled' && r.value)
+                .map(r => r.value)
+            );
+            if (i + BATCH_SIZE < elements.length) {
+                await new Promise(resolve => setTimeout(resolve, BATCH_DELAY));
+            }
+        }
+        return results;
+    }
+    static async getResolutionList($) {
+        const resolutions = [];
+        $('#resolutionMenu button').each((index, element) => {
+            const link = $(element).attr('data-src');
+            const resolution = $(element).attr('data-resolution');
+            const audio = $(element).attr('data-audio');
+            if (link) {
+                resolutions.push({
+                    url: link || null,
+                    resolution: resolution || null,
+                    isDub: (audio && audio.toLowerCase() === 'eng') || false,
+                    fanSub: $(element).attr('data-fansub') || null,
+                });
+            }
+        });
+        return resolutions;
+    }
+    static async getDownloadLinks(url) {
+        const results = await Animepahe.getData('download', { url }, false);
+        return results;
+    }
+    static async scrapePlayPage(id, episodeId, pageHtml, includeDownloads = true) {
+        const [session, provider] = ['session', 'provider'].map(v => getJsVariable(pageHtml, v) || null);
+        if (!session || !provider) throw new CustomError('Episode not found', 404);
+        const $ = cheerio.load(pageHtml);
+        const playInfo = {
+            ids: {
+                animepahe_id: parseInt($('meta[name="id"]').attr('content'), 10) || null,
+                mal_id: parseInt($('meta[name="anidb"]').attr('content'), 10) || null,
+                anilist_id: parseInt($('meta[name="anilist"]').attr('content'), 10) || null,
+                anime_planet_id: parseInt($('meta[name="anime-planet"]').attr('content'), 10) || null,
+                ann_id: parseInt($('meta[name="ann"]').attr('content'), 10) || null,
+                anilist: $('meta[name="anilist"]').attr('content') || null,
+                anime_planet: $('meta[name="anime-planet"]').attr('content') || null,
+                ann: $('meta[name="ann"]').attr('content') || null,
+                kitsu: $('meta[name="kitsu"]').attr('content') || null,
+                myanimelist: $('meta[name="myanimelist"]').attr('content') || null,
+            },
+            session,
+            provider,
+            episode: $('.episode-menu #episodeMenu').text().trim().replace(/\D/g, ''),
+            anime_title: $('div.title-wrapper > h1 > span').text().trim().replace(/^Watch\s+/i, '').replace(/\s+-\s+\d+\s+Online$/i, '') || $('h1').text().trim().replace(/^Watch\s+/i, '').replace(/\s+-\s+\d+\s+Online$/i, '').replace(/ Episode \d+$/, ''),
+        };
+        try {
+            const resolutions = await this.getResolutionList($);
+            const metadataList = await this.getDownloadLinkList($, false);
+            const resolutionData = resolutions.map(res => {
+                const match = metadataList.find(m =>
+                    m.resolution === res.resolution &&
+                    (m.fansub === res.fanSub || (!m.fansub && !res.fanSub)) &&
+                    m.isDub === res.isDub
+                );
+                return {
+                    url: res.url,
+                    embed: res.url,
+                    resolution: res.resolution,
+                    isDub: res.isDub,
+                    fanSub: res.fanSub,
+                    isBD: match ? match.isBD : false
+                };
+            });
+            let allSources = await this.processHybridOptimized(id, episodeId, resolutionData);
+            const resolvedSourceCount = allSources.flat().filter(source => source && source.url).length;
+            if (resolutionData.length > 0 && resolvedSourceCount === 0) {
+                console.warn('[PlayModel] Parallel iframe extraction resolved 0 sources, retrying sequentially...');
+                allSources = await this.processSequentialFallback(id, episodeId, resolutionData);
+            }
+            // fast download links map
+            const fastDownloadMap = new Map();
+            const processedSources = allSources.flat().map(source => {
+                if (includeDownloads && source.url && source.isM3U8) {
+                    const downloadResult = UrlConverter.buildDownloadUrl(
+                        source.url,
+                        Config.iframeBaseUrl,
+                        {
+                            animeTitle: playInfo.anime_title,
+                            episode: playInfo.episode,
+                            resolution: source.resolution,
+                            fansub: source.fanSub,
+                            isDub: source.isDub,
+                            isBD: source.isBD
+                        }
+                    );
+                    if (downloadResult) {
+                        source.download = downloadResult.url;
+                        source.downloadHeaders = downloadResult.headers;
+                        const key = `${source.resolution}-${source.fanSub || 'default'}-${source.isDub}-${source.isBD}`;
+                        fastDownloadMap.set(key, downloadResult);
+                    }
+                }
+                return source;
+            });
+            playInfo.sources = processedSources;
+            if (includeDownloads) {
+                const hydratedDownloads = metadataList.map(item => {
+                    const key = `${item.resolution}-${item.fansub || 'default'}-${item.isDub}-${item.isBD}`;
+                    const downloadResult = fastDownloadMap.get(key);
+                    if (downloadResult) {
+                        item.download = downloadResult.url;
+                        item.downloadHeaders = downloadResult.headers;
+                    }
+                    return item;
+                });
+                playInfo.downloads = hydratedDownloads;
+                console.log(`Matched ${hydratedDownloads.filter(d => d.download).length}/${metadataList.length} download links locally.`);
+            } else {
+                playInfo.downloads = [];
+            }
+            // Remove internal properties not needed in the response
+            playInfo.sources.forEach(s => delete s.isBD);
+            if (playInfo.downloads) {
+                playInfo.downloads.forEach(d => delete d.isBD);
+            }
+            const cdnCookies = Animepahe.getCdnCookies();
+            if (cdnCookies) {
+                playInfo.cdnCookies = cdnCookies;
+            }
+        } catch (error) {
+            console.error('Error in scrapePlayPage:', error);
+            playInfo.sources = playInfo.sources || [];
+            playInfo.downloads = playInfo.downloads || [];
+        }
+        return playInfo;
+    }
+    /*
+     * Optimized parallel approach:
+     * Process multiple iframe sources in parallel batches. Increased to 3 for better speed.
+     */
+    static async processHybridOptimized(id, episodeId, items) {
+        const results = [];
+        const seenUrls = new Set();
+        const IFRAME_TIMEOUT = 20000; // 20 seconds per iframe
+        const uniqueItems = items.filter(item => {
+            if (seenUrls.has(item.url)) {
+                console.log('Skipping duplicate URL:', item.url);
+                return false;
+            }
+            seenUrls.add(item.url);
+            return true;
+        });
+        console.log(`Starting parallel processing of ${uniqueItems.length} iframe sources...`);
+        if (uniqueItems.length === 0) {
+            return results;
+        }
+        // Increased from 2 to 3 for better parallelization
+        const maxParallel = 3;
+        for (let i = 0; i < uniqueItems.length; i += maxParallel) {
+            const batch = uniqueItems.slice(i, i + maxParallel);
+            console.log(`Processing batch ${Math.floor(i / maxParallel) + 1}/${Math.ceil(uniqueItems.length / maxParallel)} with ${batch.length} items...`);
+            const batchPromises = batch.map(async (data) => {
+                // Wrap each iframe scrape with a timeout
+                const scrapePromise = Animepahe.scrapeIframe(id, episodeId, data.url);
+                const timeoutPromise = new Promise((_, reject) => {
+                    setTimeout(() => reject(new Error(`Iframe fetch timed out after ${IFRAME_TIMEOUT / 1000}s`)), IFRAME_TIMEOUT);
+                });
+                try {
+                    const sources = await Promise.race([scrapePromise, timeoutPromise]);
+                    if (!Array.isArray(sources) || sources.length === 0) {
+                        throw new Error('No iframe sources resolved');
+                    }
+                    return sources.map(source => ({
+                        ...source,
+                        embed: data.embed,
+                        resolution: data.resolution,
+                        isDub: data.isDub,
+                        fanSub: data.fanSub,
+                        isBD: data.isBD || false,
+                    }));
+                } catch (err) {
+                    console.error(`Failed to process ${data.resolution}:`, err.message);
+                    // Return partial data on timeout — at least give the embed URL
+                    if (err.message && err.message.includes('timed out')) {
+                        console.log(`[Timeout Fallback] Returning embed URL for ${data.resolution}`);
+                        return [{
+                            url: null,
+                            embed: data.embed,
+                            resolution: data.resolution,
+                            isDub: data.isDub,
+                            fanSub: data.fanSub,
+                            isBD: data.isBD || false,
+                            timeout: true,
+                        }];
+                    }
+                    return [];
+                }
+            });
+            const batchResults = await Promise.all(batchPromises);
+            results.push(...batchResults);
+            // Reduced delay from 500ms to 300ms
+            if (i + maxParallel < uniqueItems.length) {
+                await new Promise(resolve => setTimeout(resolve, 300));
+            }
+        }
+        const successCount = results.filter(r => r && r.length > 0).length;
+        console.log(`Parallel processing complete: ${successCount}/${uniqueItems.length} iframe sources processed successfully`);
+        return results;
+    }
+    // Sequential fallback processing when needed.
+    static async processSequentialFallback(id, episodeId, items, delayMs = 1500) {
+        console.log('Switching to sequential fallback processing for remaining iframe sources...');
+        const results = [];
+        for (let i = 0; i < items.length; i++) {
+            const data = items[i];
+            try {
+                const sources = await Animepahe.scrapeIframe(id, episodeId, data.url);
+                if (!Array.isArray(sources) || sources.length === 0) {
+                    throw new Error('No iframe sources resolved');
+                }
+                const sourcesWithMeta = sources.map(source => ({
+                    ...source,
+                    embed: data.embed,
+                    resolution: data.resolution,
+                    isDub: data.isDub,
+                    fanSub: data.fanSub,
+                }));
+                results.push(sourcesWithMeta);
+                if (i < items.length - 1) {
+                    await new Promise(resolve => setTimeout(resolve, delayMs));
+                }
+            } catch (err) {
+                console.error(`Failed ${data.resolution}:`, err.message);
+            }
+        }
+        return results;
+    }
+    // Backwards-compatibility wrappers
+    static async processSequential(id, episodeId, items, delayMs = 2000) {
+        return this.processHybridOptimized(id, episodeId, items);
+    }
+    static async processBatch(id, episodeId, items, batchSize = 3, delayMs = 500) {
+        return this.processHybridOptimized(id, episodeId, items);
+    }
+}
+module.exports = PlayModel;

package/anime/models/queueModel.js ADDED Viewed

@@ -0,0 +1,22 @@
+const DataProcessor = require('../utils/dataProcessor');
+const Config = require('../utils/config');
+const Animepahe = require('../scrapers/animepahe');
+const { CustomError } = require('../middleware/errorHandler');
+class QueueModel {
+    static async getQueue() {
+        const results = await Animepahe.getData("queue");
+        if (!results) {
+            throw new CustomError('Failed to fetch queue data', 503);
+        }
+        if (typeof results === 'object' && !results.data) {
+            results.data = [];
+        }
+        return DataProcessor.processApiData(results, "queue", false);
+    }
+}
+module.exports = QueueModel;

package/anime/package.json ADDED Viewed

@@ -0,0 +1,27 @@
+{
+  "name": "pahe-api",
+  "main": "index.js",
+  "scripts": {
+    "dev": "nodemon app.js",
+    "start": "node app.js",
+    "test": "nodemon test.js"
+  },
+  "keywords": [],
+  "author": "aor-rex",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "cheerio": "1.0.0-rc.12",
+    "cloudscraper": "^4.6.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.5.0",
+    "express": "^4.21.2",
+    "jsdom": "^22.1.0",
+    "p-limit": "^5.0.0",
+    "redis": "^5.5.6"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.9"
+  }
+}