@serifpersia/dango 3.3.4

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

@@ -0,0 +1,71 @@
+import { dbAll, dbGet, dbRun } from '../utils/db-utils.js';
+export const WatchlistRepository = {
+    getById: (db, id) => dbGet(db, 'SELECT * FROM watchlist WHERE id = ?', [id]),
+    exists: (db, id) => {
+        const row = 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 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 = dbGet(db, query, params);
+        return row?.total || 0;
+    },
+    upsert: (db, data) => 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) => dbRun(db, 'UPDATE watchlist SET status = ? WHERE id = ?', [status, id]),
+    updateThumbnail: (db, id, thumbnail) => {
+        if (!thumbnail || thumbnail.trim() === '')
+            return Promise.resolve();
+        return dbRun(db, 'UPDATE watchlist SET thumbnail = ? WHERE id = ?', [thumbnail, id]);
+    },
+    delete: (db, id) => dbRun(db, 'DELETE FROM watchlist WHERE id = ?', [id]),
+    deleteMany: (db, ids) => {
+        if (ids.length === 0)
+            return Promise.resolve();
+        const placeholders = ids.map(() => '?').join(', ');
+        return 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 dbRun(db, `UPDATE watchlist SET status = ? WHERE id IN (${placeholders})`, [
+            status,
+            ...ids,
+        ]);
+    },
+    getWatchingShows: (db) => dbAll(db, "SELECT id, name, thumbnail, nativeName, englishName FROM watchlist WHERE status = 'Watching'"),
+};

package/server/dist/request-logger.js

@@ -0,0 +1,16 @@
+import logger from './logger.js';
+export function requestLogger(req, res, next) {
+    const start = process.hrtime.bigint();
+    const url = req.originalUrl || req.url;
+    res.on('finish', () => {
+        const ms = Math.round((Number(process.hrtime.bigint() - start) / 1_000_000) * 10) / 10;
+        const payload = { method: req.method, url, status: res.statusCode, ms };
+        if (res.statusCode >= 500) {
+            logger.warn(payload, 'request failed');
+        }
+        else if (!url.startsWith('/api/proxy')) {
+            logger.trace(`${req.method} ${url} ${res.statusCode} ${ms}ms`);
+        }
+    });
+    next();
+}

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

@@ -0,0 +1,23 @@
+import { Router } from 'express';
+import { AsmrLibraryController } from '../controllers/asmr-library.controller.js';
+export function createAsmrLibraryRouter() {
+    const router = Router();
+    const controller = new AsmrLibraryController();
+    router.get('/asmr/library', controller.getLibrary);
+    router.get('/asmr/library/ids', controller.getLibraryIds);
+    router.get('/asmr/library/check/:id', controller.checkLibrary);
+    router.post('/asmr/library/add', controller.addToLibrary);
+    router.post('/asmr/library/remove', controller.removeFromLibrary);
+    router.post('/asmr/library/status', controller.updateStatus);
+    router.post('/asmr/library/batch-status', controller.batchUpdateStatus);
+    router.post('/asmr/library/remove-many', controller.batchRemove);
+    router.post('/asmr/progress/remove-many', controller.batchRemoveProgress);
+    router.get('/asmr/progress/:workId', controller.getProgress);
+    router.get('/asmr/progress/:workId/latest', controller.getLatestProgress);
+    router.post('/asmr/progress', controller.saveProgress);
+    router.post('/asmr/progress/remove', controller.removeProgress);
+    router.get('/asmr/continue-listening', controller.getContinueListening);
+    router.get('/asmr/continue-listening/adult-count', controller.getAdultContinueListeningCount);
+    router.post('/asmr/continue-listening/purge-adult', controller.purgeAdultContinueListening);
+    return router;
+}

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

