ani-web 1.5.8

package/server/dist/controllers/proxy.controller.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyController = exports.axiosInstance = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+const path_1 = __importDefault(require("path"));
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const config_1 = require("../config");
+const fs_1 = __importDefault(require("fs"));
+const proxyCache = new node_cache_1.default({ stdTTL: 30, checkperiod: 60 });
+const httpAgent = new http_1.default.Agent({ keepAlive: true, maxSockets: 100 });
+const httpsAgent = new https_1.default.Agent({ keepAlive: true, maxSockets: 100 });
+httpAgent.setMaxListeners(100);
+httpsAgent.setMaxListeners(100);
+exports.axiosInstance = axios_1.default.create({
+    httpAgent,
+    httpsAgent,
+    timeout: 30000,
+});
+(0, axios_retry_1.default)(exports.axiosInstance, { retries: 3, retryDelay: axios_retry_1.default.exponentialDelay });
+class ProxyController {
+    handleProxy = async (req, res) => {
+        const { url, referer } = req.query;
+        if (!url)
+            return res.status(400).send('URL required');
+        const urlStr = url;
+        const refererStr = referer || '';
+        const cacheKey = `m3u8-${urlStr}-${refererStr}`;
+        const abortController = new AbortController();
+        req.on('close', () => {
+            abortController.abort();
+        });
+        try {
+            const headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            };
+            if (referer)
+                headers['Referer'] = refererStr;
+            if (req.headers.range)
+                headers['Range'] = req.headers.range;
+            if (urlStr.includes('.m3u8')) {
+                const cached = proxyCache.get(cacheKey);
+                if (cached) {
+                    return res
+                        .set('Content-Type', 'application/vnd.apple.mpegurl')
+                        .set('Access-Control-Allow-Origin', '*')
+                        .send(cached);
+                }
+                const resp = await exports.axiosInstance.get(urlStr, {
+                    headers,
+                    responseType: 'text',
+                    signal: abortController.signal,
+                });
+                const baseUrl = new URL(urlStr);
+                const rewritten = resp.data
+                    .split('\n')
+                    .map((l) => {
+                    const line = l.trim();
+                    if (!line)
+                        return l;
+                    if (line.startsWith('#')) {
+                        return line.replace(/URI="([^"]+)"/g, (match, uri) => {
+                            const fullUri = new URL(uri, baseUrl).href;
+                            if (fullUri.includes('.m3u8')) {
+                                return `URI="/api/proxy?url=${encodeURIComponent(fullUri)}&referer=${encodeURIComponent(refererStr)}"`;
+                            }
+                            return `URI="${fullUri}"`;
+                        });
+                    }
+                    const fullUrl = new URL(line, baseUrl).href;
+                    if (fullUrl.includes('.m3u8')) {
+                        return `/api/proxy?url=${encodeURIComponent(fullUrl)}&referer=${encodeURIComponent(refererStr)}`;
+                    }
+                    return fullUrl;
+                })
+                    .join('\n');
+                proxyCache.set(cacheKey, rewritten);
+                res
+                    .set('Content-Type', 'application/vnd.apple.mpegurl')
+                    .set('Access-Control-Allow-Origin', '*')
+                    .send(rewritten);
+            }
+            else {
+                const resp = await (0, exports.axiosInstance)({
+                    method: 'get',
+                    url: urlStr,
+                    responseType: 'stream',
+                    headers,
+                    signal: abortController.signal,
+                });
+                res.status(resp.status);
+                const forwardHeaders = [
+                    'content-type',
+                    'content-length',
+                    'content-range',
+                    'accept-ranges',
+                    'cache-control',
+                    'last-modified',
+                    'etag',
+                ];
+                Object.keys(resp.headers).forEach((k) => {
+                    if (forwardHeaders.includes(k.toLowerCase())) {
+                        res.set(k, resp.headers[k]);
+                    }
+                });
+                res.set('Access-Control-Allow-Origin', '*');
+                resp.data.on('error', () => {
+                    abortController.abort();
+                    if (!res.headersSent)
+                        res.status(502).send('Upstream error');
+                    else
+                        res.destroy();
+                });
+                res.on('close', () => {
+                    if (!resp.data.destroyed) {
+                        resp.data.destroy();
+                    }
+                });
+                resp.data.pipe(res);
+            }
+        }
+        catch (e) {
+            if (axios_1.default.isCancel(e)) {
+                return;
+            }
+            if (!res.headersSent)
+                res.status(500).send('Proxy error');
+        }
+    };
+    handleSubtitleProxy = async (req, res) => {
+        const { url, referer } = req.query;
+        if (!url)
+            return res.status(400).send('URL required');
+        const abortController = new AbortController();
+        req.on('close', () => {
+            abortController.abort();
+        });
+        try {
+            const headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            };
+            if (referer)
+                headers['Referer'] = referer;
+            const response = await exports.axiosInstance.get(url, {
+                headers,
+                responseType: 'text',
+                signal: abortController.signal,
+            });
+            res.set('Content-Type', 'text/vtt; charset=utf-8').send(response.data);
+        }
+        catch (e) {
+            if (axios_1.default.isCancel(e))
+                return;
+            res.status(500).send('Proxy error');
+        }
+    };
+    handleImageProxy = async (req, res) => {
+        const { url } = req.query;
+        if (!url)
+            return res.status(400).send('URL required');
+        const abortController = new AbortController();
+        req.on('close', () => {
+            abortController.abort();
+        });
+        try {
+            const targetUrl = url;
+            let refererValue = 'https://allanime.day';
+            if (targetUrl.includes('anilist.co')) {
+                refererValue = 'https://anilist.co/';
+            }
+            else if (targetUrl.includes('gogocdn.net')) {
+                refererValue = 'https://gogoanime.lu/';
+            }
+            else if (targetUrl.includes('youtube-anime.com') || targetUrl.includes('allanime.day')) {
+                refererValue = 'https://allanime.day/';
+            }
+            else if (targetUrl.includes('animeya.cc')) {
+                refererValue = 'https://animeya.cc/';
+            }
+            const imageResponse = await (0, exports.axiosInstance)({
+                method: 'get',
+                url: targetUrl,
+                responseType: 'stream',
+                headers: {
+                    Referer: refererValue,
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+                },
+                timeout: 30000,
+                signal: abortController.signal,
+            });
+            if (imageResponse.status === 200) {
+                res.set('Cache-Control', 'public, max-age=604800, immutable');
+            }
+            res.set('Content-Type', String(imageResponse.headers['content-type'] ?? ''));
+            imageResponse.data.on('error', () => {
+                if (!res.headersSent) {
+                    this.sendPlaceholder(res);
+                }
+            });
+            res.on('close', () => {
+                if (!imageResponse.data.destroyed) {
+                    imageResponse.data.destroy();
+                }
+            });
+            imageResponse.data.pipe(res);
+        }
+        catch (e) {
+            if (axios_1.default.isCancel(e)) {
+                return;
+            }
+            if (!res.headersSent) {
+                this.sendPlaceholder(res);
+            }
+        }
+    };
+    sendPlaceholder(res) {
+        const possiblePaths = [
+            path_1.default.join(config_1.CONFIG.PACKAGE_ROOT, 'client/public/placeholder.svg'),
+            path_1.default.join(config_1.CONFIG.PACKAGE_ROOT, 'client/dist/placeholder.svg'),
+            path_1.default.join(config_1.CONFIG.SERVER_ROOT, '..', 'client/public/placeholder.svg'),
+        ];
+        for (const p of possiblePaths) {
+            if (fs_1.default.existsSync(p)) {
+                return res.status(200).sendFile(p);
+            }
+        }
+        res.status(404).send('Not Found');
+    }
+}
+exports.ProxyController = ProxyController;

