@serifpersia/dango 3.3.4

package/server/dist/lib/tracker/sync.service.js

@@ -0,0 +1,496 @@
+import { AniListTracker } from './anilist-tracker.js';
+import { WatchlistRepository } from '../../repositories/watchlist.repository.js';
+import { WatchedEpisodesRepository } from '../../repositories/watched-episodes.repository.js';
+import { ShowsMetaRepository } from '../../repositories/shows-meta.repository.js';
+import { SettingsRepository } from '../../repositories/settings.repository.js';
+import { NotificationsRepository } from '../../repositories/notifications.repository.js';
+import { performWriteTransaction } from '../../sync.js';
+import { dbGet } from '../../utils/db-utils.js';
+import logger from '../../logger.js';
+import { fetchMalUserList } from '../mal.js';
+import { offlineDb } from '../offline-db.js';
+import { getShowMetaById, getShowMetaByMalId, isAnilistRateLimited, searchAnilistByTitle, } from '../anilist.js';
+import { kitsuSearchAnime } from '../kitsu.js';
+const TOKEN_KEY = 'tracker_anilist_token';
+const USER_KEY = 'tracker_anilist_user';
+const SYNC_STATE_KEY = 'tracker_anilist_sync_state';
+async function readSyncState(db) {
+    const row = await SettingsRepository.getByKey(db, SYNC_STATE_KEY);
+    if (!row?.value)
+        return {};
+    try {
+        return JSON.parse(row.value);
+    }
+    catch {
+        return {};
+    }
+}
+async function getWatchedCount(db, showId) {
+    const row = await dbGet(db, 'SELECT COUNT(DISTINCT episodeNumber) as total FROM watched_episodes WHERE showId = ?', [showId]);
+    return row?.total ?? 0;
+}
+function resolveStatus(localStatus, remoteStatus, remoteUpdated, localLastSync) {
+    if (remoteUpdated > localLastSync && remoteStatus !== localStatus) {
+        return { status: remoteStatus, pull: true };
+    }
+    if (remoteStatus !== localStatus) {
+        return { status: localStatus, pull: false };
+    }
+    return { status: localStatus, pull: false };
+}
+export async function syncAniList(db) {
+    const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
+    const token = tokenRow?.value;
+    if (!token)
+        throw new Error('AniList is not connected. Please log in first.');
+    const tracker = new AniListTracker(token);
+    const viewer = await tracker.getViewer();
+    const remoteEntries = await tracker.fetchUserAnimeList(viewer.id);
+    const localItems = await WatchlistRepository.getAll(db);
+    const syncState = await readSyncState(db);
+    const remoteByMediaId = new Map();
+    for (const entry of remoteEntries)
+        remoteByMediaId.set(entry.mediaId, entry);
+    const localByMediaId = new Map();
+    for (const item of localItems) {
+        const meta = (await ShowsMetaRepository.getById(db, item.id));
+        const anilistId = meta?.anilistId;
+        if (anilistId == null || !Number.isFinite(anilistId) || String(anilistId) !== String(item.id)) {
+            continue;
+        }
+        if (!localByMediaId.has(anilistId)) {
+            localByMediaId.set(anilistId, item);
+        }
+    }
+    const allMediaIds = new Set([
+        ...localByMediaId.keys(),
+        ...remoteByMediaId.keys(),
+        ...Object.keys(syncState)
+            .map((k) => Number.parseInt(k, 10))
+            .filter((n) => Number.isFinite(n)),
+    ]);
+    const summary = { pushed: 0, pulled: 0, merged: 0, unchanged: 0, errors: [] };
+    const watchlistUpserts = [];
+    const metaUpserts = [];
+    const watchedInserts = [];
+    const stateUpdates = {};
+    const watchlistDeletes = [];
+    const pushUpdates = [];
+    const remoteDeleteEntryIds = [];
+    const now = Math.floor(Date.now() / 1000);
+    for (const mediaId of allMediaIds) {
+        const local = localByMediaId.get(mediaId);
+        const remote = remoteByMediaId.get(mediaId);
+        const showId = String(mediaId);
+        try {
+            if (local && !remote) {
+                if (syncState[showId] && remoteEntries.length > 0) {
+                    watchlistDeletes.push(showId);
+                    stateUpdates[showId] = undefined;
+                    summary.pulled++;
+                    continue;
+                }
+                const watchedCount = await getWatchedCount(db, showId);
+                pushUpdates.push({
+                    mediaId,
+                    status: DANGO_STATUS_OR_FALLBACK(local.status),
+                    progress: watchedCount,
+                });
+                stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: now };
+                summary.pushed++;
+                continue;
+            }
+            if (!local && remote) {
+                if (syncState[showId]) {
+                    if (remote.entryId) {
+                        remoteDeleteEntryIds.push({ showId, entryId: remote.entryId });
+                        stateUpdates[showId] = undefined;
+                        summary.pushed++;
+                        continue;
+                    }
+                    stateUpdates[showId] = undefined;
+                    summary.pushed++;
+                    continue;
+                }
+                logger.debug({ mediaId, remoteStatus: remote.status }, '[AniList Sync] Remote only -> pulling to local');
+                const title = remote.title.english || remote.title.romaji || `Anime #${mediaId}`;
+                watchlistUpserts.push({
+                    id: showId,
+                    name: title,
+                    thumbnail: remote.coverImage ?? '',
+                    status: remote.status,
+                    nativeName: remote.title.native ?? '',
+                    englishName: remote.title.english ?? '',
+                    type: 'TV',
+                });
+                metaUpserts.push({
+                    id: showId,
+                    name: title,
+                    thumbnail: remote.coverImage,
+                    nativeName: remote.title.native,
+                    englishName: remote.title.english,
+                    episodeCount: remote.totalEpisodes,
+                    anilistId: mediaId,
+                    episodeDuration: remote.episodeDuration,
+                });
+                if (remote.progress > 0) {
+                    watchedInserts.push({ showId, from: 1, to: remote.progress, updatedAt: remote.updatedAt });
+                }
+                stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
+                summary.pulled++;
+                continue;
+            }
+            if (!local && !remote && syncState[showId]) {
+                stateUpdates[showId] = undefined;
+                continue;
+            }
+            if (local && remote) {
+                const watchedCount = await getWatchedCount(db, showId);
+                const localLastSync = syncState[showId]?.lastSyncedAt ?? 0;
+                const remoteUpdated = remote.updatedAt || 0;
+                const targetProgress = Math.max(watchedCount, remote.progress);
+                const shouldPushProgress = watchedCount > remote.progress;
+                const shouldPullProgress = remote.progress > watchedCount;
+                const { status: targetStatus, pull: pullStatus } = resolveStatus(local.status, remote.status, remoteUpdated, localLastSync);
+                const statusDiffers = remote.status !== local.status;
+                if (shouldPushProgress || (!pullStatus && statusDiffers)) {
+                    pushUpdates.push({
+                        mediaId,
+                        status: targetStatus,
+                        progress: targetProgress,
+                    });
+                    if (targetStatus !== local.status) {
+                        watchlistUpserts.push({
+                            id: showId,
+                            name: local.name,
+                            thumbnail: local.thumbnail ?? '',
+                            status: targetStatus,
+                            nativeName: local.nativeName ?? '',
+                            englishName: local.englishName ?? '',
+                            type: local.type ?? '',
+                        });
+                    }
+                    if (shouldPullProgress) {
+                        watchedInserts.push({
+                            showId,
+                            from: watchedCount + 1,
+                            to: targetProgress,
+                            updatedAt: remoteUpdated,
+                        });
+                    }
+                    stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: now };
+                    summary.merged++;
+                }
+                else if (pullStatus || shouldPullProgress) {
+                    if (targetStatus !== local.status) {
+                        watchlistUpserts.push({
+                            id: showId,
+                            name: local.name,
+                            thumbnail: local.thumbnail ?? '',
+                            status: targetStatus,
+                            nativeName: local.nativeName ?? '',
+                            englishName: local.englishName ?? '',
+                            type: local.type ?? '',
+                        });
+                    }
+                    if (shouldPullProgress) {
+                        watchedInserts.push({
+                            showId,
+                            from: watchedCount + 1,
+                            to: targetProgress,
+                            updatedAt: remoteUpdated,
+                        });
+                    }
+                    stateUpdates[showId] = { lastSyncedAt: now, remoteUpdatedAt: remoteUpdated };
+                    summary.merged++;
+                }
+                else {
+                    summary.unchanged++;
+                }
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn({ err, mediaId }, '[AniList Sync] Entry failed');
+            summary.errors.push(`${local?.name ?? `Media ${mediaId}`}: ${message}`);
+        }
+    }
+    if (pushUpdates.length > 0 || remoteDeleteEntryIds.length > 0 || watchlistDeletes.length > 0) {
+        const deleteCap = Math.max(5, Math.ceil(localItems.length * 0.1));
+        const totalDeletes = watchlistDeletes.length + remoteDeleteEntryIds.length;
+        if (totalDeletes > deleteCap) {
+            throw new Error(`AniList sync would delete ${totalDeletes} shows but only ${remoteEntries.length} were fetched. Aborting to protect your library — if you really removed that many shows on AniList, delete them locally first and sync again.`);
+        }
+    }
+    if (pushUpdates.length > 0) {
+        const batchSize = 10;
+        for (let i = 0; i < pushUpdates.length; i += batchSize) {
+            const batch = pushUpdates.slice(i, i + batchSize);
+            await tracker.batchUpdateMediaEntries(batch);
+        }
+    }
+    if (remoteDeleteEntryIds.length > 0) {
+        const deleteBatch = remoteDeleteEntryIds.map((r) => r.entryId);
+        const batchSize = 10;
+        for (let i = 0; i < deleteBatch.length; i += batchSize) {
+            const batch = deleteBatch.slice(i, i + batchSize);
+            await tracker.batchDeleteMediaEntries(batch);
+        }
+    }
+    if (watchlistUpserts.length > 0 ||
+        metaUpserts.length > 0 ||
+        watchedInserts.length > 0 ||
+        watchlistDeletes.length > 0 ||
+        Object.keys(stateUpdates).length > 0) {
+        await performWriteTransaction(db, (tx) => {
+            for (const item of watchlistUpserts) {
+                WatchlistRepository.upsert(tx, item);
+            }
+            for (const meta of metaUpserts) {
+                ShowsMetaRepository.upsert(tx, meta);
+            }
+            for (const w of watchedInserts) {
+                for (let ep = w.from; ep <= w.to; ep++) {
+                    WatchedEpisodesRepository.insertIfMissing(tx, {
+                        showId: w.showId,
+                        episodeNumber: String(ep),
+                        watchedAt: toSqliteDatetime(w.updatedAt),
+                    });
+                }
+            }
+            for (const id of watchlistDeletes) {
+                WatchlistRepository.delete(tx, id);
+                WatchedEpisodesRepository.deleteByShow(tx, id);
+                NotificationsRepository.deleteByShow(tx, id);
+            }
+            const mergedState = { ...syncState };
+            for (const [k, v] of Object.entries(stateUpdates)) {
+                if (v === undefined)
+                    delete mergedState[k];
+                else
+                    mergedState[k] = v;
+            }
+            SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(mergedState));
+        });
+    }
+    return summary;
+}
+function toSqliteDatetime(unixSeconds) {
+    if (!unixSeconds || unixSeconds <= 0)
+        return undefined;
+    return new Date(unixSeconds * 1000).toISOString().slice(0, 19).replace('T', ' ');
+}
+function DANGO_STATUS_OR_FALLBACK(status) {
+    const known = ['Watching', 'Completed', 'On-Hold', 'Dropped', 'Planned'];
+    return known.includes(status) ? status : undefined;
+}
+export async function importFromUsername(db, username, erase = false) {
+    const tokenRow = await SettingsRepository.getByKey(db, TOKEN_KEY);
+    const token = tokenRow?.value;
+    const tracker = new AniListTracker(token);
+    let entries;
+    if (token) {
+        const viewer = await tracker.getViewer();
+        entries = await tracker.fetchUserAnimeList(viewer.id);
+    }
+    else {
+        entries = await tracker.fetchUserAnimeList(username);
+    }
+    if (entries.length === 0)
+        return 0;
+    const now = Math.floor(Date.now() / 1000);
+    const syncState = await readSyncState(db);
+    await performWriteTransaction(db, (tx) => {
+        if (erase)
+            SettingsRepository.clearWatchlist(tx);
+        for (const remote of entries) {
+            const showId = String(remote.mediaId);
+            const title = remote.title.english || remote.title.romaji || `Anime #${remote.mediaId}`;
+            WatchlistRepository.upsert(tx, {
+                id: showId,
+                name: title,
+                thumbnail: remote.coverImage ?? '',
+                status: remote.status,
+                nativeName: remote.title.native ?? '',
+                englishName: remote.title.english ?? '',
+                type: 'TV',
+            });
+            ShowsMetaRepository.upsert(tx, {
+                id: showId,
+                name: title,
+                thumbnail: remote.coverImage,
+                nativeName: remote.title.native,
+                englishName: remote.title.english,
+                episodeCount: remote.totalEpisodes,
+                anilistId: remote.mediaId,
+            });
+            if (remote.progress > 0) {
+                for (let ep = 1; ep <= remote.progress; ep++) {
+                    WatchedEpisodesRepository.insertIfMissing(tx, {
+                        showId,
+                        episodeNumber: String(ep),
+                        watchedAt: toSqliteDatetime(remote.updatedAt),
+                    });
+                }
+            }
+            syncState[showId] = { lastSyncedAt: now, remoteUpdatedAt: remote.updatedAt };
+        }
+        SettingsRepository.upsert(tx, SYNC_STATE_KEY, JSON.stringify(syncState));
+    });
+    return entries.length;
+}
+function mapMalListStatus(status) {
+    switch (status) {
+        case 1:
+            return 'Watching';
+        case 2:
+            return 'Completed';
+        case 3:
+            return 'On-Hold';
+        case 4:
+            return 'Dropped';
+        case 6:
+            return 'Planned';
+        default:
+            return null;
+    }
+}
+async function searchTitleForMalImport(title) {
+    const result = await searchAnilistByTitle(title);
+    if (result)
+        return result.id;
+    if (isAnilistRateLimited()) {
+        try {
+            const fb = await kitsuSearchAnime({ query: title, page: 1, perPage: 5 });
+            if (fb.length > 0)
+                return fb[0].id > 0 ? fb[0].id : null;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return null;
+}
+export async function importFromMalUsername(db, username, options = {}) {
+    const { erase = false, useOfflineDb = true, skipFallback = false } = options;
+    const entries = await fetchMalUserList(username);
+    if (entries.length === 0)
+        return 0;
+    const shows = [];
+    const metas = [];
+    const watched = [];
+    const fallbackQueue = [];
+    for (const entry of entries) {
+        const status = mapMalListStatus(entry.status);
+        if (!status)
+            continue;
+        const offline = useOfflineDb ? offlineDb.getByMalId(entry.malId) : null;
+        if (offline) {
+            const showId = String(offline.anilistId);
+            const title = offline.title || entry.titleEnglish || entry.title || `MAL #${entry.malId}`;
+            shows.push({
+                id: showId,
+                name: title,
+                thumbnail: offline.thumbnail ?? entry.imageUrl ?? undefined,
+                status,
+                englishName: entry.titleEnglish ?? undefined,
+                type: offline.type ?? entry.type ?? undefined,
+            });
+            if (offline.thumbnail || offline.type || offline.genres) {
+                metas.push({
+                    id: showId,
+                    thumbnail: offline.thumbnail,
+                    type: offline.type,
+                    genres: offline.genres,
+                });
+            }
+            if (entry.watchedEpisodes > 0)
+                watched.push({ showId, progress: entry.watchedEpisodes });
+        }
+        else {
+            fallbackQueue.push(entry);
+        }
+    }
+    if (fallbackQueue.length > 0 && !skipFallback) {
+        const BATCH_SIZE = 5;
+        for (let i = 0; i < fallbackQueue.length; i += BATCH_SIZE) {
+            const batch = fallbackQueue.slice(i, i + BATCH_SIZE);
+            const results = await Promise.allSettled(batch.map(async (entry) => {
+                const byMal = await getShowMetaByMalId(entry.malId).catch(() => null);
+                if (byMal?.anilistId)
+                    return byMal;
+                const title = entry.titleEnglish || entry.title;
+                if (!title)
+                    return null;
+                const id = await searchTitleForMalImport(title);
+                if (!id)
+                    return null;
+                return getShowMetaById(String(id)).catch(() => null);
+            }));
+            results.forEach((r, idx) => {
+                if (r.status !== 'fulfilled' || !r.value)
+                    return;
+                const meta = r.value;
+                const entry = batch[idx];
+                const status = mapMalListStatus(entry.status);
+                if (!status)
+                    return;
+                const showId = meta.anilistId ? String(meta.anilistId) : meta._id;
+                const title = meta.names?.english ||
+                    meta.names?.romaji ||
+                    entry.titleEnglish ||
+                    entry.title ||
+                    `MAL #${entry.malId}`;
+                shows.push({
+                    id: showId,
+                    name: title,
+                    thumbnail: meta.thumbnail || entry.imageUrl || undefined,
+                    status,
+                    englishName: entry.titleEnglish ?? undefined,
+                    type: meta.type ?? entry.type ?? 'TV',
+                });
+                if (meta.thumbnail || meta.type) {
+                    metas.push({ id: showId, thumbnail: meta.thumbnail, type: meta.type });
+                }
+                if (entry.watchedEpisodes > 0)
+                    watched.push({ showId, progress: entry.watchedEpisodes });
+            });
+        }
+    }
+    if (shows.length > 0 || erase) {
+        await performWriteTransaction(db, (tx) => {
+            if (erase)
+                SettingsRepository.clearWatchlist(tx);
+            for (const show of shows) {
+                WatchlistRepository.upsert(tx, {
+                    id: show.id,
+                    name: show.name,
+                    thumbnail: show.thumbnail ?? '',
+                    status: show.status,
+                    nativeName: '',
+                    englishName: show.englishName ?? '',
+                    type: show.type ?? 'TV',
+                });
+            }
+            for (const meta of metas) {
+                if (meta.thumbnail || meta.type || meta.genres) {
+                    ShowsMetaRepository.upsert(tx, {
+                        id: meta.id,
+                        thumbnail: meta.thumbnail,
+                        type: meta.type,
+                        genres: meta.genres,
+                    });
+                }
+            }
+            for (const w of watched) {
+                for (let ep = 1; ep <= w.progress; ep++) {
+                    WatchedEpisodesRepository.insertIfMissing(tx, {
+                        showId: w.showId,
+                        episodeNumber: String(ep),
+                    });
+                }
+            }
+        });
+    }
+    return shows.length;
+}

package/server/dist/lib/ytmusic.js

@@ -0,0 +1,125 @@
+import fs from 'fs';
+import path from 'path';
+import { CONFIG } from '../config.js';
+import logger from '../logger.js';
+const COOKIE_PATH = path.join(CONFIG.ROOT, 'ytmusic_cookie.txt');
+let publicTube = null;
+let publicPromise = null;
+let publicFailedAt = 0;
+const PUBLIC_FAIL_COOLDOWN_MS = 60 * 1000;
+let authedTube = null;
+let ytModule = null;
+let shimReady = false;
+async function loadYoutube() {
+    if (!ytModule)
+        ytModule = await import('youtubei.js');
+    return ytModule;
+}
+async function ensureShim() {
+    if (shimReady)
+        return;
+    const { Platform, Log } = await loadYoutube();
+    Platform.shim.eval = (async (data) => new Function(data.output)());
+    Log.setLevel(Log.Level.ERROR);
+    shimReady = true;
+}
+function readCookie() {
+    try {
+        if (!fs.existsSync(COOKIE_PATH))
+            return null;
+        const raw = fs.readFileSync(COOKIE_PATH, 'utf-8').trim();
+        return raw || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getMusicCookie() {
+    return readCookie();
+}
+export function isParserVariantError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const name = err.constructor?.name;
+    if (name === 'ParsingError')
+        return true;
+    const msg = err instanceof Error ? err.message : String(err);
+    return /Expected node of any type|Cannot cast \S+ to one of|got ItemSection|is not valid JSON|Incorrect JSPB formatting/i.test(msg);
+}
+/** Public session: never signed in. Used for search/stream/home. */
+export function getInnertube() {
+    if (publicTube)
+        return Promise.resolve(publicTube);
+    if (Date.now() - publicFailedAt < PUBLIC_FAIL_COOLDOWN_MS) {
+        return Promise.reject(new Error('YouTube session unavailable (cooling down)'));
+    }
+    if (!publicPromise) {
+        publicPromise = (async () => {
+            const { Innertube } = await loadYoutube();
+            await ensureShim();
+            try {
+                const yt = await Innertube.create({ generate_session_locally: false });
+                publicTube = yt;
+                return yt;
+            }
+            catch (err) {
+                publicPromise = null;
+                publicFailedAt = Date.now();
+                throw err;
+            }
+        })();
+    }
+    return publicPromise;
+}
+/** Authenticated session built from the saved cookie. Null when not signed in. */
+export async function getAuthedInnertube() {
+    const cookie = readCookie();
+    if (!cookie) {
+        authedTube = null;
+        return null;
+    }
+    if (authedTube)
+        return authedTube;
+    await ensureShim();
+    const { Innertube } = await loadYoutube();
+    authedTube = await Innertube.create({ cookie });
+    return authedTube;
+}
+export function getMusicAuthStatus() {
+    return { authenticated: readCookie() !== null };
+}
+export async function saveMusicCookie(cookie) {
+    const clean = cookie.trim();
+    if (!clean)
+        throw new Error('Cookie is empty');
+    await ensureShim();
+    const { Innertube } = await loadYoutube();
+    const trial = await Innertube.create({ cookie: clean });
+    try {
+        await trial.music.getLibrary();
+    }
+    catch (err) {
+        if (!isParserVariantError(err))
+            throw err;
+        logger.warn('[ytmusic] sign-in validation hit a layout variant, accepting cookie anyway');
+    }
+    try {
+        fs.mkdirSync(CONFIG.ROOT, { recursive: true });
+    }
+    catch {
+        // ignore
+    }
+    fs.writeFileSync(COOKIE_PATH, clean, 'utf-8');
+    authedTube = trial;
+    logger.info('[ytmusic] cookie sign-in validated and saved');
+}
+export async function signOutMusic() {
+    try {
+        if (fs.existsSync(COOKIE_PATH))
+            fs.unlinkSync(COOKIE_PATH);
+    }
+    catch {
+        // ignore
+    }
+    authedTube = null;
+}

package/server/dist/logger.js

@@ -0,0 +1,16 @@
+import pino from 'pino';
+const isDevelopment = process.argv.includes('--dev') || process.env.NODE_ENV === 'development';
+const logger = isDevelopment
+    ? pino({
+        level: 'debug',
+        transport: {
+            target: 'pino-pretty',
+            options: {
+                colorize: true,
+                translateTime: 'SYS:standard',
+                ignore: 'pid,hostname',
+            },
+        },
+    })
+    : pino({ level: process.env.LOG_LEVEL || 'info' });
+export default logger;

package/server/dist/providers/manga/manga.types.js

@@ -0,0 +1,7 @@
+export const SAFE_RATINGS = ['safe'];
+export const MATURE_RATINGS = [
+    'safe',
+    'suggestive',
+    'erotica',
+    'pornographic',
+];

package/server/dist/providers/provider.interface.js

@@ -0,0 +1 @@
+export {};