@@ -0,0 +1,81 @@
+import { Router } from 'express';
+import logger from '../logger.js';
+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();
+    };
+}
+export function createAsmrRouter(apiCache, getProvider) {
+    const router = 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 provider = getProvider();
+            if (!provider)
+                return res.json({ shows: [], hasNext: false });
+            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.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 provider = getProvider();
+            if (!provider) {
+                return res.json({
+                    rjCode: req.params.rj,
+                    description: '',
+                    tracks: [],
+                    images: [],
+                    chapters: [],
+                });
+            }
+            const rjCode = String(req.params.rj).trim().toUpperCase();
+            const episodes = await provider.getEpisodes(rjCode);
+            const [streams, images, chapters] = await Promise.all([
+                provider.getStreamUrls(rjCode, '1'),
+                provider.getImages(rjCode),
+                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.error({ err, rj: req.params.rj }, '[Asmr] work fetch failed');
+            res.json({ rjCode: req.params.rj, description: '', tracks: [], images: [], chapters: [] });
+        }
+    });
+    return router;
+}

package/server/dist/routes/auth.routes.js

@@ -0,0 +1,25 @@
+import { Router } from 'express';
+import { AuthController } from '../controllers/auth.controller.js';
+export function createAuthRouter(runSyncSequence) {
+    const router = Router();
+    const controller = new AuthController(runSyncSequence);
+    router.get('/config-status', controller.getConfigStatus);
+    router.get('/google-auth', controller.getGoogleAuthSettings);
+    router.post('/google-auth', controller.updateGoogleAuthSettings);
+    router.get('/github/status', controller.getGitHubAuthStatus);
+    router.post('/github/start', controller.startGitHubDeviceAuth);
+    router.get('/github/poll', controller.pollGitHubDeviceAuth);
+    router.post('/github/logout', controller.logoutGitHub);
+    router.get('/github/auth', controller.getGitHubAuthOverride);
+    router.post('/github/auth', controller.updateGitHubAuthSettings);
+    router.get('/settings/rclone', controller.getRcloneSettings);
+    router.post('/settings/rclone', controller.updateRcloneSettings);
+    router.get('/settings/sync', controller.getSyncSettings);
+    router.post('/settings/sync', controller.updateSyncProvider);
+    router.get('/google', controller.getAuthUrl);
+    router.post('/google/login', controller.loginGoogle);
+    router.get('/google/callback', controller.handleCallback);
+    router.get('/user', controller.getUserProfile);
+    router.post('/logout', controller.logout);
+    return router;
+}

package/server/dist/routes/data.routes.js

@@ -0,0 +1,47 @@
+import { Router } from 'express';
+import { DataController } from '../controllers/data.controller.js';
+function makeCacheMiddleware(cache, keyFn, ttl, validate = (d) => Array.isArray(d) && d.length > 0) {
+    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 (validate(data)) {
+                if (ttl !== undefined) {
+                    cache.set(cacheKey, data, ttl);
+                }
+                else {
+                    cache.set(cacheKey, data);
+                }
+            }
+            return originalJson(data);
+        };
+        next();
+    };
+}
+export function createDataRouter(apiCache, providers, getCatalog) {
+    const router = Router();
+    const controller = new DataController(providers, getCatalog);
+    router.get('/schedule/:date', makeCacheMiddleware(apiCache, (req) => `schedule-${req.params.date}-${req.query.format || 'TV'}`, 1800), controller.getSchedule);
+    router.get('/latest-releases', makeCacheMiddleware(apiCache, (req) => `latest-releases-${req.query.format || 'TV'}-${req.query.page || 1}-${req.query.size || 12}`, 300), controller.getLatestReleases);
+    router.get('/search', makeCacheMiddleware(apiCache, (req) => `search-${JSON.stringify(req.query)}`, 1800), controller.search);
+    router.get('/mature/search', makeCacheMiddleware(apiCache, (req) => `mature-search-${JSON.stringify(req.query)}`, 600, (d) => !!d && typeof d === 'object' && Array.isArray(d.data)), controller.matureSearch);
+    router.get('/mature/resolve', makeCacheMiddleware(apiCache, (req) => `mature-resolve-${req.query.title || ''}`, 3600), controller.resolveMature);
+    router.get('/mature/filters', controller.getMatureFilters);
+    router.post('/mature/allocate', controller.allocateTempShow);
+    router.get('/skip-times/:showId/:episodeNumber', controller.getSkipTimes);
+    router.get('/video', controller.getVideo);
+    router.get('/episodes', makeCacheMiddleware(apiCache, (req) => `episodes-${req.query.showId || ''}`, 3600), controller.getEpisodes);
+    router.get('/seasonal', makeCacheMiddleware(apiCache, (req) => `seasonal-${req.query.format || 'ALL'}-${req.query.page || 1}-${req.query.size || 14}`, 300), controller.getSeasonal);
+    router.get('/show-meta/:id', makeCacheMiddleware(apiCache, (req) => `meta-${req.params.id}`, 3600, (d) => !!d), controller.getShowMeta);
+    router.get('/popular-list', makeCacheMiddleware(apiCache, (req) => `popular-list-${req.query.sort || 'TRENDING_DESC'}-${req.query.page || 1}-${req.query.size || 20}`, 300), controller.getPopularList);
+    router.get('/trending', makeCacheMiddleware(apiCache, () => 'trending', 300), controller.getTrending);
+    router.get('/spotlight', makeCacheMiddleware(apiCache, () => 'spotlight', 300), controller.getSpotlight);
+    router.get('/home', makeCacheMiddleware(apiCache, (req) => `home-${req.query.format || 'TV'}`, 300), controller.getBatchedHome);
+    router.get('/genres-and-tags', controller.getGenresAndTags);
+    router.get('/anilist-status', controller.getAnilistStatus);
+    router.get('/system-notifications', controller.getSystemNotifications);
+    return router;
+}