package/server/dist/controllers/settings.controller.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsController = void 0;
+const sync_1 = require("../sync");
+const xml2js_1 = require("xml2js");
+const logger_1 = __importDefault(require("../logger"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../config");
+const settings_repository_1 = require("../repositories/settings.repository");
+class SettingsController {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    getSettings = async (req, res) => {
+        try {
+            const row = await settings_repository_1.SettingsRepository.getByKey(req.db, req.query.key);
+            res.json({ value: row ? row.value : null });
+        }
+        catch {
+            res.status(500).json({ error: 'DB error' });
+        }
+    };
+    updateSettings = async (req, res) => {
+        try {
+            await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                settings_repository_1.SettingsRepository.upsert(tx, req.body.key, String(req.body.value));
+            });
+            res.json({ success: true });
+        }
+        catch {
+            res.status(500).json({ error: 'DB error' });
+        }
+    };
+    backupDatabase = (req, res) => {
+        const backupPath = path_1.default.join(config_1.CONFIG.ROOT, 'ani-web-backup.db');
+        try {
+            req.db.backup(backupPath);
+            res.download(backupPath, 'ani-web-backup.db', () => {
+                fs_1.default.unlink(backupPath, () => { });
+            });
+        }
+        catch (err) {
+            logger_1.default.error({ err }, 'Manual backup failed');
+            return res.status(500).json({ error: 'Backup failed' });
+        }
+    };
+    restoreDatabase = (req, res, db, initializeDatabase, setDb) => {
+        if (!req.file)
+            return res.status(400).json({ error: 'No file uploaded.' });
+        const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+        const tempPath = path_1.default.join(config_1.CONFIG.ROOT, `restore_temp.db`);
+        const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+        db.close((closeErr) => {
+            if (closeErr)
+                return res.status(500).json({ error: 'Failed to close database.' });
+            try {
+                req.db.checkpoint();
+            }
+            catch (checkpointErr) {
+                logger_1.default.warn({ err: checkpointErr }, 'WAL checkpoint failed');
+            }
+            try {
+                if (fs_1.default.existsSync(`${dbPath}-wal`))
+                    fs_1.default.unlinkSync(`${dbPath}-wal`);
+                if (fs_1.default.existsSync(`${dbPath}-shm`))
+                    fs_1.default.unlinkSync(`${dbPath}-shm`);
+            }
+            catch (cleanupErr) {
+                logger_1.default.warn({ err: cleanupErr }, 'Failed to clean up WAL files');
+            }
+            fs_1.default.rename(tempPath, dbPath, async (renameErr) => {
+                if (renameErr) {
+                    try {
+                        const reopenedDb = await initializeDatabase(dbPath);
+                        setDb(reopenedDb);
+                        req.db = reopenedDb;
+                    }
+                    catch (e) {
+                        logger_1.default.error({ err: e }, 'Failed to reopen DB after rename failure');
+                    }
+                    return res.status(500).json({ error: 'Failed to replace database file.' });
+                }
+                try {
+                    const newDb = await initializeDatabase(dbPath);
+                    setDb(newDb);
+                    req.db = newDb;
+                    res.json({ success: true, message: 'Database restored.' });
+                }
+                catch (e) {
+                    logger_1.default.error({ err: e }, 'Failed to initialize restored database');
+                    res.status(500).json({ error: 'Failed to initialize restored database.' });
+                }
+            });
+        });
+    };
+    importMalXml = async (req, res) => {
+        if (!req.file)
+            return res.status(400).json({ error: 'No file' });
+        const { erase } = req.body;
+        let result;
+        try {
+            result = await (0, xml2js_1.parseStringPromise)(req.file.buffer.toString());
+        }
+        catch {
+            return res.status(400).json({ error: 'Invalid XML' });
+        }
+        const animeList = result?.myanimelist?.anime || [];
+        let skippedCount = 0;
+        const showsToInsert = [];
+        const BATCH_SIZE = 5;
+        for (let i = 0; i < animeList.length; i += BATCH_SIZE) {
+            const batch = animeList.slice(i, i + BATCH_SIZE);
+            const batchResults = await Promise.allSettled(batch.map((item) => this.provider.search({ query: item.series_title[0] })));
+            batchResults.forEach((r, idx) => {
+                if (r.status === 'fulfilled' && r.value.length > 0) {
+                    showsToInsert.push({
+                        id: r.value[0]._id,
+                        name: r.value[0].name,
+                        thumbnail: r.value[0].thumbnail,
+                        status: batch[idx].my_status[0],
+                    });
+                }
+                else {
+                    skippedCount++;
+                }
+            });
+        }
+        try {
+            await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                if (erase)
+                    settings_repository_1.SettingsRepository.clearWatchlist(tx);
+                settings_repository_1.SettingsRepository.upsertWatchlistBatch(tx, showsToInsert);
+            });
+            res.json({ imported: showsToInsert.length, skipped: skippedCount });
+        }
+        catch (dbError) {
+            logger_1.default.error({ err: dbError }, 'Import DB error');
+            res.status(500).json({ error: 'DB error' });
+        }
+    };
+}
+exports.SettingsController = SettingsController;