ani-web 2.0.7

package/server/dist/db.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseWrapper = void 0;
+const node_sqlite_1 = require("node:sqlite");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("./logger"));
+class DatabaseWrapper {
+    db;
+    isClosed = false;
+    statementCache = new Map();
+    constructor(_dbPath, db) {
+        this.db = db;
+    }
+    static async create(dbPath) {
+        try {
+            const dir = path_1.default.dirname(dbPath);
+            if (!fs_1.default.existsSync(dir)) {
+                fs_1.default.mkdirSync(dir, { recursive: true });
+            }
+            const db = new node_sqlite_1.DatabaseSync(dbPath);
+            return new DatabaseWrapper(dbPath, db);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, `Failed to initialize database at ${dbPath}`);
+            throw e;
+        }
+    }
+    scheduleSave() { }
+    async saveNow() { }
+    configure(option, value) {
+        if (option === 'busyTimeout') {
+            this.db.exec(`PRAGMA busy_timeout = ${value}`);
+        }
+    }
+    serialize(cb) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            cb();
+            this.db.exec('COMMIT');
+        }
+        catch (e) {
+            this.db.exec('ROLLBACK');
+            throw e;
+        }
+    }
+    close(cb) {
+        if (this.isClosed) {
+            if (cb)
+                cb(null);
+            return;
+        }
+        try {
+            this.isClosed = true;
+            this.statementCache.clear();
+            this.db.close();
+            if (cb)
+                cb(null);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Error during database close');
+            if (cb)
+                cb(e);
+        }
+    }
+    isClosedCheck() {
+        return this.isClosed;
+    }
+    getPreparedStatement(query) {
+        let stmt = this.statementCache.get(query);
+        if (!stmt) {
+            if (this.statementCache.size > 100) {
+                this.statementCache.clear();
+            }
+            stmt = this.db.prepare(query);
+            this.statementCache.set(query, stmt);
+        }
+        return stmt;
+    }
+    run(query, params = []) {
+        if (this.isClosed) {
+            throw new Error('Database is closed');
+        }
+        const stmt = this.getPreparedStatement(query);
+        if (params.length > 0) {
+            stmt.run(...params);
+        }
+        else {
+            stmt.run();
+        }
+    }
+    get(query, params = []) {
+        if (this.isClosed) {
+            throw new Error('Database is closed');
+        }
+        const stmt = this.getPreparedStatement(query);
+        if (params.length > 0) {
+            return stmt.get(...params);
+        }
+        return stmt.get();
+    }
+    all(query, params = []) {
+        if (this.isClosed) {
+            throw new Error('Database is closed');
+        }
+        const stmt = this.getPreparedStatement(query);
+        if (params.length > 0) {
+            return stmt.all(...params);
+        }
+        return stmt.all();
+    }
+    prepare(query) {
+        const stmt = this.getPreparedStatement(query);
+        return {
+            run: (...args) => {
+                stmt.run(...args);
+            },
+            all: () => {
+                return stmt.all();
+            },
+            get: () => {
+                return stmt.get();
+            },
+            finalize: () => { },
+        };
+    }
+    backup(backupPath) {
+        try {
+            if (fs_1.default.existsSync(backupPath)) {
+                fs_1.default.rmSync(backupPath, { force: true });
+            }
+            this.db.exec(`VACUUM INTO '${backupPath}'`);
+        }
+        catch (e) {
+            logger_1.default.error({ err: e, backupPath }, 'Database backup failed via VACUUM INTO');
+            throw e;
+        }
+    }
+    checkpoint() {
+        try {
+            this.db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        }
+        catch (e) {
+            logger_1.default.error({ err: e }, 'Database WAL checkpoint failed');
+            throw e;
+        }
+    }
+}
+exports.DatabaseWrapper = DatabaseWrapper;

