ani-web 2.0.7

package/server/dist/providers/megaplay.provider.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MegaPlayProvider = void 0;
+const logger_1 = __importDefault(require("../logger"));
+class MegaPlayProvider {
+    name = 'MegaPlay';
+    jikanBase = 'https://api.jikan.moe/v4';
+    megaPlayBase = 'https://megaplay.buzz/stream/mal';
+    cache;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    normalizeTitle(title) {
+        return title
+            .toLowerCase()
+            .replace(/[^\w\s-]/g, '')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    bestMatch(results, query) {
+        const q = this.normalizeTitle(query);
+        let best = results[0];
+        let bestScore = -1;
+        for (const anime of results) {
+            const title = this.normalizeTitle(anime.title);
+            const englishTitle = anime.title_english ? this.normalizeTitle(anime.title_english) : '';
+            let score = -1;
+            if (title === q || englishTitle === q) {
+                score = 3;
+            }
+            else if (title.startsWith(q) || englishTitle.startsWith(q)) {
+                score = 2;
+            }
+            else if (title.includes(q) || englishTitle.includes(q)) {
+                score = 1;
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                best = anime;
+                if (score === 3)
+                    break;
+            }
+        }
+        return best;
+    }
+    async search(options) {
+        try {
+            const rawQuery = options.query || '';
+            const query = rawQuery.replace(/[""]/g, '').replace(/[']/g, '').replace(/\s+/g, ' ').trim();
+            const url = `${this.jikanBase}/anime?q=${encodeURIComponent(query)}`;
+            const response = await fetch(url);
+            const data = (await response.json());
+            if (!data.data || data.data.length === 0)
+                return [];
+            const results = data.data.map((anime) => ({
+                _id: anime.mal_id.toString(),
+                id: anime.mal_id.toString(),
+                name: anime.title,
+                englishName: anime.title_english || anime.title,
+                thumbnail: anime.images?.jpg?.image_url,
+                type: anime.type,
+                year: anime.year,
+                episodeCount: anime.episodes,
+            }));
+            if (query && results.length > 0) {
+                const best = this.bestMatch(data.data, query);
+                const bestIndex = data.data.findIndex((a) => a.mal_id === best.mal_id);
+                if (bestIndex > 0) {
+                    const [bestItem] = results.splice(bestIndex, 1);
+                    results.unshift(bestItem);
+                }
+            }
+            return results;
+        }
+        catch (error) {
+            logger_1.default.error({ error }, 'MegaPlay (Jikan) search failed');
+            return [];
+        }
+    }
+    async getEpisodes(showId, _mode) {
+        try {
+            if (!/^\d+$/.test(showId))
+                return null;
+            const cacheKey = `megaplay_eps_${showId}`;
+            const cached = this.cache.get(cacheKey);
+            if (cached)
+                return cached;
+            const url = `${this.jikanBase}/anime/${showId}`;
+            const response = await fetch(url);
+            if (!response.ok)
+                return null;
+            const data = (await response.json());
+            if (!data.data)
+                return null;
+            const episodeCount = data.data.episodes || 0;
+            let count = episodeCount;
+            if (count === 0) {
+                if (data.data.status === 'Currently Airing' || data.data.status === 'Finished Airing') {
+                    count = 12;
+                }
+            }
+            const episodes = Array.from({ length: count }, (_, i) => (i + 1).toString());
+            const result = {
+                episodes,
+                description: data.data.synopsis || '',
+            };
+            this.cache.set(cacheKey, result, 86400);
+            return result;
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId }, 'MegaPlay getEpisodes failed');
+            return null;
+        }
+    }
+    async getStreamUrls(showId, episodeNumber, mode) {
+        if (!/^\d+$/.test(showId))
+            return null;
+        let targetEpisode = episodeNumber;
+        if (episodeNumber === '0') {
+            targetEpisode = '1';
+        }
+        const streamUrl = `${this.megaPlayBase}/${showId}/${targetEpisode}/${mode}`;
+        return [
+            {
+                sourceName: `MegaPlay (${mode.toUpperCase()})`,
+                links: [
+                    {
+                        resolutionStr: 'Auto',
+                        link: streamUrl,
+                        hls: false,
+                    },
+                ],
+                type: 'iframe',
+                actualEpisodeNumber: targetEpisode,
+            },
+        ];
+    }
+    async getShowMeta(showId) {
+        try {
+            if (!/^\d+$/.test(showId))
+                return null;
+            const url = `${this.jikanBase}/anime/${showId}`;
+            const response = await fetch(url);
+            const data = (await response.json());
+            if (!data.data)
+                return null;
+            const anime = data.data;
+            return {
+                _id: anime.mal_id.toString(),
+                name: anime.title,
+                englishName: anime.title_english,
+                thumbnail: anime.images?.jpg?.image_url,
+                description: anime.synopsis,
+                type: anime.type,
+                year: anime.year,
+                episodeCount: anime.episodes,
+                status: anime.status,
+                genres: anime.genres?.map((g) => ({ name: g.name })),
+                score: anime.score,
+            };
+        }
+        catch (error) {
+            logger_1.default.error({ error, showId }, 'MegaPlay getShowMeta failed');
+            return null;
+        }
+    }
+    async getPopular(_timeframe, page, size) {
+        try {
+            const url = `${this.jikanBase}/top/anime?page=${page || 1}&limit=${size || 10}`;
+            const response = await fetch(url);
+            const data = (await response.json());
+            if (!data.data)
+                return [];
+            return data.data.map((anime) => ({
+                _id: anime.mal_id.toString(),
+                id: anime.mal_id.toString(),
+                name: anime.title,
+                englishName: anime.title_english || anime.title,
+                thumbnail: anime.images?.jpg?.image_url,
+                type: anime.type,
+                year: anime.year,
+                episodeCount: anime.episodes,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getSchedule(date) {
+        try {
+            const days = ['sunday', 'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday'];
+            const day = days[date.getDay()];
+            const url = `${this.jikanBase}/schedules?filter=${day}`;
+            const response = await fetch(url);
+            const data = (await response.json());
+            if (!data.data)
+                return [];
+            return data.data.map((anime) => ({
+                _id: anime.mal_id.toString(),
+                id: anime.mal_id.toString(),
+                name: anime.title,
+                englishName: anime.title_english || anime.title,
+                thumbnail: anime.images?.jpg?.image_url,
+                type: anime.type,
+                year: anime.year,
+                episodeCount: anime.episodes,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getSeasonal(page) {
+        try {
+            const url = `${this.jikanBase}/seasons/now?page=${page}`;
+            const response = await fetch(url);
+            const data = (await response.json());
+            if (!data.data)
+                return [];
+            return data.data.map((anime) => ({
+                _id: anime.mal_id.toString(),
+                id: anime.mal_id.toString(),
+                name: anime.title,
+                englishName: anime.title_english || anime.title,
+                thumbnail: anime.images?.jpg?.image_url,
+                type: anime.type,
+                year: anime.year,
+                episodeCount: anime.episodes,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getLatestReleases(page, size) {
+        try {
+            const url = `${this.jikanBase}/top/anime?filter=airing&page=${page || 1}&limit=${size || 10}`;
+            const response = await fetch(url);
+            const data = (await response.json());
+            if (!data.data)
+                return [];
+            return data.data.map((anime) => ({
+                _id: anime.mal_id.toString(),
+                id: anime.mal_id.toString(),
+                name: anime.title,
+                englishName: anime.title_english || anime.title,
+                thumbnail: anime.images?.jpg?.image_url,
+                type: anime.type,
+                year: anime.year,
+                episodeCount: anime.episodes,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    async getSkipTimes(_showId, _episodeNumber) {
+        return { found: false, results: [] };
+    }
+}
+exports.MegaPlayProvider = MegaPlayProvider;

package/server/dist/providers/provider.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/rclone.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rcloneService = void 0;
+const child_process_1 = require("child_process");
+const logger_1 = __importDefault(require("./logger"));
+const config_1 = require("./config");
+class RcloneService {
+    activeRemote = null;
+    executeCommand(command) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.exec)(command, (err, stdout, stderr) => {
+                if (err) {
+                    if (stderr)
+                        logger_1.default.warn({ stderr }, 'Rclone command warning');
+                    return reject(new Error(stderr || err.message));
+                }
+                resolve(stdout.trim());
+            });
+        });
+    }
+    executeRcloneArgs(args) {
+        return new Promise((resolve, reject) => {
+            const process = (0, child_process_1.spawn)('rclone', args, { stdio: 'ignore' });
+            process.on('close', (code) => {
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(`Rclone exited with code ${code}`));
+            });
+            process.on('error', (err) => reject(err));
+        });
+    }
+    async listRemotes() {
+        try {
+            const remotesStr = await this.executeCommand('rclone listremotes');
+            return remotesStr
+                .split('\n')
+                .map((r) => r.trim())
+                .filter((r) => r !== '')
+                .map((r) => r.replace(/:$/, ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    async init() {
+        try {
+            await this.executeCommand('rclone version');
+            const remotes = await this.listRemotes();
+            if (config_1.CONFIG.RCLONE_REMOTE) {
+                const found = remotes.find((r) => r.toLowerCase() === config_1.CONFIG.RCLONE_REMOTE?.toLowerCase());
+                if (found) {
+                    this.activeRemote = found;
+                    logger_1.default.info(`Rclone initialized with manual remote: ${this.activeRemote}`);
+                    return true;
+                }
+                else {
+                    logger_1.default.warn(`Configured RCLONE_REMOTE '${config_1.CONFIG.RCLONE_REMOTE}' not found in rclone listremotes.`);
+                }
+            }
+            if (remotes.length > 0 && !config_1.CONFIG.RCLONE_REMOTE) {
+                logger_1.default.info({ remotes }, 'Rclone available but no manual remote is configured in settings.');
+                return false;
+            }
+            return false;
+        }
+        catch (error) {
+            logger_1.default.warn({ err: error }, 'Rclone initialization failed');
+            return false;
+        }
+    }
+    isActive() {
+        return this.activeRemote !== null;
+    }
+    getRemoteName() {
+        return this.activeRemote || 'unknown';
+    }
+    async downloadFile(remoteFolder, fileName, localPath) {
+        if (!this.activeRemote)
+            throw new Error('Rclone not active');
+        const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+        await this.executeRcloneArgs(['copyto', remotePath, localPath]);
+    }
+    async uploadFile(localPath, remoteFolder, fileName) {
+        if (!this.activeRemote)
+            throw new Error('Rclone not active');
+        const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+        await this.executeRcloneArgs(['copyto', localPath, remotePath]);
+    }
+    executeRcloneArgsWithOutput(args) {
+        return new Promise((resolve, reject) => {
+            const process = (0, child_process_1.spawn)('rclone', args, { stdio: 'pipe' });
+            let stdout = '';
+            let stderr = '';
+            process.stdout?.on('data', (data) => (stdout += data));
+            process.stderr?.on('data', (data) => (stderr += data));
+            process.on('close', (code) => {
+                if (code === 0)
+                    resolve(stdout.trim());
+                else {
+                    if (stderr)
+                        logger_1.default.warn({ stderr }, 'Rclone command warning');
+                    reject(new Error(stderr || `Rclone exited with code ${code}`));
+                }
+            });
+            process.on('error', (err) => reject(err));
+        });
+    }
+    async fileExists(remoteFolder, fileName) {
+        if (!this.activeRemote)
+            return false;
+        try {
+            const remotePath = `${this.activeRemote}:${remoteFolder}/${fileName}`;
+            const output = await this.executeRcloneArgsWithOutput(['lsjson', remotePath]);
+            const json = JSON.parse(output);
+            return json && json.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.rcloneService = new RcloneService();

package/server/dist/repositories/insights.repository.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.InsightsRepository = {
+    getCoreStats: (db) => (0, db_utils_1.dbGet)(db, `SELECT
+        (SELECT SUM(currentTime) FROM watched_episodes) as totalSeconds,
+        (SELECT COUNT(*) FROM watched_episodes) as totalEpisodes,
+        (SELECT COUNT(*) FROM watchlist WHERE status = 'Completed') as completedCount,
+        (SELECT COUNT(*) FROM watchlist) as totalWatchlist`),
+    getActivityGrid: (db) => (0, db_utils_1.dbAll)(db, `SELECT date(watchedAt) as day, COUNT(*) as count FROM watched_episodes GROUP BY day`),
+    getHourlyDist: (db) => (0, db_utils_1.dbAll)(db, `SELECT strftime('%H', watchedAt) as hour, COUNT(*) as count FROM watched_episodes GROUP BY hour`),
+    getSeasonality: (db) => (0, db_utils_1.dbAll)(db, `SELECT strftime('%m', watchedAt) as month, SUM(currentTime) as seconds FROM watched_episodes GROUP BY month`),
+    getAllWatches: (db) => (0, db_utils_1.dbAll)(db, 'SELECT watchedAt, currentTime FROM watched_episodes ORDER BY watchedAt ASC'),
+    getWatchedShowsMeta: (db) => (0, db_utils_1.dbAll)(db, `SELECT DISTINCT sm.id, sm.genres, sm.popularityScore
+      FROM shows_meta sm
+      JOIN watched_episodes we ON sm.id = we.showId`),
+    getDroppedShows: (db) => (0, db_utils_1.dbAll)(db, `SELECT w.id, w.name, MAX(we.watchedAt) as lastActivity
+        FROM watchlist w
+        JOIN watched_episodes we ON w.id = we.showId
+        WHERE w.status = 'Watching'
+        GROUP BY w.id
+        HAVING lastActivity < date('now', '-90 days')`),
+    getCompletionVelocities: (db) => (0, db_utils_1.dbAll)(db, `SELECT
+        (julianday(MAX(we.watchedAt)) - julianday(MIN(we.watchedAt))) as daysToFinish
+        FROM watchlist w
+        JOIN watched_episodes we ON w.id = we.showId
+        WHERE w.status = 'Completed'
+        GROUP BY w.id`),
+    getWatchedEpisodesWithMeta: (db) => (0, db_utils_1.dbAll)(db, `SELECT 
+        we.showId,
+        we.currentTime,
+        we.duration,
+        sm.genres,
+        sm.popularityScore,
+        sm.name,
+        sm.nativeName,
+        sm.englishName,
+        sm.thumbnail
+      FROM watched_episodes we
+      JOIN shows_meta sm ON we.showId = sm.id`),
+};

package/server/dist/repositories/notifications.repository.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.NotificationsRepository = {
+    getDismissedByShow: (db, showId) => (0, db_utils_1.dbAll)(db, 'SELECT episodeNumber FROM dismissed_notifications WHERE showId = ?', [showId]),
+    getDiscoveredByShow: (db, showId) => (0, db_utils_1.dbAll)(db, 'SELECT episodeNumber FROM discovered_notifications WHERE showId = ?', [showId]),
+    addDiscovered: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO discovered_notifications (showId, episodeNumber) VALUES (?, ?)', [showId, episodeNumber]),
+    addDismissed: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) VALUES (?, ?)', [showId, episodeNumber]),
+    dismissFromDiscovered: (db, showId) => {
+        if (showId) {
+            return (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications WHERE showId = ?', [showId]);
+        }
+        else {
+            return (0, db_utils_1.dbRun)(db, 'INSERT OR IGNORE INTO dismissed_notifications (showId, episodeNumber) SELECT showId, episodeNumber FROM discovered_notifications');
+        }
+    },
+    deleteByShow: (db, showId) => Promise.all([
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM dismissed_notifications WHERE showId = ?', [showId]),
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM discovered_notifications WHERE showId = ?', [showId]),
+    ]),
+    deleteSpecificDismissed: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'DELETE FROM dismissed_notifications WHERE showId = ? AND episodeNumber = ?', [
+        showId,
+        episodeNumber,
+    ]),
+    cleanupWatchedNotifications: (db) => Promise.all([
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM dismissed_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = dismissed_notifications.showId AND we.episodeNumber = dismissed_notifications.episodeNumber)'),
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM discovered_notifications WHERE EXISTS (SELECT 1 FROM watched_episodes we WHERE we.showId = discovered_notifications.showId AND we.episodeNumber = discovered_notifications.episodeNumber)'),
+    ]),
+};

package/server/dist/repositories/queue.repository.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.QueueRepository = {
+    getAll: (db) => (0, db_utils_1.dbAll)(db, `SELECT
+        q.id,
+        q.showId,
+        q.episodeNumber,
+        q.queue_order,
+        COALESCE(sm.name, w.name) as name,
+        COALESCE(sm.thumbnail, w.thumbnail) as thumbnail,
+        COALESCE(sm.nativeName, w.nativeName) as nativeName,
+        COALESCE(sm.englishName, w.englishName) as englishName,
+        COALESCE(sm.type, w.type) as type
+      FROM queue q
+      LEFT JOIN shows_meta sm ON q.showId = sm.id
+      LEFT JOIN watchlist w ON q.showId = w.id
+      ORDER BY q.queue_order ASC, q.id ASC`),
+    getByEpisode: (db, showId, episodeNumber) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM queue WHERE showId = ? AND episodeNumber = ?', [
+        showId,
+        episodeNumber,
+    ]),
+    getMaxOrder: async (db) => {
+        const row = await (0, db_utils_1.dbGet)(db, 'SELECT COALESCE(MAX(queue_order), -1) as maxOrder FROM queue');
+        return row?.maxOrder ?? -1;
+    },
+    addToEnd: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'INSERT INTO queue (showId, episodeNumber, queue_order) VALUES (?, ?, (SELECT COALESCE(MAX(queue_order), -1) + 1 FROM queue))', [showId, episodeNumber]),
+    removeEpisode: (db, showId, episodeNumber) => (0, db_utils_1.dbRun)(db, 'DELETE FROM queue WHERE showId = ? AND episodeNumber = ?', [showId, episodeNumber]),
+    clear: (db) => (0, db_utils_1.dbRun)(db, 'DELETE FROM queue'),
+    reorder: (db, items) => Promise.all(items.map((item, index) => {
+        if (item.id !== undefined) {
+            return (0, db_utils_1.dbRun)(db, 'UPDATE queue SET queue_order = ? WHERE id = ?', [index, item.id]);
+        }
+        return (0, db_utils_1.dbRun)(db, 'UPDATE queue SET queue_order = ? WHERE showId = ? AND episodeNumber = ?', [index, item.showId, item.episodeNumber]);
+    })),
+    cleanupOrphanedShowsMeta: (db) => (0, db_utils_1.dbRun)(db, 'DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)'),
+};

package/server/dist/repositories/settings.repository.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.SettingsRepository = {
+    getByKey: (db, key) => (0, db_utils_1.dbGet)(db, 'SELECT value FROM settings WHERE key = ?', [key]),
+    upsert: (db, key, value) => (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO settings (key, value) VALUES (?, ?)', [key, value]),
+    clearWatchlist: (db) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watchlist'),
+    upsertWatchlistBatch: (db, shows) => {
+        for (const show of shows) {
+            (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO watchlist (id, name, thumbnail, status) VALUES (?, ?, ?, ?)', [show.id, show.name, show.thumbnail ?? null, show.status]);
+        }
+    },
+};

package/server/dist/repositories/shows-meta.repository.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowsMetaRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.ShowsMetaRepository = {
+    getById: (db, id) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM shows_meta WHERE id = ?', [id]),
+    getStatus: async (db, id) => {
+        const row = await (0, db_utils_1.dbGet)(db, 'SELECT status FROM shows_meta WHERE id = ?', [
+            id,
+        ]);
+        return row?.status;
+    },
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, `INSERT INTO shows_meta (id, name, thumbnail, nativeName, englishName, genres, popularityScore, status, episodeCount, type)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = COALESCE(EXCLUDED.name, shows_meta.name),
+         thumbnail = COALESCE(EXCLUDED.thumbnail, shows_meta.thumbnail),
+         nativeName = COALESCE(EXCLUDED.nativeName, shows_meta.nativeName),
+         englishName = COALESCE(EXCLUDED.englishName, shows_meta.englishName),
+         genres = COALESCE(EXCLUDED.genres, shows_meta.genres),
+         popularityScore = COALESCE(EXCLUDED.popularityScore, shows_meta.popularityScore),
+         status = COALESCE(EXCLUDED.status, shows_meta.status),
+         episodeCount = COALESCE(EXCLUDED.episodeCount, shows_meta.episodeCount),
+         type = COALESCE(EXCLUDED.type, shows_meta.type)`, [
+        data.id,
+        data.name ?? null,
+        data.thumbnail ?? null,
+        data.nativeName ?? null,
+        data.englishName ?? null,
+        data.genres ?? null,
+        data.popularityScore ?? null,
+        data.status ?? null,
+        data.episodeCount ?? null,
+        data.type ?? null,
+    ]),
+    updateEpisodeCount: (db, id, episodeCount) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET episodeCount = ? WHERE id = ?', [episodeCount, id]),
+    updateType: (db, id, type) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET type = ? WHERE id = ?', [type, id]),
+    updateStatus: (db, id, status) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET status = ? WHERE id = ?', [status, id]),
+    updateThumbnail: (db, id, thumbnail) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET thumbnail = ? WHERE id = ?', [thumbnail, id]),
+    cleanupOrphanedMeta: (db) => (0, db_utils_1.dbRun)(db, 'DELETE FROM shows_meta WHERE id NOT IN (SELECT id FROM watchlist) AND id NOT IN (SELECT showId FROM queue)'),
+};

package/server/dist/repositories/watched-episodes.repository.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchedEpisodesRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.WatchedEpisodesRepository = {
+    getByShowAndEpisode: (db, showId, episodeNumber) => (0, db_utils_1.dbGet)(db, 'SELECT currentTime, duration FROM watched_episodes WHERE showId = ? AND episodeNumber = ?', [showId, episodeNumber]),
+    getWatchedEpisodeNumbers: async (db, showId) => {
+        const rows = await (0, db_utils_1.dbAll)(db, 'SELECT episodeNumber FROM watched_episodes WHERE showId = ?', [showId]);
+        return rows.map((r) => r.episodeNumber);
+    },
+    getByShow: (db, showId) => (0, db_utils_1.dbAll)(db, 'SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId = ? ORDER BY CAST(episodeNumber AS REAL) ASC', [showId]),
+    getLatestResumeProgress: (db, showId) => (0, db_utils_1.dbGet)(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt
+       FROM watched_episodes
+       WHERE showId = ? AND currentTime > 5 AND (duration <= 0 OR currentTime < duration * 0.8)
+       ORDER BY watchedAt DESC
+       LIMIT 1`, [showId]),
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, 'INSERT OR REPLACE INTO watched_episodes (showId, episodeNumber, watchedAt, currentTime, duration) VALUES (?, ?, CURRENT_TIMESTAMP, ?, ?)', [data.showId, data.episodeNumber, data.currentTime, data.duration]),
+    deleteByShow: (db, showId) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watched_episodes WHERE showId = ?', [showId]),
+    cleanupOrphanedProgress: (db) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watched_episodes WHERE showId NOT IN (SELECT id FROM watchlist)'),
+    getContinueWatching: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        const query = `
+      SELECT 
+        w.id as _id,
+        w.id as id,
+        w.name as name,
+        w.thumbnail as thumbnail,
+        w.nativeName as nativeName,
+        w.englishName as englishName,
+        w.type as type,
+        sm.episodeCount,
+        sm.type as smType,
+        (SELECT COUNT(DISTINCT episodeNumber) FROM watched_episodes WHERE showId = w.id) as watchedCount,
+        we.episodeNumber, we.currentTime, we.duration, we.watchedAt
+      FROM (
+        SELECT *, ROW_NUMBER() OVER(PARTITION BY showId ORDER BY watchedAt DESC) as rn
+        FROM watched_episodes
+      ) we
+      JOIN watchlist w ON we.showId = w.id
+      LEFT JOIN shows_meta sm ON we.showId = sm.id
+      WHERE we.rn = 1 AND w.status = 'Watching'
+      ORDER BY we.watchedAt DESC
+      ${limitClause}
+    `;
+        return (0, db_utils_1.dbAll)(db, query);
+    },
+    getUpNextShows: (db) => {
+        const query = `
+      SELECT w.id, w.name, w.thumbnail, w.nativeName, w.englishName, w.type, sm.episodeCount, sm.type as smType
+      FROM watchlist w
+      LEFT JOIN shows_meta sm ON w.id = sm.id
+      LEFT JOIN (
+        SELECT showId, MAX(watchedAt) as lastActivity
+        FROM watched_episodes
+        GROUP BY showId
+      ) we ON w.id = we.showId
+      WHERE w.status = 'Watching'
+      ORDER BY we.lastActivity DESC
+      LIMIT 15
+    `;
+        return (0, db_utils_1.dbAll)(db, query);
+    },
+    getEpisodesForShows: (db, showIds) => {
+        const placeholders = showIds.map(() => '?').join(',');
+        return (0, db_utils_1.dbAll)(db, `SELECT showId, episodeNumber, currentTime, duration, watchedAt FROM watched_episodes WHERE showId IN (${placeholders})`, showIds);
+    },
+};