@serifpersia/dango 3.3.9 → 3.4.0

package/server/dist/controllers/asmr-library.controller.js

@@ -1,288 +0,0 @@
-import logger from '../logger.js';
-import { performAsmrWriteTransaction } from '../sync.js';
-import { dbAll } from '../utils/db-utils.js';
-import { SettingsRepository } from '../repositories/settings.repository.js';
-import { buildAsmrId, ASMR_STATUSES, AsmrLibraryRepository, AsmrProgressRepository, } from '../repositories/asmr.repository.js';
-function asmrDb(req) {
-    const db = req.asmrDb;
-    if (!db || db.isClosedCheck())
-        throw new Error('ASMR database is not ready');
-    return db;
-}
-export class AsmrLibraryController {
-    getLibrary = async (req, res) => {
-        try {
-            const { status, page: pageStr, limit: limitStr } = req.query;
-            const page = Math.max(parseInt(pageStr) || 1, 1);
-            const limit = Math.min(Math.max(parseInt(limitStr) || 24, 1), 100);
-            const offset = (page - 1) * limit;
-            const db = asmrDb(req);
-            const rows = AsmrLibraryRepository.getAll(db, status, limit, offset);
-            const total = AsmrLibraryRepository.getCount(db, status);
-            res.json({ data: rows, total, page, limit });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to get ASMR library');
-            res.status(500).json({ error: 'Failed to load listening list' });
-        }
-    };
-    checkLibrary = async (req, res) => {
-        try {
-            const item = AsmrLibraryRepository.getById(asmrDb(req), req.params.id);
-            res.json({ inLibrary: !!item, status: item?.status ?? null });
-        }
-        catch {
-            res.json({ inLibrary: false, status: null });
-        }
-    };
-    getLibraryIds = async (req, res) => {
-        try {
-            res.json({ ids: AsmrLibraryRepository.getIds(asmrDb(req)) });
-        }
-        catch {
-            res.json({ ids: [] });
-        }
-    };
-    addToLibrary = async (req, res) => {
-        const { rjCode, id: idRaw, title, thumbnail, status, isAdult } = req.body ?? {};
-        const rawCode = String(rjCode || idRaw || '').trim();
-        if (!rawCode) {
-            return res.status(400).json({ error: 'rjCode is required' });
-        }
-        const id = idRaw && String(idRaw).trim() ? buildAsmrId(String(idRaw)) : buildAsmrId(rawCode);
-        const cleanStatus = typeof status === 'string' && ASMR_STATUSES.includes(status)
-            ? status
-            : 'Listening';
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrLibraryRepository.upsert(tx, {
-                    id,
-                    rjCode: buildAsmrId(rawCode),
-                    title: String(title || ''),
-                    thumbnail: String(thumbnail || ''),
-                    status: cleanStatus,
-                    isAdult: isAdult === true || isAdult === 1,
-                });
-            });
-            res.json({ success: true, id });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to add ASMR work to library');
-            res.status(500).json({ error: 'Failed to add to listening list' });
-        }
-    };
-    removeFromLibrary = async (req, res) => {
-        const { id } = req.body ?? {};
-        if (!id)
-            return res.status(400).json({ error: 'id is required' });
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrLibraryRepository.delete(tx, String(id));
-                AsmrProgressRepository.deleteByWork(tx, String(id));
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to remove ASMR work from library');
-            res.status(500).json({ error: 'Failed to remove from listening list' });
-        }
-    };
-    updateStatus = async (req, res) => {
-        const { id, status } = req.body ?? {};
-        if (!id || !ASMR_STATUSES.includes(status)) {
-            return res.status(400).json({ error: 'id and a valid status are required' });
-        }
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrLibraryRepository.updateStatus(tx, String(id), String(status));
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to update ASMR status');
-            res.status(500).json({ error: 'Failed to update status' });
-        }
-    };
-    getProgress = async (req, res) => {
-        try {
-            const rows = AsmrProgressRepository.getByWork(asmrDb(req), req.params.workId);
-            res.json({ progress: rows });
-        }
-        catch {
-            res.json({ progress: [] });
-        }
-    };
-    getLatestProgress = async (req, res) => {
-        try {
-            const row = AsmrProgressRepository.getLatest(asmrDb(req), req.params.workId);
-            res.json(row || { currentTime: 0, duration: 0 });
-        }
-        catch {
-            res.json({ currentTime: 0, duration: 0 });
-        }
-    };
-    saveProgress = async (req, res) => {
-        const { workId, trackIndex, trackLabel, currentTime, duration, title, thumbnail, rjCode, isAdult, } = req.body ?? {};
-        if (!workId) {
-            return res.status(400).json({ error: 'workId is required' });
-        }
-        const trackIndexNum = Math.max(Math.round(Number(trackIndex)) || 0, 0);
-        const timeNum = Math.max(Number(currentTime) || 0, 0);
-        const durationNum = Math.max(Number(duration) || 0, 0);
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrProgressRepository.upsert(tx, {
-                    workId: String(workId),
-                    trackIndex: trackIndexNum,
-                    trackLabel: String(trackLabel || ''),
-                    currentTime: timeNum,
-                    duration: durationNum,
-                    title: title ?? null,
-                    thumbnail: thumbnail ?? null,
-                    rjCode: rjCode ?? null,
-                    isAdult: isAdult != null ? Number(isAdult) : null,
-                });
-                AsmrLibraryRepository.touchProgress(tx, String(workId), {
-                    trackIndex: trackIndexNum,
-                    trackLabel: String(trackLabel || ''),
-                    position: timeNum,
-                });
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to save ASMR progress');
-            res.status(500).json({ error: 'Failed to save progress' });
-        }
-    };
-    getContinueListening = async (req, res) => {
-        try {
-            const limit = Math.min(Math.max(parseInt(req.query.limit) || 24, 1), 100);
-            const ignoreAdultRow = await SettingsRepository.getByKey(req.db, 'asmrIgnoreAdultContent');
-            const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
-            const listOnlyRow = await SettingsRepository.getByKey(req.db, 'asmrCwWatchlistOnly');
-            const listOnly = listOnlyRow
-                ? listOnlyRow.value === 'true' || listOnlyRow.value === '1'
-                : false;
-            const rows = AsmrProgressRepository.getContinueListening(asmrDb(req), limit).filter((row) => {
-                if (ignoreAdult && row.isAdult === 1)
-                    return false;
-                if (listOnly && row.watchlistStatus !== 'Listening')
-                    return false;
-                return true;
-            });
-            res.json({ data: rows, total: rows.length });
-        }
-        catch {
-            res.json({ data: [], total: 0 });
-        }
-    };
-    async getAdultNonListWorkIds(db) {
-        const rows = await dbAll(db, `SELECT DISTINCT p.workId as workId
-       FROM asmr_progress p
-       LEFT JOIN asmr_library l ON l.id = p.workId
-       WHERE COALESCE(l.isAdult, p.isAdult) = 1
-         AND l.id IS NULL`);
-        return rows.map((r) => r.workId);
-    }
-    getAdultContinueListeningCount = async (req, res) => {
-        try {
-            const ids = await this.getAdultNonListWorkIds(asmrDb(req));
-            res.json({ count: ids.length });
-        }
-        catch {
-            res.json({ count: 0 });
-        }
-    };
-    purgeAdultContinueListening = async (req, res) => {
-        try {
-            const ids = await this.getAdultNonListWorkIds(asmrDb(req));
-            if (ids.length > 0) {
-                await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                    for (const id of ids)
-                        AsmrProgressRepository.deleteByWork(tx, id);
-                });
-            }
-            res.json({ success: true, removed: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to purge adult ASMR progress');
-            res.status(500).json({ error: 'Failed to purge adult entries' });
-        }
-    };
-    removeProgress = async (req, res) => {
-        const { workId, trackIndex } = req.body ?? {};
-        if (!workId)
-            return res.status(400).json({ error: 'workId is required' });
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                if (trackIndex !== undefined && trackIndex !== null) {
-                    AsmrProgressRepository.deleteTrack(tx, String(workId), Number(trackIndex));
-                }
-                else {
-                    AsmrProgressRepository.deleteByWork(tx, String(workId));
-                }
-            });
-            res.json({ success: true });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to remove ASMR progress');
-            res.status(500).json({ error: 'Failed to reset progress' });
-        }
-    };
-    batchUpdateStatus = async (req, res) => {
-        const { ids: idsRaw, status } = req.body ?? {};
-        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
-            return res.status(400).json({ error: 'ids must be a non-empty array' });
-        }
-        if (!status || !ASMR_STATUSES.includes(status)) {
-            return res.status(400).json({ error: 'a valid status is required' });
-        }
-        const ids = idsRaw.map((id) => String(id));
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrLibraryRepository.updateStatusMany(tx, ids, String(status));
-            });
-            res.json({ success: true, updated: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to batch update ASMR status');
-            res.status(500).json({ error: 'Failed to update statuses' });
-        }
-    };
-    batchRemove = async (req, res) => {
-        const { ids: idsRaw } = req.body ?? {};
-        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
-            return res.status(400).json({ error: 'ids must be a non-empty array' });
-        }
-        const ids = idsRaw.map((id) => String(id));
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrLibraryRepository.deleteMany(tx, ids);
-                AsmrProgressRepository.deleteMany(tx, ids);
-            });
-            res.json({ success: true, removed: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to batch remove ASMR works');
-            res.status(500).json({ error: 'Failed to remove from listening list' });
-        }
-    };
-    batchRemoveProgress = async (req, res) => {
-        const { ids: idsRaw } = req.body ?? {};
-        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
-            return res.status(400).json({ error: 'ids must be a non-empty array' });
-        }
-        const ids = idsRaw.map((id) => String(id));
-        try {
-            await performAsmrWriteTransaction(asmrDb(req), (tx) => {
-                AsmrProgressRepository.deleteMany(tx, ids);
-            });
-            res.json({ success: true, removed: ids.length });
-        }
-        catch (err) {
-            logger.error({ err }, 'Failed to batch remove ASMR progress');
-            res.status(500).json({ error: 'Failed to reset progress' });
-        }
-    };
-}

