@serifpersia/dango 3.0.3

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthRouter = createAuthRouter;
+const express_1 = require("express");
+const auth_controller_1 = require("../controllers/auth.controller");
+function createAuthRouter(runSyncSequence) {
+    const router = (0, express_1.Router)();
+    const controller = new auth_controller_1.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,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataRouter = createDataRouter;
+const express_1 = require("express");
+const data_controller_1 = require("../controllers/data.controller");
+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();
+    };
+}
+function createDataRouter(apiCache, providers) {
+    const router = (0, express_1.Router)();
+    const controller = new data_controller_1.DataController(providers);
+    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,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiscordGatewayRouter = createDiscordGatewayRouter;
+const express_1 = require("express");
+const logger_1 = __importDefault(require("../logger"));
+const discord_gateway_1 = require("../discord-gateway");
+const env_utils_1 = require("../utils/env.utils");
+const log = logger_1.default.child({ module: 'DiscordGatewayRoutes' });
+function mask(t) {
+    if (!t)
+        return 'none';
+    return t.slice(0, 8) + '...' + t.slice(-4);
+}
+function createDiscordGatewayRouter() {
+    const router = (0, express_1.Router)();
+    router.get('/discord/gateway/status', (_req, res) => {
+        const hasToken = discord_gateway_1.discordGatewayService.hasToken();
+        res.json({
+            hasToken,
+            masked: hasToken ? mask(process.env.DISCORD_GATEWAY_TOKEN) : null,
+            enabled: discord_gateway_1.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 (0, env_utils_1.updateEnvFile)({ DISCORD_GATEWAY_TOKEN: token });
+            discord_gateway_1.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 (0, env_utils_1.updateEnvFile)({ DISCORD_GATEWAY_TOKEN: '' });
+            discord_gateway_1.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,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInsightsRouter = createInsightsRouter;
+const express_1 = require("express");
+const insights_controller_1 = require("../controllers/insights.controller");
+function createInsightsRouter() {
+    const router = (0, express_1.Router)();
+    const controller = new insights_controller_1.InsightsController();
+    router.get('/insights', controller.getWatchInsights);
+    router.get('/insights/genre-cards', controller.getGenreCards);
+    return router;
+}

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

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

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

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMangaRouter = createMangaRouter;
+const express_1 = require("express");
+const logger_1 = __importDefault(require("../logger"));
+const mangadex_provider_1 = require("../providers/manga/mangadex.provider");
+const mangapill_provider_1 = require("../providers/manga/mangapill.provider");
+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;
+}
+function createMangaRouter(apiCache) {
+    const router = (0, express_1.Router)();
+    const dex = new mangadex_provider_1.MangaDexProvider(apiCache);
+    const pill = new mangapill_provider_1.MangaPillProvider(apiCache);
+    const pick = (name) => (name === 'mangapill' ? pill : dex);
+    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);
+        }
+        catch (err) {
+            logger_1.default.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_1.default.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_1.default.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_1.default.error({ err }, '[Manga] pages failed');
+            res.json({ pages: [] });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProxyRouter = createProxyRouter;
+const express_1 = require("express");
+const proxy_controller_1 = require("../controllers/proxy.controller");
+function createProxyRouter() {
+    const router = (0, express_1.Router)();
+    const controller = new proxy_controller_1.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;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRadioRouter = createRadioRouter;
+const express_1 = require("express");
+const logger_1 = __importDefault(require("../logger"));
+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 (await res.json());
+        }
+        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',
+    };
+}
+function createRadioRouter(apiCache) {
+    const router = (0, express_1.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_1.default.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_1.default.error({ err }, '[Radio] search failed');
+            res.json({ stations: [] });
+        }
+    });
+    return router;
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSettingsRouter = createSettingsRouter;
+const express_1 = require("express");
+const settings_controller_1 = require("../controllers/settings.controller");
+const multer_1 = __importDefault(require("multer"));
+const config_1 = require("../config");
+function createSettingsRouter(getDb, initializeDatabase, setDb) {
+    const router = (0, express_1.Router)();
+    const controller = new settings_controller_1.SettingsController();
+    router.get('/settings', controller.getSettings);
+    router.post('/settings', controller.updateSettings);
+    router.get('/backup-db', controller.backupDatabase);
+    router.get('/installation-id', controller.getInstallationId);
+    const restoreStorage = (0, multer_1.default)({
+        storage: multer_1.default.diskStorage({
+            destination: (_req, _f, cb) => cb(null, config_1.CONFIG.ROOT),
+            filename: (_r, _f, cb) => cb(null, `restore_temp.db`),
+        }),
+    });
+    router.post('/restore-db', restoreStorage.single('dbfile'), (req, res) => controller.restoreDatabase(req, res, getDb(), initializeDatabase, setDb));
+    router.post('/import/mal-xml', (0, multer_1.default)().single('xmlfile'), controller.importMalXml);
+    return router;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrackerRouter = createTrackerRouter;
+const express_1 = require("express");
+const anilist_tracker_1 = require("../lib/tracker/anilist-tracker");
+const sync_service_1 = require("../lib/tracker/sync.service");
+const settings_repository_1 = require("../repositories/settings.repository");
+const sync_1 = require("../sync");
+const TOKEN_KEY = 'tracker_anilist_token';
+const USER_KEY = 'tracker_anilist_user';
+const CLIENT_ID_KEY = 'tracker_anilist_client_id';
+function createTrackerRouter() {
+    const router = (0, express_1.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 settings_repository_1.SettingsRepository.getByKey(req.db, TOKEN_KEY);
+            const userRow = await settings_repository_1.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 anilist_tracker_1.AniListTracker(accessToken);
+            const viewer = await tracker.getViewer();
+            await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                settings_repository_1.SettingsRepository.upsert(tx, TOKEN_KEY, accessToken);
+                settings_repository_1.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 (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                settings_repository_1.SettingsRepository.upsert(tx, TOKEN_KEY, '');
+                settings_repository_1.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 (0, sync_service_1.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 } = req.body ?? {};
+        if (!username || typeof username !== 'string') {
+            return res.status(400).json({ error: 'Username is required' });
+        }
+        try {
+            const count = await (0, sync_service_1.importFromUsername)(req.db, username.trim());
+            res.json({ success: true, count });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Import failed';
+            res.status(500).json({ error: message });
+        }
+    });
+    return router;
+}