package/server/dist/discord-rpc.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discordRPCService = void 0;
+const discord_rpc_1 = require("@xhayper/discord-rpc");
+const logger_1 = __importDefault(require("./logger"));
+const config_1 = require("./config");
+const log = logger_1.default.child({ module: 'DiscordRPC' });
+class DiscordRPCService {
+    client = null;
+    isEnabled = false;
+    reconnectTimeout = null;
+    lastActivity = null;
+    currentSessionId = null;
+    retryCount = 0;
+    MAX_RETRIES = 5;
+    INITIAL_RECONNECT_DELAY = 15000;
+    MAX_RECONNECT_DELAY = 300000;
+    setEnabled(enabled) {
+        if (this.isEnabled === enabled)
+            return;
+        this.isEnabled = enabled;
+        if (enabled) {
+            this.retryCount = 0;
+            this.connect();
+        }
+        else {
+            this.disconnect();
+        }
+    }
+    async connect() {
+        if (!this.isEnabled || this.client)
+            return;
+        const isTermux = !!process.env.TERMUX_VERSION;
+        const isAndroid = process.platform === 'android';
+        if (isTermux || isAndroid) {
+            log.debug('Discord Rich Presence is not supported on Android/Termux. Skipping connection.');
+            this.isEnabled = false;
+            return;
+        }
+        const clientId = config_1.CONFIG.DISCORD_CLIENT_ID;
+        if (!clientId) {
+            log.debug('DISCORD_CLIENT_ID is not configured. Discord Rich Presence is disabled.');
+            return;
+        }
+        try {
+            this.client = new discord_rpc_1.Client({ clientId });
+            this.client.on('ready', () => {
+                log.info('Connected to Discord client successfully');
+                this.retryCount = 0;
+                if (this.lastActivity) {
+                    this.updatePresence(this.lastActivity);
+                }
+                else {
+                    this.setIdleStatus('home');
+                }
+            });
+            this.client.on('disconnected', () => {
+                log.warn('Disconnected from Discord client, scheduling reconnect...');
+                this.cleanup();
+                this.scheduleReconnect();
+            });
+            this.client.on('ERROR', (err) => {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                if (errMsg.includes('ENOENT') || errMsg.includes('ECONNREFUSED')) {
+                    log.debug('Discord client not running or connection refused.');
+                }
+                else {
+                    log.error({ err }, 'Discord RPC client error');
+                }
+                this.cleanup();
+                this.scheduleReconnect();
+            });
+            const loginPromise = this.client.login();
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Login timeout')), 5000));
+            await Promise.race([loginPromise, timeoutPromise]);
+        }
+        catch (err) {
+            this.cleanup();
+            this.scheduleReconnect();
+        }
+    }
+    scheduleReconnect() {
+        if (!this.isEnabled || this.reconnectTimeout)
+            return;
+        const delay = Math.min(this.INITIAL_RECONNECT_DELAY * Math.pow(1.5, this.retryCount), this.MAX_RECONNECT_DELAY);
+        this.retryCount++;
+        if (this.retryCount > this.MAX_RETRIES) {
+            log.debug(`Discord RPC login failed ${this.retryCount} times. Retrying in ${Math.round(delay / 1000)}s...`);
+        }
+        else {
+            log.info(`Discord RPC login failed. Retrying in ${Math.round(delay / 1000)}s...`);
+        }
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            this.connect();
+        }, delay);
+    }
+    cleanup() {
+        if (this.client) {
+            try {
+                this.client.removeAllListeners();
+                this.client.destroy();
+            }
+            catch (err) {
+                // Ignore errors during destruction
+            }
+            this.client = null;
+        }
+    }
+    disconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        this.cleanup();
+        this.isEnabled = false;
+        this.lastActivity = null;
+        this.currentSessionId = null;
+    }
+    formatTime(seconds) {
+        if (isNaN(seconds) || seconds <= 0)
+            return '00:00';
+        const h = Math.floor(seconds / 3600);
+        const m = Math.floor((seconds % 3600) / 60);
+        const s = Math.floor(seconds % 60);
+        const mm = String(m).padStart(2, '0');
+        const ss = String(s).padStart(2, '0');
+        if (h > 0) {
+            const hh = String(h).padStart(2, '0');
+            return `${hh}:${mm}:${ss}`;
+        }
+        return `${mm}:${ss}`;
+    }
+    async updatePresence(data) {
+        this.lastActivity = data;
+        if (data.sessionId) {
+            this.currentSessionId = data.sessionId;
+        }
+        if (!this.isEnabled || !this.client || !this.client.user)
+            return;
+        const isSafeUrl = (url) => {
+            if (!url.startsWith('http://') && !url.startsWith('https://')) {
+                return false;
+            }
+            if (url.includes('localhost') || url.includes('127.0.0.1')) {
+                return false;
+            }
+            if (url.includes('s4.anilist.co') || url.includes('anilistcdn')) {
+                return true;
+            }
+            const blockedDomains = [
+                'youtube-anime.com',
+                'allanime.day',
+                'animepahe',
+                'animeya.cc',
+                'gogocdn.net',
+            ];
+            return !blockedDomains.some((domain) => url.includes(domain));
+        };
+        let imageKey = 'logo';
+        if (data.thumbnail && data.providerName !== 'AnimePahe') {
+            let thumbUrl = data.thumbnail;
+            if (thumbUrl.includes('/api/image-proxy')) {
+                const match = thumbUrl.match(/url=([^&]+)/);
+                if (match) {
+                    thumbUrl = decodeURIComponent(match[1]);
+                }
+            }
+            if (isSafeUrl(thumbUrl)) {
+                imageKey = thumbUrl;
+            }
+            else if (data.thumbnails) {
+                const safeThumb = data.thumbnails.find((t) => t && (t.includes('s4.anilist.co') || t.includes('anilistcdn')));
+                if (safeThumb)
+                    imageKey = safeThumb;
+            }
+        }
+        try {
+            if (!data.isPlaying) {
+                await this.client.user.clearActivity();
+                await this.client.user.setActivity({
+                    details: data.title,
+                    state: `Episode ${data.episode}${data.totalEpisodes ? `/${data.totalEpisodes}` : ''} (Paused)`,
+                    largeImageKey: imageKey,
+                    largeImageText: data.title,
+                    smallImageKey: 'logo',
+                    smallImageText: 'ani-web',
+                    type: 3,
+                    buttons: [
+                        {
+                            label: 'Learn More',
+                            url: 'https://github.com/serifpersia/ani-web',
+                        },
+                    ],
+                });
+                return;
+            }
+            const nowSeconds = Math.round(Date.now() / 1000);
+            const activity = {
+                details: data.title,
+                state: `Episode ${data.episode}${data.totalEpisodes ? `/${data.totalEpisodes}` : ''}`,
+                largeImageKey: imageKey,
+                largeImageText: data.title,
+                smallImageKey: 'logo',
+                smallImageText: 'ani-web',
+                type: 3,
+                buttons: [
+                    {
+                        label: 'Learn More',
+                        url: 'https://github.com/serifpersia/ani-web',
+                    },
+                ],
+            };
+            if (data.currentTime && data.currentTime > 0) {
+                activity.startTimestamp = Math.round(nowSeconds - data.currentTime);
+            }
+            if (data.duration && data.duration > data.currentTime) {
+                activity.endTimestamp = Math.round(nowSeconds + (data.duration - data.currentTime));
+            }
+            await this.client.user.setActivity(activity);
+        }
+        catch (err) {
+            log.error({ err }, 'Failed to set Discord activity');
+        }
+    }
+    async setIdleStatus(page) {
+        if (!this.isEnabled || !this.client || !this.client.user)
+            return;
+        const pageLabels = {
+            home: { details: 'Browsing Anime', state: 'On the Home page' },
+            search: { details: 'Searching for Anime', state: 'Exploring titles...' },
+            watchlist: { details: 'Managing Watchlist', state: 'Reviewing anime list' },
+            anime: { details: 'Viewing Anime Info', state: 'Reading show details' },
+            insights: { details: 'Checking Insights', state: 'Reviewing stats' },
+            settings: { details: 'In Settings', state: 'Tweaking preferences' },
+            mal: { details: 'MAL Sync', state: 'Syncing with MyAnimeList' },
+        };
+        const label = pageLabels[page] ?? { details: 'Browsing Anime', state: 'Idle' };
+        try {
+            if (!this.client || !this.client.user) {
+                log.warn('Discord client not connected, skipping idle status update');
+                return;
+            }
+            await this.client.user.setActivity({
+                details: label.details,
+                state: label.state,
+                largeImageKey: 'logo',
+                largeImageText: 'ani-web',
+                type: 3,
+                buttons: [
+                    {
+                        label: 'Learn More',
+                        url: 'https://github.com/serifpersia/ani-web',
+                    },
+                ],
+            });
+        }
+        catch (err) {
+            if (err.message === 'Closed by Discord') {
+                log.warn('Discord connection ended, skipping idle status update');
+            }
+            else {
+                log.error({ err }, 'Failed to set Discord idle status');
+            }
+        }
+    }
+    async clearPresence(sessionId) {
+        if (sessionId && this.currentSessionId && sessionId !== this.currentSessionId) {
+            return;
+        }
+        this.lastActivity = null;
+        this.currentSessionId = null;
+        await this.setIdleStatus('home');
+    }
+}
+exports.discordRPCService = new DiscordRPCService();