@serifpersia/dango 3.3.4

package/server/dist/routes/radio.routes.js

@@ -0,0 +1,138 @@
+import { Router } from 'express';
+import logger from '../logger.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+const LISTEN_MOE_STATIONS = [
+    {
+        id: 'listenmoe-jpop',
+        name: 'LISTEN.moe JPOP',
+        streamUrl: 'https://listen.moe/fallback',
+        homepage: 'https://listen.moe/',
+        tags: 'anime,j-pop,jpop',
+        codec: 'MP3',
+        source: 'listen.moe',
+        gateway: 'wss://listen.moe/gateway_v2',
+    },
+    {
+        id: 'listenmoe-kpop',
+        name: 'LISTEN.moe KPOP',
+        streamUrl: 'https://listen.moe/kpop/fallback',
+        homepage: 'https://listen.moe/',
+        tags: 'k-pop,kpop',
+        codec: 'MP3',
+        source: 'listen.moe',
+        gateway: 'wss://listen.moe/kpop/gateway_v2',
+    },
+];
+const FEATURED_STATIONS = [
+    {
+        id: 'stereo-anime',
+        name: 'stereo anime',
+        streamUrl: 'https://radio.stereoanime.com/listen/stereoanime/128',
+        tags: 'anime',
+        codec: 'MP3',
+        bitrate: 128,
+        source: 'radio-browser',
+    },
+    {
+        id: 'jpop-sakura',
+        name: 'J-Pop Sakura (asia DREAM radio)',
+        streamUrl: 'https://quincy.torontocast.com:2070/stream.mp3',
+        tags: 'j-pop,jpop',
+        codec: 'MP3',
+        bitrate: 128,
+        source: 'radio-browser',
+    },
+    {
+        id: 'n-kpop',
+        name: '0 N - K-Pop on Radio',
+        streamUrl: 'https://0n-kpop.radionetz.de/0n-kpop.mp3',
+        tags: 'k-pop,kpop',
+        codec: 'MP3',
+        bitrate: 128,
+        source: 'radio-browser',
+    },
+    {
+        id: 'bigb-kpop',
+        name: 'Big B Radio - Kpop',
+        streamUrl: 'https://antares.dribbcast.com/proxy/kpop?mp=/s',
+        tags: 'k-pop,kpop',
+        codec: 'MP3',
+        bitrate: 192,
+        source: 'radio-browser',
+    },
+];
+const RB_MIRRORS = ['https://de1.api.radio-browser.info', 'https://nl1.api.radio-browser.info'];
+async function rbFetch(path) {
+    let lastErr = null;
+    for (const base of RB_MIRRORS) {
+        try {
+            const res = await fetch(`${base}${path}`, {
+                headers: { 'User-Agent': 'dango/1.0' },
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok)
+                throw new Error(`radio-browser ${res.status}`);
+            return parseJsonBody(res);
+        }
+        catch (err) {
+            lastErr = err;
+        }
+    }
+    throw lastErr;
+}
+function toStation(s) {
+    const url = s.url_resolved || '';
+    if (!url.startsWith('https://'))
+        return null;
+    return {
+        id: s.stationuuid || url,
+        name: s.name || 'Unknown station',
+        streamUrl: url,
+        homepage: s.homepage || undefined,
+        favicon: s.favicon && s.favicon.startsWith('https://') ? s.favicon : undefined,
+        tags: s.tags || undefined,
+        codec: s.codec || undefined,
+        bitrate: s.bitrate || undefined,
+        source: 'radio-browser',
+    };
+}
+export function createRadioRouter(apiCache) {
+    const router = Router();
+    router.get('/radio/stations', async (_req, res) => {
+        try {
+            const cached = apiCache.get('route-radio-stations');
+            if (cached)
+                return res.json({ stations: cached });
+            const stations = [...LISTEN_MOE_STATIONS, ...FEATURED_STATIONS];
+            apiCache.set('route-radio-stations', stations, 3600);
+            res.json({ stations });
+        }
+        catch (err) {
+            logger.error({ err }, '[Radio] stations failed');
+            res.json({ stations: LISTEN_MOE_STATIONS });
+        }
+    });
+    router.get('/radio/search', async (req, res) => {
+        try {
+            const q = String(req.query.q || '').trim();
+            if (!q)
+                return res.json({ stations: [] });
+            const cacheKey = `route-radio-search-${q.toLowerCase()}`;
+            const cached = apiCache.get(cacheKey);
+            if (cached)
+                return res.json({ stations: cached });
+            const raw = (await rbFetch(`/json/stations/search?name=${encodeURIComponent(q)}&hidebroken=true&order=clickcount&reverse=true&limit=25`));
+            const stations = raw
+                .map(toStation)
+                .filter((s) => s !== null)
+                .slice(0, 25);
+            apiCache.set(cacheKey, stations, 300);
+            res.json({ stations });
+        }
+        catch (err) {
+            logger.error({ err }, '[Radio] search failed');
+            res.json({ stations: [] });
+        }
+    });
+    return router;
+}

package/server/dist/routes/settings.routes.js

@@ -0,0 +1,24 @@
+import { Router } from 'express';
+import { SettingsController } from '../controllers/settings.controller.js';
+import multer from 'multer';
+export function createSettingsRouter(getDb, initializeDatabase, setDb) {
+    const router = Router();
+    const controller = new SettingsController();
+    router.get('/settings', controller.getSettings);
+    router.post('/settings', controller.updateSettings);
+    router.get('/backup-db', controller.backupDatabase);
+    router.post('/database/clear', controller.clearDatabase);
+    router.get('/installation-id', controller.getInstallationId);
+    router.get('/settings/offline-db', controller.getOfflineDbInfo);
+    router.post('/settings/offline-db/update', controller.updateOfflineDb);
+    router.post('/settings/offline-db/auto-update', controller.setAutoUpdateOfflineDb);
+    const restoreStorage = multer({
+        storage: multer.memoryStorage(),
+        limits: { fileSize: 256 * 1024 * 1024 },
+    });
+    router.post('/restore-db', restoreStorage.single('dbfile'), (req, res) => controller.restoreDatabase(req, res, getDb(), initializeDatabase, setDb));
+    router.post('/import/mal-xml', multer().single('xmlfile'), controller.importMalXml);
+    router.get('/import/mal-xml/status', controller.getImportStatus);
+    router.post('/import/mal-xml/cancel', controller.cancelImport);
+    return router;
+}

package/server/dist/routes/tracker.routes.js

@@ -0,0 +1,164 @@
+import { Router } from 'express';
+import { AniListTracker } from '../lib/tracker/anilist-tracker.js';
+import { syncAniList, importFromMalUsername, importFromUsername, } from '../lib/tracker/sync.service.js';
+import { SettingsRepository } from '../repositories/settings.repository.js';
+import { performWriteTransaction } from '../sync.js';
+const TOKEN_KEY = 'tracker_anilist_token';
+const USER_KEY = 'tracker_anilist_user';
+const CLIENT_ID_KEY = 'tracker_anilist_client_id';
+export function createTrackerRouter() {
+    const router = Router();
+    router.get('/tracker/anilist/callback', (_req, res) => {
+        res.type('html').send(`<!doctype html>
+<html><head><meta charset="utf-8"><title>AniList — completing login</title></head>
+<body style="font-family:system-ui;padding:24px;background:#0b1426;color:#e5eefc"><p>Completing AniList login…</p>
+<script>
+(function(){
+  var qs = new URLSearchParams(location.search);
+  var state = qs.get('state');
+  var hash = location.hash || '';
+  var hp = new URLSearchParams(hash.slice(1));
+  if (!state) state = hp.get('state');
+  var token = hp.get('access_token');
+  var error = hp.get('error') || qs.get('error');
+  var frontend = location.origin + '/trackers';
+  if (state) {
+    try {
+      var candidate = decodeURIComponent(state);
+      if (candidate.startsWith('/') && !candidate.startsWith('//')) {
+        frontend = location.origin + candidate;
+      } else {
+        var parsed = new URL(candidate, location.origin);
+        if (parsed.origin === location.origin) {
+          frontend = parsed.href;
+        }
+      }
+    } catch(e) {}
+  }
+  if (frontend.indexOf('/api/tracker/anilist/callback') !== -1) {
+    frontend = location.origin + '/trackers';
+  }
+  if (error) {
+    location.replace(frontend + (frontend.indexOf('?') !== -1 ? '&' : '?') + 'anilist=error&reason=' + encodeURIComponent(error));
+    return;
+  }
+  if (token) {
+    location.replace(frontend + hash);
+    return;
+  }
+  var code = qs.get('code');
+  if (code) {
+    location.replace(frontend + (frontend.indexOf('?') !== -1 ? '&' : '?') + 'anilist=error&reason=code_flow_removed');
+    return;
+  }
+  location.replace(frontend + (frontend.indexOf('?') !== -1 ? '&' : '?') + 'anilist=error&reason=no_token');
+})();
+</script></body></html>`);
+    });
+    router.get('/tracker/status', async (req, res) => {
+        try {
+            const tokenRow = await SettingsRepository.getByKey(req.db, TOKEN_KEY);
+            const userRow = await SettingsRepository.getByKey(req.db, USER_KEY);
+            let user = null;
+            if (userRow?.value) {
+                try {
+                    user = JSON.parse(userRow.value);
+                }
+                catch {
+                    user = null;
+                }
+            }
+            res.json({
+                anilist: { connected: !!tokenRow?.value, user },
+            });
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to read tracker status' });
+        }
+    });
+    router.post('/tracker/anilist/auth', async (req, res) => {
+        const { token } = req.body ?? {};
+        const accessToken = typeof token === 'string' ? token.trim() : '';
+        if (!accessToken) {
+            return res.status(400).json({ error: 'Access token is required' });
+        }
+        try {
+            const tracker = new AniListTracker(accessToken);
+            const viewer = await tracker.getViewer();
+            await performWriteTransaction(req.db, (tx) => {
+                SettingsRepository.upsert(tx, TOKEN_KEY, accessToken);
+                SettingsRepository.upsert(tx, USER_KEY, JSON.stringify(viewer));
+            });
+            res.json({ success: true, user: viewer });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Authentication failed';
+            res.status(401).json({ error: message });
+        }
+    });
+    router.post('/tracker/anilist/disconnect', async (req, res) => {
+        try {
+            await performWriteTransaction(req.db, (tx) => {
+                SettingsRepository.upsert(tx, TOKEN_KEY, '');
+                SettingsRepository.upsert(tx, USER_KEY, '');
+            });
+            res.json({ success: true });
+        }
+        catch {
+            res.status(500).json({ error: 'Failed to disconnect' });
+        }
+    });
+    router.post('/tracker/sync', async (req, res) => {
+        const { provider = 'anilist' } = req.body ?? {};
+        if (provider !== 'anilist') {
+            return res.status(400).json({ error: `Provider "${provider}" is not supported yet` });
+        }
+        try {
+            const summary = await syncAniList(req.db);
+            res.json({ success: true, summary });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Sync failed';
+            res.status(500).json({ error: message });
+        }
+    });
+    router.post('/tracker/anilist/import', async (req, res) => {
+        const { username, erase } = req.body ?? {};
+        if (!username || typeof username !== 'string') {
+            return res.status(400).json({ error: 'Username is required' });
+        }
+        try {
+            const count = await importFromUsername(req.db, username.trim(), erase === true);
+            res.json({ success: true, count });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Import failed';
+            res.status(500).json({ error: message });
+        }
+    });
+    router.post('/tracker/mal/import', async (req, res) => {
+        const { username, erase, useOfflineDb, skipFallback } = req.body ?? {};
+        if (!username || typeof username !== 'string') {
+            return res.status(400).json({ error: 'MAL username is required' });
+        }
+        try {
+            const count = await importFromMalUsername(req.db, username.trim(), {
+                erase: erase === true,
+                useOfflineDb: useOfflineDb !== false,
+                skipFallback: skipFallback === true,
+            });
+            res.json({ success: true, count });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Import failed';
+            if (message.includes('private') || message.includes('not found')) {
+                return res.status(404).json({ error: message });
+            }
+            if (message.includes('blocked') || message.includes('HTTP 429')) {
+                return res.status(429).json({ error: message });
+            }
+            res.status(500).json({ error: message });
+        }
+    });
+    return router;
+}

package/server/dist/routes/translate.routes.js

@@ -0,0 +1,88 @@
+import { Router } from 'express';
+import { AppCache } from '../utils/cache.utils.js';
+import { parseJsonBody } from '../utils/http.utils.js';
+const cache = new AppCache({
+    ttlSeconds: 7 * 24 * 60 * 60,
+    maxKeys: 5000,
+});
+function toTitleCase(s) {
+    return s
+        .split(' ')
+        .map((w, i) => {
+        if (i !== 0 &&
+            ['x', 'and', 'or', 'the', 'a', 'an', 'of', 'in', 'on', 'with'].includes(w.toLowerCase())) {
+            return w.toLowerCase();
+        }
+        return w.charAt(0).toUpperCase() + w.slice(1);
+    })
+        .join(' ')
+        .replace(/\bX\b/g, 'x');
+}
+function normalize(s) {
+    const t = s.trim();
+    if (!t)
+        return t;
+    return toTitleCase(t);
+}
+export function createTranslateRouter() {
+    const router = Router();
+    router.post('/translate', async (req, res) => {
+        const { texts, source = 'ja', target = 'en' } = req.body ?? {};
+        if (!Array.isArray(texts) || texts.length === 0) {
+            return res.json({ translations: {} });
+        }
+        const jobs = texts.map((t) => String(t).trim()).filter(Boolean);
+        const result = {};
+        const toFetch = [];
+        for (const t of jobs) {
+            const key = `${source}:${target}:${t}`;
+            const cached = cache.get(key);
+            if (cached)
+                result[t] = cached;
+            else
+                toFetch.push(t);
+        }
+        if (toFetch.length > 0) {
+            const chunks = [];
+            for (let i = 0; i < toFetch.length; i += 15)
+                chunks.push(toFetch.slice(i, i + 15));
+            for (const chunk of chunks) {
+                const q = chunk.join('\n');
+                const url = `https://clients5.google.com/translate_a/t?client=dict-chrome-ex&sl=${encodeURIComponent(source)}&tl=${encodeURIComponent(target)}&dt=t&q=${encodeURIComponent(q)}`;
+                try {
+                    const r = await fetch(url, {
+                        headers: { 'User-Agent': 'Mozilla/5.0' },
+                        signal: AbortSignal.timeout(5000),
+                    });
+                    if (!r.ok)
+                        throw new Error(`translate ${r.status}`);
+                    const data = (await parseJsonBody(r));
+                    let translated = '';
+                    if (Array.isArray(data) && typeof data[0] === 'string') {
+                        translated = data[0];
+                    }
+                    else if (Array.isArray(data) && Array.isArray(data[0])) {
+                        const outer = data;
+                        translated = outer[0]?.map((p) => p[0]).join('') || '';
+                    }
+                    const parts = translated.split('\n');
+                    chunk.forEach((orig, i) => {
+                        const trans = (parts[i] ?? '').trim();
+                        const norm = trans ? normalize(trans) : orig;
+                        result[orig] = norm;
+                        cache.set(`${source}:${target}:${orig}`, norm);
+                    });
+                }
+                catch {
+                    for (const orig of chunk) {
+                        if (!result[orig])
+                            result[orig] = orig;
+                    }
+                }
+                await new Promise((r) => setTimeout(r, 80));
+            }
+        }
+        res.json({ translations: result });
+    });
+    return router;
+}

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

@@ -0,0 +1,23 @@
+import { Router } from 'express';
+import { TvLibraryController } from '../controllers/tv-library.controller.js';
+export function createTvLibraryRouter() {
+    const router = Router();
+    const controller = new TvLibraryController();
+    router.get('/tv/library', controller.getLibrary);
+    router.get('/tv/library/ids', controller.getLibraryIds);
+    router.get('/tv/library/check/:id', controller.checkLibrary);
+    router.post('/tv/library/add', controller.addToLibrary);
+    router.post('/tv/library/remove', controller.removeFromLibrary);
+    router.post('/tv/library/status', controller.updateStatus);
+    router.post('/tv/library/batch-status', controller.batchUpdateStatus);
+    router.post('/tv/library/remove-many', controller.batchRemove);
+    router.post('/tv/progress/remove-many', controller.batchRemoveProgress);
+    router.get('/tv/progress/:mediaId', controller.getProgress);
+    router.get('/tv/progress/:mediaId/latest', controller.getLatestProgress);
+    router.post('/tv/progress', controller.saveProgress);
+    router.post('/tv/progress/remove', controller.removeProgress);
+    router.get('/tv/continue-watching', controller.getContinueWatching);
+    router.get('/tv/continue-watching/adult-count', controller.getAdultContinueWatchingCount);
+    router.post('/tv/continue-watching/purge-adult', controller.purgeAdultContinueWatching);
+    return router;
+}