@serifpersia/dango 3.0.3

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(args) {
+        return new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)('rclone', args, (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(['listremotes']);
+            return remotesStr
+                .split('\n')
+                .map((r) => r.trim())
+                .filter((r) => r !== '')
+                .map((r) => r.replace(/:$/, ''));
+        }
+        catch {
+            return [];
+        }
+    }
+    async init() {
+        try {
+            await this.executeCommand(['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,43 @@
+"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(DISTINCT showId) FROM watched_episodes) as totalAnime,
+        (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/mal-cache.repository.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAL_CACHE_MAX_ROWS = void 0;
+exports.malCacheGet = malCacheGet;
+exports.malCachePut = malCachePut;
+exports.malCachePruneExpired = malCachePruneExpired;
+exports.malCacheDelete = malCacheDelete;
+exports.malCacheStore = malCacheStore;
+const node_sqlite_1 = require("node:sqlite");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const db_1 = require("../db");
+const db_utils_1 = require("../utils/db-utils");
+exports.MAL_CACHE_MAX_ROWS = 5000;
+const DEFAULT_TTL_SECONDS = 6 * 3600;
+function cacheFile() {
+    return path_1.default.join(config_1.CONFIG.ROOT, config_1.CONFIG.IS_DEV ? 'mal-cache.dev.db' : 'mal-cache.db');
+}
+let handle = null;
+function db() {
+    if (!handle) {
+        const file = cacheFile();
+        fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+        handle = new db_1.DatabaseWrapper(file, new node_sqlite_1.DatabaseSync(file));
+        (0, db_utils_1.dbRun)(handle, `CREATE TABLE IF NOT EXISTS mal_cache (key TEXT PRIMARY KEY, payload TEXT NOT NULL, fetched_at TEXT NOT NULL, expires_at TEXT NOT NULL)`);
+    }
+    return handle;
+}
+function malCacheGet(key) {
+    const row = (0, db_utils_1.dbGet)(db(), 'SELECT payload, fetched_at AS fetchedAt, expires_at AS expiresAt FROM mal_cache WHERE key = ?', [key]);
+    if (!row)
+        return null;
+    return { payload: row.payload, fresh: Date.now() < Date.parse(row.expiresAt) };
+}
+function malCachePut(key, payload, ttlSeconds = DEFAULT_TTL_SECONDS) {
+    const database = db();
+    const now = new Date();
+    (0, db_utils_1.dbRun)(database, 'INSERT OR REPLACE INTO mal_cache (key, payload, fetched_at, expires_at) VALUES (?, ?, ?, ?)', [key, payload, now.toISOString(), new Date(now.getTime() + ttlSeconds * 1000).toISOString()]);
+    const count = (0, db_utils_1.dbGet)(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
+    if (count < exports.MAL_CACHE_MAX_ROWS)
+        return;
+    malCachePruneExpired();
+    const remaining = (0, db_utils_1.dbGet)(database, 'SELECT COUNT(*) AS rows FROM mal_cache')?.rows ?? 0;
+    if (remaining < exports.MAL_CACHE_MAX_ROWS)
+        return;
+    (0, db_utils_1.dbRun)(database, `DELETE FROM mal_cache WHERE key NOT IN (SELECT key FROM mal_cache ORDER BY fetched_at DESC LIMIT ${exports.MAL_CACHE_MAX_ROWS})`);
+}
+function malCachePruneExpired() {
+    const now = new Date().toISOString();
+    const row = (0, db_utils_1.dbGet)(db(), 'SELECT COUNT(*) AS rows FROM mal_cache WHERE expires_at < ?', [now]);
+    (0, db_utils_1.dbRun)(db(), 'DELETE FROM mal_cache WHERE expires_at < ?', [now]);
+    return row?.rows ?? 0;
+}
+function malCacheDelete(key) {
+    (0, db_utils_1.dbRun)(db(), 'DELETE FROM mal_cache WHERE key = ?', [key]);
+}
+function malCacheStore() {
+    return {
+        get: (key) => malCacheGet(key),
+        put: (key, payload, ttl) => malCachePut(key, payload, ttl),
+    };
+}

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

@@ -0,0 +1,40 @@
+"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)'),
+    ]),
+    hasAnyDiscovered: (db) => Promise.resolve((0, db_utils_1.dbGet)(db, 'SELECT COUNT(*) as count FROM discovered_notifications')).then((row) => (row?.count || 0) > 0),
+    hasActiveNotifications: (db) => Promise.resolve((0, db_utils_1.dbGet)(db, `SELECT COUNT(*) as count FROM discovered_notifications dn
+         WHERE NOT EXISTS (
+           SELECT 1 FROM dismissed_notifications dn2 
+           WHERE dn2.showId = dn.showId AND dn2.episodeNumber = dn.episodeNumber
+         )
+         AND NOT EXISTS (
+           SELECT 1 FROM watched_episodes we 
+           WHERE we.showId = dn.showId AND we.episodeNumber = dn.episodeNumber
+         )`)).then((row) => (row?.count || 0) > 0),
+};

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

@@ -0,0 +1,64 @@
+"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(NULLIF(sm.name, ''), w.name) as name,
+        COALESCE(NULLIF(sm.thumbnail, ''), NULLIF(w.thumbnail, ''), '') as thumbnail,
+        COALESCE(NULLIF(sm.nativeName, ''), w.nativeName) as nativeName,
+        COALESCE(NULLIF(sm.englishName, ''), w.englishName) as englishName,
+        COALESCE(NULLIF(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,
+    ]),
+    getByShow: (db, showId) => (0, db_utils_1.dbAll)(db, 'SELECT * FROM queue WHERE showId = ? ORDER BY queue_order ASC', [showId]),
+    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]),
+    addManyToEnd: async (db, episodes) => {
+        if (episodes.length === 0)
+            return;
+        let nextOrder = (await exports.QueueRepository.getMaxOrder(db)) + 1;
+        for (const episode of episodes) {
+            const existing = await exports.QueueRepository.getByEpisode(db, episode.showId, episode.episodeNumber);
+            if (existing)
+                continue;
+            await (0, db_utils_1.dbRun)(db, 'INSERT INTO queue (showId, episodeNumber, queue_order) VALUES (?, ?, ?)', [
+                episode.showId,
+                episode.episodeNumber,
+                nextOrder,
+            ]);
+            nextOrder += 1;
+        }
+    },
+    removeMany: (db, showId, episodeNumbers) => {
+        if (episodeNumbers.length === 0)
+            return Promise.resolve();
+        const placeholders = episodeNumbers.map(() => '?').join(', ');
+        return (0, db_utils_1.dbRun)(db, `DELETE FROM queue WHERE showId = ? AND episodeNumber IN (${placeholders})`, [
+            showId,
+            ...episodeNumbers,
+        ]);
+    },
+    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,15 @@
+"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]),
+    deleteByKey: (db, key) => (0, db_utils_1.dbRun)(db, 'DELETE FROM settings WHERE key = ?', [key]),
+    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,43 @@
+"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, anilistId, isAdult)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+          name = COALESCE(NULLIF(EXCLUDED.name, ''), shows_meta.name),
+          thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), shows_meta.thumbnail),
+          nativeName = COALESCE(NULLIF(EXCLUDED.nativeName, ''), shows_meta.nativeName),
+          englishName = COALESCE(NULLIF(EXCLUDED.englishName, ''), shows_meta.englishName),
+          genres = COALESCE(NULLIF(EXCLUDED.genres, ''), shows_meta.genres),
+          popularityScore = COALESCE(EXCLUDED.popularityScore, shows_meta.popularityScore),
+          status = COALESCE(NULLIF(EXCLUDED.status, ''), shows_meta.status),
+          episodeCount = COALESCE(EXCLUDED.episodeCount, shows_meta.episodeCount),
+          type = COALESCE(NULLIF(EXCLUDED.type, ''), shows_meta.type),
+          anilistId = COALESCE(EXCLUDED.anilistId, shows_meta.anilistId),
+          isAdult = COALESCE(EXCLUDED.isAdult, shows_meta.isAdult)`, [
+        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,
+        data.anilistId ?? null,
+        data.isAdult ?? null,
+    ]),
+    updateEpisodeCount: (db, id, episodeCount) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET episodeCount = ? WHERE id = ?', [episodeCount, id]),
+    updateStatus: (db, id, status) => (0, db_utils_1.dbRun)(db, 'UPDATE shows_meta SET status = ? WHERE id = ?', [status, 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/temp-show-ids.repository.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempShowIdsRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+const temp_ids_1 = require("../lib/temp-ids");
+exports.TempShowIdsRepository = {
+    getById: (db, id) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM temp_show_ids WHERE id = ?', [id]),
+    getByProviderNative: (db, provider, nativeId) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM temp_show_ids WHERE provider = ? AND nativeId = ?', [
+        provider,
+        nativeId,
+    ]),
+    count: (db) => {
+        const row = (0, db_utils_1.dbGet)(db, 'SELECT COUNT(*) as total FROM temp_show_ids');
+        return row?.total || 0;
+    },
+    allocate: (db, data) => {
+        const existing = exports.TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
+        if (existing)
+            return existing;
+        const prefixLen = temp_ids_1.TEMP_SHOW_ID_PREFIX.length + 1;
+        const maxRow = (0, db_utils_1.dbGet)(db, `SELECT MAX(CAST(SUBSTR(id, ?) AS INTEGER)) as maxId FROM temp_show_ids WHERE id LIKE '${temp_ids_1.TEMP_SHOW_ID_PREFIX}%'`, [prefixLen]);
+        const next = (maxRow?.maxId || 0) + 1;
+        const id = `${temp_ids_1.TEMP_SHOW_ID_PREFIX}${next}`;
+        try {
+            (0, db_utils_1.dbRun)(db, 'INSERT INTO temp_show_ids (id, provider, nativeId, title, thumbnail, createdAt) VALUES (?, ?, ?, ?, ?, ?)', [id, data.provider, data.nativeId, data.title, data.thumbnail || '', Date.now()]);
+        }
+        catch {
+            // Lost a race with a concurrent allocate — return whatever won.
+            const winner = exports.TempShowIdsRepository.getByProviderNative(db, data.provider, data.nativeId);
+            if (winner)
+                return winner;
+            throw new Error('temp id allocation failed');
+        }
+        return exports.TempShowIdsRepository.getById(db, id);
+    },
+    purge: (db) => {
+        const total = exports.TempShowIdsRepository.count(db);
+        if (total === 0)
+            return 0;
+        const like = `${temp_ids_1.TEMP_SHOW_ID_PREFIX}%`;
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM watchlist WHERE id LIKE ?', [like]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM watched_episodes WHERE showId LIKE ?', [like]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM queue WHERE showId LIKE ?', [like]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM shows_meta WHERE id LIKE ?', [like]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM dismissed_notifications WHERE showId LIKE ?', [like]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM discovered_notifications WHERE showId LIKE ?', [like]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM legacy_id_mapping WHERE legacyId LIKE ? OR numericId LIKE ?', [
+            like,
+            like,
+        ]);
+        (0, db_utils_1.dbRun)(db, 'DELETE FROM temp_show_ids');
+        return total;
+    },
+};

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

@@ -0,0 +1,54 @@
+"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]),
+    getContinueWatching: (db, limit) => {
+        const limitClause = typeof limit === 'number' ? `LIMIT ${limit}` : '';
+        const query = `
+      SELECT
+        we.showId as _id,
+        we.showId as id,
+        COALESCE(NULLIF(w.name, ''), sm.name) as name,
+        COALESCE(NULLIF(w.thumbnail, ''), NULLIF(sm.thumbnail, ''), '') as thumbnail,
+        COALESCE(NULLIF(w.nativeName, ''), sm.nativeName) as nativeName,
+        COALESCE(NULLIF(w.englishName, ''), sm.englishName) as englishName,
+        COALESCE(NULLIF(w.type, ''), sm.type) as type,
+        sm.episodeCount,
+        sm.type as smType,
+        sm.isAdult as isAdult,
+        w.status as watchlistStatus,
+        (SELECT COUNT(DISTINCT episodeNumber) FROM watched_episodes WHERE showId = we.showId) 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
+      LEFT 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 IS NULL OR w.status = 'Watching')
+        AND (w.id IS NOT NULL OR sm.id IS NOT NULL)
+      ORDER BY we.watchedAt DESC
+      ${limitClause}
+    `;
+        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);
+    },
+};

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchlistRepository = void 0;
+const db_utils_1 = require("../utils/db-utils");
+exports.WatchlistRepository = {
+    getById: (db, id) => (0, db_utils_1.dbGet)(db, 'SELECT * FROM watchlist WHERE id = ?', [id]),
+    exists: (db, id) => {
+        const row = (0, db_utils_1.dbGet)(db, 'SELECT EXISTS(SELECT 1 FROM watchlist WHERE id = ?) as inWatchlist', [id]);
+        return !!(row && row.inWatchlist);
+    },
+    getAll: (db, status, limit, offset) => {
+        let query = 'SELECT * FROM watchlist';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        query += ' ORDER BY rowid DESC';
+        if (limit !== undefined && offset !== undefined) {
+            query += ' LIMIT ? OFFSET ?';
+            params.push(limit, offset);
+        }
+        return (0, db_utils_1.dbAll)(db, query, params);
+    },
+    getCount: (db, status) => {
+        let query = 'SELECT COUNT(*) as total FROM watchlist';
+        const params = [];
+        if (status && status !== 'All') {
+            query += ' WHERE status = ?';
+            params.push(status);
+        }
+        const row = (0, db_utils_1.dbGet)(db, query, params);
+        return row?.total || 0;
+    },
+    upsert: (db, data) => (0, db_utils_1.dbRun)(db, `INSERT INTO watchlist (id, name, thumbnail, status, nativeName, englishName, type) VALUES (?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+          name = COALESCE(NULLIF(EXCLUDED.name, ''), watchlist.name),
+          thumbnail = COALESCE(NULLIF(EXCLUDED.thumbnail, ''), watchlist.thumbnail),
+          status = COALESCE(NULLIF(EXCLUDED.status, ''), watchlist.status),
+          nativeName = COALESCE(NULLIF(EXCLUDED.nativeName, ''), watchlist.nativeName),
+          englishName = COALESCE(NULLIF(EXCLUDED.englishName, ''), watchlist.englishName),
+          type = COALESCE(NULLIF(EXCLUDED.type, ''), watchlist.type)`, [
+        data.id,
+        data.name,
+        data.thumbnail,
+        data.status,
+        data.nativeName,
+        data.englishName,
+        data.type,
+    ]),
+    updateStatus: (db, id, status) => (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET status = ? WHERE id = ?', [status, id]),
+    updateThumbnail: (db, id, thumbnail) => {
+        if (!thumbnail || thumbnail.trim() === '')
+            return Promise.resolve();
+        return (0, db_utils_1.dbRun)(db, 'UPDATE watchlist SET thumbnail = ? WHERE id = ?', [thumbnail, id]);
+    },
+    delete: (db, id) => (0, db_utils_1.dbRun)(db, 'DELETE FROM watchlist WHERE id = ?', [id]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return Promise.resolve();
+        const placeholders = ids.map(() => '?').join(', ');
+        return (0, db_utils_1.dbRun)(db, `DELETE FROM watchlist WHERE id IN (${placeholders})`, ids);
+    },
+    updateStatusMany: (db, ids, status) => {
+        if (ids.length === 0)
+            return Promise.resolve();
+        const placeholders = ids.map(() => '?').join(', ');
+        return (0, db_utils_1.dbRun)(db, `UPDATE watchlist SET status = ? WHERE id IN (${placeholders})`, [
+            status,
+            ...ids,
+        ]);
+    },
+    getWatchingShows: (db) => (0, db_utils_1.dbAll)(db, "SELECT id, name, thumbnail, nativeName, englishName FROM watchlist WHERE status = 'Watching'"),
+};

package/server/dist/routes/asmr.routes.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAsmrRouter = createAsmrRouter;
+const express_1 = require("express");
+const logger_1 = __importDefault(require("../logger"));
+function makeCacheMiddleware(cache, keyFn, ttl) {
+    return (req, res, next) => {
+        const cacheKey = keyFn(req);
+        const cached = cache.get(cacheKey);
+        if (cached)
+            return res.json(cached);
+        const originalJson = res.json.bind(res);
+        res.json = (data) => {
+            if (res.statusCode >= 200 && res.statusCode < 400) {
+                if (ttl !== undefined)
+                    cache.set(cacheKey, data, ttl);
+                else
+                    cache.set(cacheKey, data);
+            }
+            return originalJson(data);
+        };
+        next();
+    };
+}
+function createAsmrRouter(apiCache, provider) {
+    const router = (0, express_1.Router)();
+    router.get('/asmr/browse', makeCacheMiddleware(apiCache, (req) => `route-asmr-browse-${req.query.q || ''}-${req.query.page || 1}-${req.query.sort || ''}-${req.query.rating || ''}-${req.query.sort === 'random' ? Date.now() : ''}`, 300), async (req, res) => {
+        try {
+            const result = await provider.browse({
+                query: req.query.q,
+                page: parseInt(req.query.page) || 1,
+                sort: req.query.sort,
+                rating: req.query.rating,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            if (err.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'jasmr' });
+            }
+            logger_1.default.error({ err }, '[Asmr] browse failed');
+            res.json({ shows: [], hasNext: false });
+        }
+    });
+    router.get('/asmr/work/:rj', makeCacheMiddleware(apiCache, (req) => `route-asmr-work-${req.params.rj}`, 1800), async (req, res) => {
+        try {
+            const rjCode = String(req.params.rj).trim().toUpperCase();
+            const episodes = await provider.getEpisodes(rjCode);
+            const streams = await provider.getStreamUrls(rjCode, '1');
+            const images = await provider.getImages(rjCode);
+            const chapters = await provider.getChapters(rjCode);
+            res.json({
+                rjCode,
+                description: episodes?.description || '',
+                tracks: streams?.[0]?.links || [],
+                images,
+                chapters,
+            });
+        }
+        catch (err) {
+            if (err.message === 'AUTH_REQUIRED') {
+                return res.status(403).json({ error: 'AUTH_REQUIRED', provider: 'jasmr' });
+            }
+            logger_1.default.error({ err, rj: req.params.rj }, '[Asmr] work fetch failed');
+            res.json({ rjCode: req.params.rj, description: '', tracks: [], images: [], chapters: [] });
+        }
+    });
+    return router;
+}