package/server/dist/controllers/auth.controller.js

@@ -1,225 +0,0 @@
-import logger from '../logger.js';
-import { googleDriveService } from '../google.js';
-import { githubSyncService } from '../github-sync.js';
-import { initSyncProvider } from '../sync.js';
-import { CONFIG } from '../config.js';
-import { rcloneService } from '../rclone.js';
-export class AuthController {
-    runSyncSequence;
-    constructor(runSyncSequence) {
-        this.runSyncSequence = runSyncSequence;
-    }
-    getConfigStatus = (_req, res) => {
-        // New flow: Worker holds ID+secret, no local .env needed.
-        // Legacy fallback: user-owned GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET.
-        const useWorker = !!CONFIG.GOOGLE_AUTH_WORKER_URL;
-        const hasLegacyConfig = !!process.env.GOOGLE_CLIENT_ID && !!process.env.GOOGLE_CLIENT_SECRET;
-        res.json({ hasConfig: useWorker || hasLegacyConfig, useWorker });
-    };
-    getGoogleAuthSettings = (_req, res) => {
-        res.json({
-            useWorker: !!CONFIG.GOOGLE_AUTH_WORKER_URL,
-            hasCustomWorkerUrl: !!process.env.GOOGLE_AUTH_WORKER_URL,
-            hasCustomClientId: !!process.env.GOOGLE_CLIENT_ID,
-            hasClientSecret: !!process.env.GOOGLE_CLIENT_SECRET,
-        });
-    };
-    updateGoogleAuthSettings = async (req, res) => {
-        const { clientId, clientSecret, workerUrl } = req.body;
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        const updates = {};
-        if (typeof clientId === 'string') {
-            updates.GOOGLE_CLIENT_ID = clientId;
-        }
-        if (typeof clientSecret === 'string') {
-            updates.GOOGLE_CLIENT_SECRET = clientSecret;
-        }
-        if (typeof workerUrl === 'string') {
-            updates.GOOGLE_AUTH_WORKER_URL = workerUrl;
-        }
-        await updateEnvFile(updates);
-        if (typeof workerUrl === 'string') {
-            ;
-            CONFIG.GOOGLE_AUTH_WORKER_URL = workerUrl;
-        }
-        if (typeof clientId === 'string') {
-            ;
-            CONFIG.GOOGLE_CLIENT_ID = clientId || undefined;
-        }
-        if (typeof clientSecret === 'string') {
-            ;
-            CONFIG.GOOGLE_CLIENT_SECRET =
-                clientSecret || undefined;
-        }
-        await initSyncProvider();
-        res.json({ success: true });
-    };
-    getGitHubAuthOverride = (_req, res) => {
-        res.json({ hasCustomClientId: !!process.env.GITHUB_CLIENT_ID });
-    };
-    updateGitHubAuthSettings = async (req, res) => {
-        const { clientId } = req.body;
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        if (typeof clientId !== 'string') {
-            return res.status(400).json({ error: 'clientId required' });
-        }
-        await updateEnvFile({ GITHUB_CLIENT_ID: clientId });
-        res.json({ success: true });
-    };
-    getRcloneSettings = async (_req, res) => {
-        const remotes = await rcloneService.listRemotes();
-        res.json({
-            remote: CONFIG.RCLONE_REMOTE || '',
-            availableRemotes: remotes,
-            activeRemote: rcloneService.isActive() ? rcloneService.getRemoteName() : null,
-        });
-    };
-    getSyncSettings = async (_req, res) => {
-        const { getActiveProvider } = await import('../sync.js');
-        res.json({
-            activeProvider: process.env.SYNC_PROVIDER || 'default',
-            actualActiveProvider: getActiveProvider(),
-            authenticatedProviders: {
-                github: githubSyncService.isAuthenticated(),
-                google: googleDriveService.isAuthenticated(),
-                rclone: rcloneService.isActive(),
-            },
-        });
-    };
-    updateSyncProvider = async (req, res) => {
-        const { provider } = req.body;
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        const value = provider === 'default' ? '' : provider;
-        await updateEnvFile({ SYNC_PROVIDER: value });
-        await initSyncProvider();
-        res.json({ success: true, activeProvider: process.env.SYNC_PROVIDER || 'default' });
-    };
-    getGitHubAuthStatus = async (_req, res) => {
-        try {
-            const user = await githubSyncService.getUserProfile();
-            res.json({
-                authenticated: !!user,
-                user,
-                device: githubSyncService.getDeviceState(),
-                hasCustomClientId: !!process.env.GITHUB_CLIENT_ID,
-            });
-        }
-        catch (error) {
-            logger.error({ err: error }, 'Failed to fetch GitHub auth status');
-            res.json({
-                authenticated: false,
-                user: null,
-                device: githubSyncService.getDeviceState(),
-                hasCustomClientId: !!process.env.GITHUB_CLIENT_ID,
-            });
-        }
-    };
-    startGitHubDeviceAuth = async (req, res) => {
-        const mangaDb = req.mangaDb;
-        const runSync = this.runSyncSequence;
-        const state = await githubSyncService.startDeviceAuth(req.db, (db, provider) => runSync(db, mangaDb, provider));
-        res.json(state);
-    };
-    pollGitHubDeviceAuth = (_req, res) => {
-        res.json(githubSyncService.getDeviceState());
-    };
-    logoutGitHub = async (_req, res) => {
-        await githubSyncService.logout();
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        await updateEnvFile({ SYNC_PROVIDER: '' });
-        await initSyncProvider();
-        res.json({ success: true });
-    };
-    updateRcloneSettings = async (req, res) => {
-        const { remote } = req.body;
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        await updateEnvFile({
-            RCLONE_REMOTE: remote,
-            SYNC_PROVIDER: 'rclone',
-        });
-        await this.runSyncSequence(req.db, req.mangaDb, 'rclone');
-        res.json({ success: true });
-    };
-    getAuthUrl = async (_req, res) => {
-        const url = await googleDriveService.getAuthUrl();
-        res.json({ url });
-    };
-    loginGoogle = async (req, res) => {
-        if (googleDriveService.isAuthenticated()) {
-            const user = await googleDriveService.getUserProfile();
-            if (user) {
-                const { updateEnvFile } = await import('../utils/env.utils.js');
-                await updateEnvFile({ SYNC_PROVIDER: 'google' });
-                await this.runSyncSequence(req.db, req.mangaDb, 'google');
-                return res.json({ url: null, authenticated: true });
-            }
-            else {
-                logger.warn('Google tokens found but invalid. Clearing and requesting new auth.');
-                await googleDriveService.logout();
-            }
-        }
-        const url = await googleDriveService.getAuthUrl();
-        res.json({ url, authenticated: false });
-    };
-    handleCallback = async (req, res) => {
-        const code = req.query.code;
-        if (!code) {
-            return res.status(400).send('No code provided');
-        }
-        await googleDriveService.handleCallback(code);
-        const user = await googleDriveService.getUserProfile();
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        await updateEnvFile({ SYNC_PROVIDER: 'google' });
-        logger.info('User logged in. Syncing database (please wait)...');
-        try {
-            await this.runSyncSequence(req.db, req.mangaDb, 'google');
-        }
-        catch (err) {
-            logger.error({ err }, 'Post-login sync failed');
-        }
-        const responseHtml = `
-            <html>
-            <head><meta name="viewport" content="width=device-width, initial-scale=1" /></head>
-            <body>
-            <h1>Authentication Successful</h1>
-            <p>Database synced. Returning to dango...</p>
-            <p><a href="/?google_auth=success">Tap here if you are not redirected</a></p>
-            <script>
-            (function () {
-              var payload = { type: 'GOOGLE_AUTH_SUCCESS', user: ${JSON.stringify(user)} };
-              try {
-                if (window.opener && !window.opener.closed) {
-                  window.opener.postMessage(payload, window.location.origin);
-                  try {
-                    window.opener.postMessage(payload, 'http://localhost:${CONFIG.PORT}');
-                  } catch (e) {}
-                  try {
-                    window.opener.postMessage(payload, 'http://127.0.0.1:${CONFIG.PORT}');
-                  } catch (e) {}
-                  setTimeout(function () { window.close(); }, 300);
-                  setTimeout(function () { window.location.href = '/?google_auth=success'; }, 1500);
-                } else {
-                  window.location.href = '/?google_auth=success';
-                }
-              } catch (e) {
-                window.location.href = '/?google_auth=success';
-              }
-            })();
-            </script>
-            </body>
-            </html>
-            `;
-        res.send(responseHtml);
-    };
-    getUserProfile = async (_req, res) => {
-        const user = await googleDriveService.getUserProfile();
-        res.json(user);
-    };
-    logout = async (_req, res) => {
-        await googleDriveService.logout();
-        const { updateEnvFile } = await import('../utils/env.utils.js');
-        await updateEnvFile({ SYNC_PROVIDER: '' });
-        await initSyncProvider();
-        res.json({ success: true });
-    };
-}