package/server/dist/routes/discord-gateway.routes.js

@@ -0,0 +1,51 @@
+import { Router } from 'express';
+import logger from '../logger.js';
+import { discordGatewayService } from '../discord-gateway.js';
+import { updateEnvFile } from '../utils/env.utils.js';
+const log = logger.child({ module: 'DiscordGatewayRoutes' });
+function mask(t) {
+    if (!t)
+        return 'none';
+    return t.slice(0, 8) + '...' + t.slice(-4);
+}
+export function createDiscordGatewayRouter() {
+    const router = Router();
+    router.get('/discord/gateway/status', (_req, res) => {
+        const hasToken = discordGatewayService.hasToken();
+        res.json({
+            hasToken,
+            masked: hasToken ? mask(process.env.DISCORD_GATEWAY_TOKEN) : null,
+            enabled: discordGatewayService.serviceEnabled,
+        });
+    });
+    router.post('/discord/gateway/save', async (req, res) => {
+        let token = (req.body.token || '').trim();
+        if (token.startsWith('"') && token.endsWith('"'))
+            token = token.slice(1, -1);
+        if (token.length < 30)
+            return res.status(400).json({ error: 'Token too short' });
+        try {
+            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: token });
+            discordGatewayService.reloadToken();
+            log.info(`Discord Gateway token saved ${mask(token)} (not logged)`);
+            res.json({ ok: true, masked: mask(token) });
+        }
+        catch (e) {
+            log.error({ err: e }, 'Failed to save Discord Gateway token');
+            res.status(500).json({ error: 'Failed to save token' });
+        }
+    });
+    router.post('/discord/gateway/remove', async (_req, res) => {
+        try {
+            await updateEnvFile({ DISCORD_GATEWAY_TOKEN: '' });
+            discordGatewayService.reloadToken();
+            log.info('Discord Gateway token removed');
+            res.json({ ok: true });
+        }
+        catch (e) {
+            log.error({ err: e }, 'Failed to remove Discord Gateway token');
+            res.status(500).json({ error: 'Failed to remove token' });
+        }
+    });
+    return router;
+}

package/server/dist/routes/insights.routes.js

