@serifpersia/dango 3.0.3

package/server/dist/routes/watchlist.routes.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWatchlistRouter = createWatchlistRouter;
+const express_1 = require("express");
+const watchlist_controller_1 = require("../controllers/watchlist.controller");
+const discord_rpc_1 = require("../discord-rpc");
+const title_matching_1 = require("../providers/title-matching");
+const dlsitePosterCache = new Map();
+const mangadexCoverCache = new Map();
+async function getMangadexCover(title) {
+    const key = title.trim().toLowerCase();
+    if (!key)
+        return null;
+    const cached = mangadexCoverCache.get(key);
+    if (cached && Date.now() - cached.ts < 3600_000)
+        return cached.url;
+    try {
+        const params = new URLSearchParams({
+            title: title.trim(),
+            limit: '5',
+            'includes[]': 'cover_art',
+            'order[relevance]': 'desc',
+        });
+        for (const r of ['safe', 'suggestive', 'erotica', 'pornographic']) {
+            params.append('contentRating[]', r);
+        }
+        const res = await fetch(`https://api.mangadex.org/manga?${params.toString()}`, {
+            headers: { 'User-Agent': 'Dango/3.0', Accept: 'application/json' },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        const candidates = [];
+        for (const m of data.data || []) {
+            const fileName = m.relationships?.find((r) => r.type === 'cover_art')?.attributes?.fileName;
+            if (!fileName)
+                continue;
+            const cover = `https://uploads.mangadex.org/covers/${m.id}/${fileName}.256.jpg`;
+            const main = m.attributes?.title;
+            const mainTitle = main?.en || main?.['ja-ro'] || Object.values(main || {})[0];
+            if (mainTitle)
+                candidates.push({ title: mainTitle, cover });
+            for (const alt of m.attributes?.altTitles || []) {
+                const t = Object.values(alt)[0];
+                if (t)
+                    candidates.push({ title: t, cover });
+            }
+        }
+        const match = (0, title_matching_1.pickBestMatch)(candidates, [title]);
+        const url = match ? match.item.cover : null;
+        mangadexCoverCache.set(key, { url, ts: Date.now() });
+        return url;
+    }
+    catch {
+        return null;
+    }
+}
+async function getDlsitePoster(rjCode) {
+    const key = String(rjCode).trim().toUpperCase();
+    if (!/^RJ\d{5,}$/.test(key))
+        return null;
+    const cached = dlsitePosterCache.get(key);
+    if (cached && Date.now() - cached.ts < 3600_000)
+        return cached.url;
+    try {
+        const res = await fetch(`https://www.dlsite.com/maniax/product/info/ajax?product_id=${key}`, {
+            headers: { 'User-Agent': 'Mozilla/5.0', Accept: 'application/json' },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        const raw = (await res.json());
+        const data = raw;
+        const entryRaw = (data[key] ?? data);
+        const entry = entryRaw;
+        const img = typeof entry?.work_image === 'string' ? entry.work_image : undefined;
+        if (!img)
+            return null;
+        const url = img.startsWith('//') ? `https:${img}` : img;
+        dlsitePosterCache.set(key, { url, ts: Date.now() });
+        return url;
+    }
+    catch {
+        return null;
+    }
+}
+function createWatchlistRouter(getDb) {
+    const router = (0, express_1.Router)();
+    const controller = new watchlist_controller_1.WatchlistController();
+    controller.startNotificationDiscovery(getDb);
+    router.get('/continue-watching/all', controller.getAllContinueWatching);
+    router.get('/continue-watching/this-week', controller.getThisWeekSchedule);
+    router.post('/continue-watching/remove', controller.removeContinueWatching);
+    router.post('/continue-watching/remove-many', controller.batchRemoveContinueWatching);
+    router.get('/continue-watching/adult-count', controller.getAdultContinueWatchingCount);
+    router.post('/continue-watching/purge-adult', controller.purgeAdultContinueWatching);
+    router.post('/update-progress', controller.updateProgress);
+    router.get('/watchlist', controller.getWatchlist);
+    router.get('/watchlist/check/:showId', controller.checkWatchlist);
+    router.post('/watchlist/add', controller.addToWatchlist);
+    router.post('/watchlist/remove', controller.removeFromWatchlist);
+    router.post('/watchlist/remove-many', controller.batchRemoveFromWatchlist);
+    router.post('/watchlist/status', controller.updateWatchlistStatus);
+    router.post('/watchlist/batch-status', controller.batchUpdateWatchlistStatus);
+    router.get('/queue', controller.getQueue);
+    router.get('/queue/suggested/:showId', controller.getSuggestedQueueEpisode);
+    router.get('/queue/remaining/:showId', controller.getQueueRemainingEpisodes);
+    router.post('/queue/add', controller.addToQueue);
+    router.post('/queue/batch', controller.addToQueueBatch);
+    router.post('/queue/remove', controller.removeFromQueue);
+    router.post('/queue/remove-many', controller.removeFromQueueBatch);
+    router.post('/queue/clear', controller.clearQueue);
+    router.post('/queue/reorder', controller.reorderQueue);
+    router.get('/episode-progress/:showId/:episodeNumber', controller.getEpisodeProgress);
+    router.get('/watched-episodes/:showId', controller.getWatchedEpisodes);
+    router.get('/notifications', controller.getNotifications);
+    router.post('/notifications/dismiss', controller.dismissNotification);
+    router.post('/notifications/clear-all', controller.clearAllNotifications);
+    router.get('/discovery/status', (req, res) => {
+        res.json(controller.getDiscoveryStatus());
+    });
+    router.post('/discovery/nudge', (req, res) => {
+        const started = controller.triggerDiscovery?.(false) ?? false;
+        res.json({ success: true, started, ...controller.getDiscoveryStatus() });
+    });
+    router.post('/discovery/refresh', (req, res) => {
+        const started = controller.triggerDiscovery?.(true) ?? false;
+        res.json({ success: true, started, ...controller.getDiscoveryStatus() });
+    });
+    router.post('/discord/clear', (req, res) => {
+        const { sessionId } = req.body;
+        if (!discord_rpc_1.discordRPCService.isServiceEnabled) {
+            return res.json({ success: true });
+        }
+        discord_rpc_1.discordRPCService.clearPresence(sessionId);
+        res.json({ success: true });
+    });
+    router.post('/discord/heartbeat', (req, res) => {
+        const { sessionId, bye } = req.body ?? {};
+        if (typeof sessionId !== 'string' || !discord_rpc_1.discordRPCService.isServiceEnabled) {
+            return res.json({ success: true });
+        }
+        if (bye) {
+            discord_rpc_1.discordRPCService.removeHeartbeat(sessionId);
+        }
+        else {
+            discord_rpc_1.discordRPCService.heartbeat(sessionId);
+        }
+        res.json({ success: true });
+    });
+    router.post('/discord/status', (req, res) => {
+        const { page } = req.body;
+        if (typeof page !== 'string' || !discord_rpc_1.discordRPCService.isServiceEnabled) {
+            return res.json({ success: true });
+        }
+        discord_rpc_1.discordRPCService.setIdleStatus(page);
+        res.json({ success: true });
+    });
+    router.post('/discord/asmr', async (req, res) => {
+        const { title, trackLabel, isPlaying, thumbnail, thumbnails, currentTime, duration, isAdult, sessionId, rjCode, } = req.body ?? {};
+        if (!discord_rpc_1.discordRPCService.isServiceEnabled)
+            return res.json({ success: true });
+        if (typeof sessionId === 'string')
+            discord_rpc_1.discordRPCService.heartbeat(sessionId);
+        let thumb = String(thumbnail || '');
+        const thumbs = Array.isArray(thumbnails) ? thumbnails.map(String).filter(Boolean) : undefined;
+        // ASMR thumbs from japaneseasmr/weeabo0 require Referer and will 403 on Discord's fetch.
+        // Try DLSite's direct img.dlsite.jp poster which is public (no Referer needed).
+        const needsDlsite = !thumb || thumb.includes('weeabo0.xyz') || thumb.includes('japaneseasmr.com');
+        if (needsDlsite && rjCode) {
+            const dlsiteThumb = await getDlsitePoster(String(rjCode));
+            if (dlsiteThumb)
+                thumb = dlsiteThumb;
+        }
+        // fallback to logo if still proxied/weeabo0 (Discord can't fetch localhost or 403)
+        if (thumb.includes('/api/image-proxy') || thumb.includes('weeabo0.xyz'))
+            thumb = '';
+        discord_rpc_1.discordRPCService.updatePresence({
+            title: String(title || 'ASMR').slice(0, 128),
+            episode: String(trackLabel || '').slice(0, 64),
+            totalEpisodes: '',
+            currentTime: Number(currentTime) || 0,
+            duration: Number(duration) || 0,
+            thumbnail: thumb,
+            thumbnails: thumbs,
+            isPlaying: !!isPlaying,
+            providerName: 'ASMR',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: !!isAdult,
+        });
+        res.json({ success: true });
+    });
+    router.post('/discord/radio', (req, res) => {
+        const { title, stationLabel, isPlaying, thumbnail, currentTime, sessionId } = req.body ?? {};
+        if (!discord_rpc_1.discordRPCService.isServiceEnabled)
+            return res.json({ success: true });
+        if (typeof sessionId === 'string')
+            discord_rpc_1.discordRPCService.heartbeat(sessionId);
+        let thumb = String(thumbnail || '');
+        if (thumb.includes('/api/image-proxy')) {
+            const match = thumb.match(/url=([^&]+)/);
+            if (match)
+                thumb = decodeURIComponent(match[1]);
+        }
+        if (thumb && !thumb.startsWith('https://'))
+            thumb = '';
+        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+            thumb = '';
+        discord_rpc_1.discordRPCService.updatePresence({
+            title: String(title || 'Radio').slice(0, 128),
+            episode: String(stationLabel || '').slice(0, 64),
+            totalEpisodes: '',
+            stateLine: String(stationLabel || 'Radio').slice(0, 64),
+            currentTime: Number(currentTime) || 0,
+            duration: 0,
+            thumbnail: thumb,
+            isPlaying: !!isPlaying,
+            providerName: 'Radio',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: false,
+        });
+        res.json({ success: true });
+    });
+    router.post('/discord/manga', async (req, res) => {
+        const { title, chapterLabel, isPlaying, thumbnail, thumbnails, sessionId, isAdult } = req.body ?? {};
+        if (!discord_rpc_1.discordRPCService.isServiceEnabled)
+            return res.json({ success: true });
+        if (typeof sessionId === 'string')
+            discord_rpc_1.discordRPCService.heartbeat(sessionId);
+        const cleanThumb = (value) => {
+            let thumb = String(value || '');
+            if (thumb.includes('/api/proxy') || thumb.includes('/api/image-proxy')) {
+                const match = thumb.match(/url=([^&]+)/);
+                if (match) {
+                    try {
+                        thumb = decodeURIComponent(match[1]);
+                    }
+                    catch {
+                        return '';
+                    }
+                }
+            }
+            if (!thumb.startsWith('https://'))
+                return '';
+            if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+                return '';
+            if (thumb.includes('readdetectiveconan.com'))
+                return '';
+            return thumb;
+        };
+        let thumb = cleanThumb(thumbnail);
+        let thumbs = Array.isArray(thumbnails)
+            ? thumbnails.map(cleanThumb).filter(Boolean)
+            : undefined;
+        if (!thumb && title) {
+            const fallback = await getMangadexCover(String(title));
+            if (fallback) {
+                thumb = fallback;
+                thumbs = [fallback, ...(thumbs || [])];
+            }
+        }
+        discord_rpc_1.discordRPCService.updatePresence({
+            title: String(title || 'Manga').slice(0, 128),
+            episode: String(chapterLabel || '').slice(0, 64),
+            totalEpisodes: '',
+            stateLine: (chapterLabel ? `Reading ${chapterLabel}` : 'Reading').slice(0, 64),
+            currentTime: 0,
+            duration: 0,
+            thumbnail: thumb,
+            thumbnails: thumbs,
+            isPlaying: isPlaying !== false,
+            providerName: 'Manga',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: isAdult === true,
+        });
+        res.json({ success: true });
+    });
+    router.post('/discord/tv', (req, res) => {
+        const { title, episodeLabel, isPlaying, thumbnail, currentTime, duration, sessionId, isAdult } = req.body ?? {};
+        if (!discord_rpc_1.discordRPCService.isServiceEnabled)
+            return res.json({ success: true });
+        if (typeof sessionId === 'string')
+            discord_rpc_1.discordRPCService.heartbeat(sessionId);
+        let thumb = String(thumbnail || '');
+        if (thumb.includes('/api/image-proxy')) {
+            const match = thumb.match(/url=([^&]+)/);
+            if (match)
+                thumb = decodeURIComponent(match[1]);
+        }
+        if (thumb.includes('localhost') || thumb.includes('127.0.0.1'))
+            thumb = '';
+        discord_rpc_1.discordRPCService.updatePresence({
+            title: String(title || 'TV').slice(0, 128),
+            episode: String(episodeLabel || '').slice(0, 64),
+            totalEpisodes: '',
+            stateLine: String(episodeLabel || 'Movie').slice(0, 64),
+            currentTime: Number(currentTime) || 0,
+            duration: Number(duration) || 0,
+            thumbnail: thumb,
+            isPlaying: !!isPlaying,
+            providerName: 'TV',
+            sessionId: typeof sessionId === 'string' ? sessionId : undefined,
+            isAdult: isAdult === true,
+        });
+        res.json({ success: true });
+    });
+    return {
+        router,
+        stopDiscovery: () => controller.stopNotificationDiscovery(),
+    };
+}

package/server/dist/server.js

@@ -0,0 +1,310 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+process.setMaxListeners(100);
+const events_1 = require("events");
+events_1.EventEmitter.defaultMaxListeners = 100;
+const express_1 = __importDefault(require("express"));
+const path_1 = __importDefault(require("path"));
+const cors_1 = __importDefault(require("cors"));
+const compression_1 = __importDefault(require("compression"));
+const node_cache_1 = __importDefault(require("node-cache"));
+const fs_1 = __importDefault(require("fs"));
+const crypto_1 = __importDefault(require("crypto"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const logger_1 = __importDefault(require("./logger"));
+const ipc_1 = require("./lib/ipc");
+const security_utils_1 = require("./utils/security.utils");
+const _123anime_provider_1 = require("./providers/123anime.provider");
+const animeya_provider_1 = require("./providers/animeya.provider");
+const megaplay_provider_1 = require("./providers/megaplay.provider");
+const animepahe_provider_1 = require("./providers/animepahe.provider");
+const wh_provider_1 = require("./providers/wh.provider");
+const hn_provider_1 = require("./providers/hn.provider");
+const anilight_provider_1 = require("./providers/anilight.provider");
+const kaa_provider_1 = require("./providers/kaa.provider");
+const ht_provider_1 = require("./providers/ht.provider");
+const jasmr_provider_1 = require("./providers/jasmr.provider");
+const op_provider_1 = require("./providers/op.provider");
+const github_sync_1 = require("./github-sync");
+const config_1 = require("./config");
+const sync_1 = require("./sync");
+const auth_routes_1 = require("./routes/auth.routes");
+const lan_auth_routes_1 = require("./routes/lan-auth.routes");
+const app_auth_1 = require("./app-auth");
+const watchlist_routes_1 = require("./routes/watchlist.routes");
+const data_routes_1 = require("./routes/data.routes");
+const asmr_routes_1 = require("./routes/asmr.routes");
+const manga_routes_1 = require("./routes/manga.routes");
+const radio_routes_1 = require("./routes/radio.routes");
+const tv_routes_1 = require("./routes/tv.routes");
+const proxy_routes_1 = require("./routes/proxy.routes");
+const settings_routes_1 = require("./routes/settings.routes");
+const insights_routes_1 = require("./routes/insights.routes");
+const translate_routes_1 = require("./routes/translate.routes");
+const discord_gateway_routes_1 = require("./routes/discord-gateway.routes");
+const tracker_routes_1 = require("./routes/tracker.routes");
+const discord_rpc_1 = require("./discord-rpc");
+const discord_gateway_1 = require("./discord-gateway");
+const settings_repository_1 = require("./repositories/settings.repository");
+const request_context_1 = require("./utils/request-context");
+const anilist_1 = require("./lib/anilist");
+const app = (0, express_1.default)();
+app.use((req, res, next) => {
+    const store = new Map();
+    if (req.headers['x-animepahe-ua']) {
+        store.set('ua', req.headers['x-animepahe-ua']);
+    }
+    if (req.headers['x-animepahe-cookie']) {
+        store.set('cookie', req.headers['x-animepahe-cookie']);
+    }
+    if (req.headers['x-jasmr-ua']) {
+        store.set('jasmr_ua', req.headers['x-jasmr-ua']);
+    }
+    if (req.headers['x-jasmr-cookie']) {
+        store.set('jasmr_cookie', req.headers['x-jasmr-cookie']);
+    }
+    request_context_1.requestContext.run(store, next);
+});
+const apiCache = new node_cache_1.default({ stdTTL: 3600 });
+const _123AnimeProvider = new _123anime_provider_1._123AnimeProvider(apiCache);
+const animeyaProvider = new animeya_provider_1.AnimeyaProvider(apiCache);
+const megaPlayProvider = new megaplay_provider_1.MegaPlayProvider(apiCache);
+const animepaheProvider = new animepahe_provider_1.AnimePaheProvider(apiCache);
+const whProvider = new wh_provider_1.WhProvider(apiCache);
+const hnProvider = new hn_provider_1.HnProvider();
+const anilightProvider = new anilight_provider_1.AnilightProvider(apiCache);
+const kaaProvider = new kaa_provider_1.KaaProvider(apiCache);
+const htProvider = new ht_provider_1.HtProvider(apiCache);
+const jasmrProvider = new jasmr_provider_1.JasmrProvider(apiCache);
+const opProvider = new op_provider_1.OpProvider(apiCache);
+const providers = {
+    '123anime': _123AnimeProvider,
+    animeya: animeyaProvider,
+    megaplay: megaPlayProvider,
+    animepahe: animepaheProvider,
+    wh: whProvider,
+    hn: hnProvider,
+    anilight: anilightProvider,
+    kaa: kaaProvider,
+    ht: htProvider,
+    jasmr: jasmrProvider,
+    op: opProvider,
+};
+let db;
+let isShuttingDown = false;
+async function runSyncSequence(database, preferredProvider) {
+    const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+    const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+    const remoteFolder = config_1.CONFIG.IS_DEV ? config_1.CONFIG.REMOTE_FOLDER_DEV : config_1.CONFIG.REMOTE_FOLDER_PROD;
+    await (0, sync_1.initSyncProvider)(preferredProvider);
+    if ((0, sync_1.getActiveProvider)() === 'github' && github_sync_1.githubSyncService.isAuthenticated()) {
+        try {
+            await github_sync_1.githubSyncService.migrateFromAniWebSync();
+        }
+        catch (err) {
+            logger_1.default.error({ err }, 'GitHub sync migration from ani-web failed');
+        }
+    }
+    const didDownload = await (0, sync_1.syncDownOnBoot)(database, dbPath, remoteFolder, () => {
+        return new Promise((resolve) => {
+            if (database && !database.isClosedCheck()) {
+                database.checkpoint();
+                database.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    let currentDb = database;
+    if (didDownload) {
+        db = await (0, sync_1.initializeDatabase)(dbPath);
+        currentDb = db;
+        logger_1.default.info('Database re-initialized after sync.');
+    }
+    try {
+        await (0, sync_1.syncUp)(currentDb, dbPath, remoteFolder);
+    }
+    catch (err) {
+        logger_1.default.error({ err }, 'Sync up on boot failed');
+    }
+}
+app.use((req, res, next) => {
+    if (isShuttingDown) {
+        return res.status(503).send('Server is shutting down...');
+    }
+    if (!db) {
+        return res.status(503).send('Database initializing...');
+    }
+    req.db = db;
+    next();
+});
+app.use((0, compression_1.default)({
+    level: 2,
+    threshold: 1024,
+    filter: (req, res) => {
+        if (req.headers['x-no-compression']) {
+            return false;
+        }
+        return compression_1.default.filter(req, res);
+    },
+}));
+app.use((0, cors_1.default)({
+    origin: (origin, callback) => {
+        callback(null, (0, security_utils_1.isAllowedOrigin)(origin));
+    },
+    credentials: true,
+}));
+app.use(security_utils_1.crossSiteProtectionMiddleware);
+app.use(express_1.default.json({ limit: '10mb' }));
+app.use('/api/auth', (0, lan_auth_routes_1.createLanAuthRouter)());
+app.use(app_auth_1.lanAuthMiddleware);
+app.use('/api/auth', (0, auth_routes_1.createAuthRouter)((database) => runSyncSequence(database)));
+const { router: watchlistRouter, stopDiscovery } = (0, watchlist_routes_1.createWatchlistRouter)(() => db);
+app.use('/api', watchlistRouter);
+app.use('/api', (0, data_routes_1.createDataRouter)(apiCache, providers));
+app.use('/api', (0, asmr_routes_1.createAsmrRouter)(apiCache, jasmrProvider));
+app.use('/api', (0, manga_routes_1.createMangaRouter)(apiCache));
+app.use('/api', (0, radio_routes_1.createRadioRouter)(apiCache));
+app.use('/api', (0, tv_routes_1.createTvRouter)(apiCache));
+app.use('/api', (0, proxy_routes_1.createProxyRouter)());
+app.use('/api', (0, insights_routes_1.createInsightsRouter)());
+app.use('/api', (0, translate_routes_1.createTranslateRouter)());
+app.use('/api', (0, discord_gateway_routes_1.createDiscordGatewayRouter)());
+app.use('/api', (0, tracker_routes_1.createTrackerRouter)());
+app.use('/api', (0, settings_routes_1.createSettingsRouter)(() => db, sync_1.initializeDatabase, (newDb) => {
+    db = newDb;
+}));
+if (!config_1.CONFIG.IS_DEV) {
+    const frontendPath = path_1.default.join(config_1.CONFIG.PACKAGE_ROOT, 'client', 'dist');
+    logger_1.default.info(`Serving frontend from: ${frontendPath}`);
+    app.use(express_1.default.static(frontendPath));
+    app.get(/^(?!\/api).+/, (req, res) => {
+        res.sendFile('index.html', { root: frontendPath }, (err) => {
+            if (err) {
+                logger_1.default.error({ err }, `Failed to serve index.html from ${frontendPath}`);
+                if (!res.headersSent) {
+                    res.status(500).send('Server Error: Frontend build not found.');
+                }
+            }
+        });
+    });
+}
+app.use((err, req, res, next) => {
+    if (err instanceof SyntaxError &&
+        'body' in err &&
+        req.headers['content-type']?.includes('application/json')) {
+        if (!res.headersSent) {
+            return res.status(400).json({ error: 'Invalid JSON', status: 400 });
+        }
+    }
+    logger_1.default.error({ err, url: req.url, method: req.method }, 'Unhandled error');
+    if (res.headersSent) {
+        return next(err);
+    }
+    res.status(err.status || 500).json({
+        error: err.message || 'Internal Server Error',
+        status: err.status || 500,
+    });
+});
+async function main() {
+    const dbName = config_1.CONFIG.IS_DEV ? config_1.CONFIG.DB_NAME_DEV : config_1.CONFIG.DB_NAME_PROD;
+    const dbPath = path_1.default.join(config_1.CONFIG.ROOT, dbName);
+    const remoteFolder = config_1.CONFIG.IS_DEV ? config_1.CONFIG.REMOTE_FOLDER_DEV : config_1.CONFIG.REMOTE_FOLDER_PROD;
+    db = await (0, sync_1.initializeDatabase)(dbPath);
+    logger_1.default.info(`Database initialized at ${dbPath}`);
+    const rpcEnabledSetting = await settings_repository_1.SettingsRepository.getByKey(db, 'discordRPCEnabled');
+    const isRpcEnabled = rpcEnabledSetting ? rpcEnabledSetting.value === 'true' : true;
+    await discord_rpc_1.discordRPCService.setEnabled(isRpcEnabled);
+    discord_gateway_1.discordGatewayService.setEnabled(isRpcEnabled);
+    (0, anilist_1.checkAnilistStatus)().catch(() => { });
+    await runSyncSequence(db);
+    if (!fs_1.default.existsSync(config_1.CONFIG.LOCAL_MANIFEST_PATH)) {
+        fs_1.default.writeFileSync(config_1.CONFIG.LOCAL_MANIFEST_PATH, JSON.stringify({ version: 0 }));
+    }
+    let hasUnsyncedChanges = false;
+    const watcher = chokidar_1.default.watch(config_1.CONFIG.LOCAL_MANIFEST_PATH, {
+        persistent: true,
+        ignoreInitial: true,
+    });
+    const expressServer = app.listen(config_1.CONFIG.PORT, () => {
+        logger_1.default.info(`Server running on http://localhost:${config_1.CONFIG.PORT}`);
+    });
+    watcher.on('change', () => {
+        hasUnsyncedChanges = true;
+    });
+    const syncInterval = setInterval(async () => {
+        if (hasUnsyncedChanges) {
+            logger_1.default.info('Uploading accumulated database changes...');
+            hasUnsyncedChanges = false;
+            try {
+                await (0, sync_1.syncUp)(db, dbPath, remoteFolder);
+            }
+            catch (err) {
+                logger_1.default.error({ err }, 'Failed to upload database changes');
+                hasUnsyncedChanges = true;
+            }
+        }
+    }, 300000);
+    const shutdown = async (signal) => {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        stopDiscovery();
+        clearInterval(syncInterval);
+        discord_rpc_1.discordRPCService.disconnect();
+        discord_gateway_1.discordGatewayService.disconnect();
+        await watcher.close();
+        if (expressServer) {
+            expressServer.close();
+        }
+        if (hasUnsyncedChanges) {
+            logger_1.default.info('Sync on shutdown: uploading final database changes...');
+            hasUnsyncedChanges = false;
+            try {
+                await (0, sync_1.syncUp)(db, dbPath, remoteFolder);
+            }
+            catch (e) {
+                logger_1.default.error({ err: e }, 'Final sync on shutdown failed');
+            }
+        }
+        await (0, sync_1.waitForSync)();
+        db.close(() => {
+            (0, ipc_1.notifyServerExit)();
+            if (signal === 'SIGUSR2') {
+                process.kill(process.pid, 'SIGUSR2');
+            }
+        });
+    };
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGHUP', () => shutdown('SIGHUP'));
+    process.once('SIGUSR2', () => shutdown('SIGUSR2'));
+    app.post('/api/internal/shutdown', (req, res) => {
+        const isLoopback = req.ip === '::1' || req.ip === '127.0.0.1' || req.ip === '::ffff:127.0.0.1';
+        if (!isLoopback) {
+            res.status(403).json({ error: 'Forbidden' });
+            return;
+        }
+        const expectedToken = process.env.INTERNAL_SHUTDOWN_TOKEN;
+        const providedToken = req.headers['x-internal-token'];
+        if (expectedToken) {
+            const expBuf = Buffer.from(expectedToken);
+            const provBuf = Buffer.from(typeof providedToken === 'string' ? providedToken : '');
+            if (expBuf.length !== provBuf.length || !crypto_1.default.timingSafeEqual(expBuf, provBuf)) {
+                logger_1.default.warn('Unauthorized internal shutdown attempt rejected: invalid token');
+                res.status(403).json({ error: 'Forbidden' });
+                return;
+            }
+        }
+        res.status(200).json({ message: 'Shutting down' });
+        setTimeout(() => shutdown(), 500);
+    });
+}
+main().catch((err) => {
+    logger_1.default.error({ err }, 'Server failed to start');
+    process.exit(1);
+});

package/server/dist/shipped-defaults.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHIPPED_DEFAULTS = void 0;
+exports.SHIPPED_DEFAULTS = {
+    "GITHUB_CLIENT_ID": "Ov23liT1ZtPk7XtN9PZk",
+    "GOOGLE_AUTH_WORKER_URL": "https://google-auth-client.ramiserifpersia.workers.dev",
+    "DISCORD_CLIENT_ID": "1512253778022367426"
+};

package/server/dist/sync-config.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setActiveRemote = setActiveRemote;
+exports.getActiveRemote = getActiveRemote;
+exports.initialize = initialize;
+exports.getRemoteString = getRemoteString;
+const logger_1 = __importDefault(require("./logger"));
+const log = logger_1.default.child({ module: 'SyncConfig' });
+let activeRemote;
+function setActiveRemote(remote) {
+    log.info({ remote }, 'Setting active sync remote');
+    activeRemote = remote;
+}
+function getActiveRemote() {
+    return activeRemote;
+}
+async function initialize() {
+    if (activeRemote !== 'gdrive') {
+        log.info('Active remote is not gdrive, skipping gdrive-specific initialization.');
+        return;
+    }
+    log.info('gdrive is the active remote.');
+}
+function getRemoteString(remoteDir) {
+    if (!activeRemote) {
+        throw new Error('Cannot get remote string: active remote is not set.');
+    }
+    return `${activeRemote}:${remoteDir}`;
+}