@@ -0,0 +1,34 @@
+import { Router } from 'express';
+import { InsightsController } from '../controllers/insights.controller.js';
+import { CONFIG } from '../config.js';
+import { getLinkedDiscordUser, setLinkedDiscordUser, syncDiscordRoles, } from '../lib/discord-roles-sync.service.js';
+export function createInsightsRouter() {
+    const router = Router();
+    const controller = new InsightsController();
+    router.get('/insights', controller.getWatchInsights);
+    router.get('/insights/genre-cards', controller.getGenreCards);
+    router.get('/insights/discord-sync-stats', controller.getDiscordSyncStats);
+    router.get('/discord-roles-config', (_req, res) => {
+        res.json({ workerUrl: CONFIG.DISCORD_ROLES_WORKER_URL || null });
+    });
+    router.get('/discord-user', async (req, res) => {
+        const user = await getLinkedDiscordUser(req.db);
+        res.json({ user });
+    });
+    router.post('/discord-user', async (req, res) => {
+        const { user } = req.body;
+        if (user !== null &&
+            user !== undefined &&
+            (typeof user !== 'object' || typeof user.id !== 'string' || !user.id)) {
+            res.status(400).json({ error: 'Invalid user payload: expected { id, ... } or null' });
+            return;
+        }
+        await setLinkedDiscordUser(req.db, user || null);
+        res.json({ success: true, user: user || null });
+    });
+    router.post('/discord-sync-now', async (req, res) => {
+        const result = await syncDiscordRoles(req.db, true);
+        res.json(result);
+    });
+    return router;
+}

package/server/dist/routes/lan-auth.routes.js

@@ -0,0 +1,46 @@
+import { Router } from 'express';
+import { hasAppPassword, verifyAppPassword, setAppPassword, createLanSession, revokeLanSession, clearAllLanSessions, isLanAuthenticated, isLoopbackRequest, buildLanCookie, clearLanCookie, getRequestToken, } from '../app-auth.js';
+export function createLanAuthRouter() {
+    const router = Router();
+    router.get('/app-status', (req, res) => {
+        res.json({
+            hasPassword: hasAppPassword(),
+            isAuthenticated: isLanAuthenticated(req),
+        });
+    });
+    router.post('/app-login', (req, res) => {
+        const password = String(req.body?.password || '');
+        if (!hasAppPassword()) {
+            return res.json({ success: true });
+        }
+        if (!password) {
+            return res.status(400).json({ error: 'Password required' });
+        }
+        if (!verifyAppPassword(password)) {
+            return res.status(401).json({ error: 'Invalid password' });
+        }
+        const session = createLanSession();
+        res.setHeader('Set-Cookie', buildLanCookie(session.token, session.expiry));
+        res.json({ success: true });
+    });
+    router.post('/app-logout', (req, res) => {
+        revokeLanSession(getRequestToken(req));
+        res.setHeader('Set-Cookie', clearLanCookie());
+        res.json({ success: true });
+    });
+    router.post('/app-setup', (req, res) => {
+        if (!isLoopbackRequest(req)) {
+            return res.status(403).json({ error: 'Forbidden' });
+        }
+        const password = String(req.body?.password || '');
+        setAppPassword(password)
+            .then(() => {
+            clearAllLanSessions();
+            res.json({ success: true, hasPassword: hasAppPassword() });
+        })
+            .catch((err) => {
+            res.status(500).json({ error: 'Failed to update password' });
+        });
+    });
+    return router;
+}

package/server/dist/routes/manga-library.routes.js

@@ -0,0 +1,23 @@
+import { Router } from 'express';
+import { MangaLibraryController } from '../controllers/manga-library.controller.js';
+export function createMangaLibraryRouter() {
+    const router = Router();
+    const controller = new MangaLibraryController();
+    router.get('/manga/library', controller.getLibrary);
+    router.get('/manga/library/ids', controller.getLibraryIds);
+    router.get('/manga/library/check/:id', controller.checkLibrary);
+    router.post('/manga/library/add', controller.addToLibrary);
+    router.post('/manga/library/remove', controller.removeFromLibrary);
+    router.post('/manga/library/status', controller.updateStatus);
+    router.post('/manga/library/batch-status', controller.batchUpdateStatus);
+    router.post('/manga/library/remove-many', controller.batchRemove);
+    router.post('/manga/progress/remove-many', controller.batchRemoveProgress);
+    router.get('/manga/progress/:mangaId', controller.getProgress);
+    router.get('/manga/progress/:mangaId/latest', controller.getLatestProgress);
+    router.post('/manga/progress', controller.saveProgress);
+    router.post('/manga/progress/remove', controller.removeProgress);
+    router.get('/manga/continue-reading', controller.getContinueReading);
+    router.get('/manga/continue-reading/adult-count', controller.getAdultContinueReadingCount);
+    router.post('/manga/continue-reading/purge-adult', controller.purgeAdultContinueReading);
+    return router;
+}

package/server/dist/routes/manga.routes.js

@@ -0,0 +1,141 @@
+import { Router } from 'express';
+import logger from '../logger.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+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();
+    };
+}
+const SAFE = ['safe'];
+function parseRatings(req) {
+    const mature = req.query.mature === '1';
+    const raw = String(req.query.rating || 'safe')
+        .split(',')
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => ['safe', 'suggestive', 'erotica', 'pornographic'].includes(s));
+    if (!mature)
+        return SAFE;
+    const exact = [...new Set(raw)];
+    return exact.length > 0 ? exact : SAFE;
+}
+export function createMangaRouter(apiCache, getProvider) {
+    const router = Router();
+    const pick = (name) => getProvider(name.toLowerCase());
+    router.get('/manga/search', makeCacheMiddleware(apiCache, (req) => `route-manga-search-${req.query.provider || ''}-${req.query.q || ''}-${req.query.page || 1}-${req.query.sort || ''}-${req.query.status || ''}-${req.query.type || ''}-${req.query.rating || ''}-${req.query.mature || ''}`, 300), async (req, res) => {
+        try {
+            const provider = req.query.provider;
+            const ratings = parseRatings(req);
+            const rawType = req.query.type || '';
+            const type = rawType === 'doujinshi' && req.query.mature !== '1' ? '' : rawType;
+            const options = {
+                query: req.query.q || '',
+                page: parseInt(req.query.page) || 1,
+                limit: Math.min(parseInt(req.query.limit) || 24, 50),
+                sort: req.query.sort || 'popular',
+                status: req.query.status || '',
+                type,
+                ratings,
+            };
+            const result = await pick(provider)?.search(options);
+            res.json(result ?? { items: [], hasNext: false });
+        }
+        catch (err) {
+            logger.error({ err }, '[Manga] search failed');
+            res.json({ items: [], hasNext: false });
+        }
+    });
+    router.get('/manga/info', makeCacheMiddleware(apiCache, (req) => `route-manga-info-${req.query.provider || ''}-${req.query.id || ''}-${req.query.rating || ''}-${req.query.mature || ''}`, 600), async (req, res) => {
+        try {
+            const provider = req.query.provider;
+            const id = String(req.query.id || '');
+            if (!id)
+                return res.status(400).json({ error: 'Missing id' });
+            const detail = await pick(provider)?.getDetail(id, parseRatings(req));
+            if (!detail)
+                return res.status(404).json({ error: 'Not found' });
+            res.json(detail);
+        }
+        catch (err) {
+            logger.error({ err }, '[Manga] info failed');
+            res.status(500).json({ error: 'Failed to load manga' });
+        }
+    });
+    router.get('/manga/chapters', makeCacheMiddleware(apiCache, (req) => `route-manga-chapters-${req.query.provider || ''}-${req.query.id || ''}-${req.query.rating || ''}-${req.query.mature || ''}`, 600), async (req, res) => {
+        try {
+            const provider = req.query.provider;
+            const id = String(req.query.id || '');
+            if (!id)
+                return res.status(400).json({ error: 'Missing id' });
+            const chapters = (await pick(provider)?.getChapters(id, parseRatings(req))) ?? [];
+            res.json({ chapters });
+        }
+        catch (err) {
+            logger.error({ err }, '[Manga] chapters failed');
+            res.json({ chapters: [] });
+        }
+    });
+    router.get('/manga/pages', makeCacheMiddleware(apiCache, (req) => `route-manga-pages-${req.query.provider || ''}-${req.query.id || ''}`, 300), async (req, res) => {
+        try {
+            const provider = req.query.provider;
+            const id = String(req.query.id || '');
+            if (!id)
+                return res.status(400).json({ error: 'Missing id' });
+            const pages = (await pick(provider)?.getPages(id)) ?? [];
+            res.json({ pages });
+        }
+        catch (err) {
+            logger.error({ err }, '[Manga] pages failed');
+            res.json({ pages: [] });
+        }
+    });
+    router.get('/manga/trending', makeCacheMiddleware(apiCache, () => 'route-manga-trending', 600), async (_req, res) => {
+        try {
+            const url = 'https://api.mangadex.org/manga?limit=6&order%5BfollowedCount%5D=desc&includes%5B%5D=cover_art&contentRating%5B%5D=safe&contentRating%5B%5D=suggestive';
+            const upstream = await fetch(url, {
+                headers: { 'User-Agent': 'dango/3.1.9' },
+            });
+            if (!upstream.ok)
+                return res.json([]);
+            const data = (await parseJsonBody(upstream));
+            const results = (data.data || []).map((m) => {
+                const title = m.attributes?.title?.en || Object.values(m.attributes?.title || {})[0] || '';
+                const desc = m.attributes?.description?.en || '';
+                const tags = (m.attributes?.tags || []).map((t) => t.attributes?.name?.en).filter(Boolean);
+                const coverArt = m.relationships?.find((r) => r.type === 'cover_art');
+                const fileName = coverArt?.attributes?.fileName;
+                const cover = fileName
+                    ? `https://uploads.mangadex.org/covers/${m.id}/${fileName}.512.jpg`
+                    : '';
+                return {
+                    id: m.id,
+                    title,
+                    description: desc,
+                    tags,
+                    year: m.attributes?.year || null,
+                    status: m.attributes?.status || null,
+                    cover,
+                };
+            });
+            res.json(results);
+        }
+        catch (err) {
+            logger.error({ err }, '[Manga] trending failed');
+            res.json([]);
+        }
+    });
+    return router;
+}

package/server/dist/routes/music.routes.js

@@ -0,0 +1,20 @@
+import { Router } from 'express';
+import { MusicController } from '../controllers/music.controller.js';
+export function createMusicRouter(apiCache) {
+    const router = Router();
+    const controller = new MusicController(apiCache);
+    router.get('/music/auth/status', controller.getAuthStatus);
+    router.post('/music/auth/start', controller.startAuth);
+    router.post('/music/auth/signout', controller.signOut);
+    router.get('/music/search', controller.search);
+    router.get('/music/stream', controller.stream);
+    router.get('/music/audio', controller.audio);
+    router.get('/music/track', controller.track);
+    router.get('/music/library', controller.library);
+    router.get('/music/playlist', controller.playlist);
+    router.get('/music/home', controller.home);
+    router.get('/music/upnext', controller.upnext);
+    router.get('/music/likes', controller.likedIds);
+    router.post('/music/like', controller.rate);
+    return router;
+}

package/server/dist/routes/providers.routes.js

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+export function createProvidersRouter(getCatalog, refresh) {
+    const router = Router();
+    router.get('/providers', (_req, res) => {
+        res.set('Cache-Control', 'public, max-age=300').json(getCatalog());
+    });
+    router.post('/providers/refresh', async (_req, res) => {
+        try {
+            const catalog = await refresh();
+            res.json(catalog);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message || 'refresh failed' });
+        }
+    });
+    return router;
+}

package/server/dist/routes/proxy.routes.js

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import { ProxyController } from '../controllers/proxy.controller.js';
+export function createProxyRouter() {
+    const router = Router();
+    const controller = new ProxyController();
+    router.get('/proxy', controller.handleProxy);
+    router.get('/embed-proxy', controller.handleEmbedProxy);
+    router.get('/subtitle-proxy', controller.handleSubtitleProxy);
+    router.get('/image-proxy', controller.handleImageProxy);
+    router.get('/resolve', controller.handleResolve);
+    return router;
+}